jherax/arrayFilterFactory.1.ts

## arrayFilterFactory.1.ts
type FilterOperator = 'AND' | 'OR';
type FiltersBy<T> = {
  [K in keyof T]?: (value: T[K]) => boolean;
};

/**
 * Factory function that creates a specialized function to filter
 * arrays, by validating all filters (AND operator),
 * or validating just one of the filters (OR operator).
 * @param operator Method to validate all filters: AND, OR
 * @returns Specialized function
 */
function arrayFilterFactory(operator: FilterOperator) {
  const method = operator === 'AND' ? 'every' : 'some';

  /**
   * Filters an array of objects using custom predicates.
   * @param array List of elements to filter
   * @param filters Object with predicates as filters
   * @returns Filtered array
   */
  return function filterArrayBy<T>(array: T[], filters: FiltersBy<T>): T[] {
    const filterKeys = Object.keys(filters);
    return array.filter(item => {
      // validates filters (AND|OR operator)
      return filterKeys[method](prop => {
        return filters[prop](item[prop]);
      });
    });
  };
}


## arrayFilterFactory.2.test.ts
describe('Testing arrayFilterFactory()', () => {
  const arrayFilterEvery = arrayFilterFactory('AND');
  const arrayFilterSome = arrayFilterFactory('OR');

  type Person = {
    age: number;
    name: string;
    email: string;
    nation: string;
  };

  const users: Person[] = [
    {age: 28, name: 'John', email: 'johnson@mail.com', nation: 'USA'},
    {age: 38, name: 'Marlin', email: 'marlin@mail.com', nation: 'England'},
    {age: 35, name: 'Tom', email: 'tom@mail.com', nation: 'England'},
    {age: 28, name: 'Mark', email: 'mark@mail.com', nation: 'England'},
  ];

  it('should filter an array of objects validating just one of the filters', () => {
    // filters are applied using OR operator
    const filters: FiltersBy<Person> = {
      nation: country => country.toUpperCase() === 'USA',
      age: age => age < 30,
    };

    const expected: Person[] = [
      {age: 28, name: 'John', email: 'johnson@mail.com', nation: 'USA'},
      {age: 28, name: 'Mark', email: 'mark@mail.com', nation: 'England'},
    ];

    const filtered = arrayFilterSome(users, filters);
    expect(filtered).toStrictEqual(expected);
  });

  it('should filter an array of objects validating all filters', () => {
    // filters are applied using OR operator
    const filters: FiltersBy<Person> = {
      age: age => age < 30,
      nation: country => country.toUpperCase() === 'USA',
    };

    const expected: Person[] = [
      {age: 28, name: 'John', email: 'johnson@mail.com', nation: 'USA'},
    ];

    const filtered = arrayFilterEvery(users, filters);
    expect(filtered).toStrictEqual(expected);
  });
});

## filterArrayBy.1.ts
/**
 * Filters an array of objects using custom predicates.
 * @param array List of elements to filter
 * @param filters Object with predicates as filters
 * @returns Filtered array
 */
function filterArrayBy<T>(array: T[], filters: FiltersBy<T>): T[] {
  const filterKeys = Object.keys(filters);
  return array.filter(item => {
    // validates all filters (AND operator)
    return filterKeys.every(prop => {
      return filters[prop](item[prop]);
    });
  });
}

type FiltersBy<T> = {
  [K in keyof T]?: (value: T[K]) => boolean;
};

## filterArrayBy.2.test.ts
type Product = {
  name: string;
  color: string;
  size: number;
  locations: string[];
  details: {length: number; width: number};
};

describe('Testing filterArrayBy()', () => {
  it('should filter an array of products by multiple properties', () => {
    const products: Product[] = [
      { name: 'A', color: 'Blue', size: 50, locations: ['USA', 'Europe'], details: { length: 20, width: 70 } },
      { name: 'B', color: 'Blue', size: 60, locations: [], details: { length: 20, width: 70 } },
      { name: 'C', color: 'Black', size: 70, locations: ['Japan'], details: { length: 20, width: 71 } },
      { name: 'D', color: 'Green', size: 50, locations: ['USA'], details: { length: 20, width: 71 } },
    ];

    // filters are applied using AND operator
    const filters: FiltersBy<Product> = {
      size: size => size === 50 || size === 70,
      color: color => ['blue', 'black'].includes(color.toLowerCase()),
      locations: locations => !!locations.find(c => ['japan', 'usa'].includes(c.toLowerCase())),
      details: details => details.length < 30 && details.width >= 70,
    };

    const expected: Product[] = [
      { name: 'A', color: 'Blue', size: 50, locations: ['USA', 'Europe'], details: { length: 20, width: 70 } },
      { name: 'C', color: 'Black', size: 70, locations: ['Japan'], details: { length: 20, width: 71 } },
    ];

    const filtered = filterArrayBy(products, filters);
    expect(filtered).toStrictEqual(expected);
  });
});

## filterArrayByEq.1.ts
const value = <T>(v: T) => (typeof v === 'string' ? v.toUpperCase() : v);

/**
 * Filters an array of objects using a list of valid values.
 * @param array List of elements to filter
 * @param filters Object whith lists of valid values
 * @returns Filtered array
 */
function filterArrayByEq<T extends {[key: string]: unknown}>(
  array: T[],
  filters: FiltersByEq<T>,
): T[] {
  const filterKeys = Object.keys(filters);
  return array.filter(item => {
    // validates all filters (AND operator)
    return filterKeys.every(key => {
      // ignores empty filters
      if (!filters[key].length) return true;
      return filters[key].find(f => value(f) === value(item[key]));
    });
  });
}

type FiltersByEq<T> = {
  [K in keyof T]?: T[K][];
};

## filterArrayByEq.2.test.ts
type Product = {
  name: string;
  color: string;
  size: number;
};

describe('Testing filterArrayByEq()', () => {
  it('should filter an array of objects using a list of valid values', () => {
    const products: Product[] = [
      {name: 'A', color: 'Blue', size: 50},
      {name: 'B', color: 'Blue', size: 60},
      {name: 'C', color: 'Black', size: 70},
      {name: 'D', color: 'Green', size: 50},
    ];

    // Filters are applied using AND operator.
    // Each filter uses a list of valid values, compared using === operator.
    // String values are not case-sensitive.
    const filters: FiltersByEq<Product> = {
      color: ['BLUE', 'black'],
      size: [70, 50],
    };

    const expected: Product[] = [
      {name: 'A', color: 'Blue', size: 50},
      {name: 'C', color: 'Black', size: 70},
    ];

    const filtered = filterArrayByEq(products, filters);
    expect(filtered).toStrictEqual(expected);
  });
});
	type FilterOperator = 'AND' \| 'OR';
	type FiltersBy<T> = {
	[K in keyof T]?: (value: T[K]) => boolean;
	};

	/**
	* Factory function that creates a specialized function to filter
	* arrays, by validating all filters (AND operator),
	* or validating just one of the filters (OR operator).
	* @param operator Method to validate all filters: AND, OR
	* @returns Specialized function
	*/
	function arrayFilterFactory(operator: FilterOperator) {
	const method = operator === 'AND' ? 'every' : 'some';

	/**
	* Filters an array of objects using custom predicates.
	* @param array List of elements to filter
	* @param filters Object with predicates as filters
	* @returns Filtered array
	*/
	return function filterArrayBy<T>(array: T[], filters: FiltersBy<T>): T[] {
	const filterKeys = Object.keys(filters);
	return array.filter(item => {
	// validates filters (AND\|OR operator)
	return filterKeys[method](prop => {
	return filters[prop](item[prop]);
	});
	});
	};
	}
	describe('Testing arrayFilterFactory()', () => {
	const arrayFilterEvery = arrayFilterFactory('AND');
	const arrayFilterSome = arrayFilterFactory('OR');

	type Person = {
	age: number;
	name: string;
	email: string;
	nation: string;
	};

	const users: Person[] = [
	{age: 28, name: 'John', email: 'johnson@mail.com', nation: 'USA'},
	{age: 38, name: 'Marlin', email: 'marlin@mail.com', nation: 'England'},
	{age: 35, name: 'Tom', email: 'tom@mail.com', nation: 'England'},
	{age: 28, name: 'Mark', email: 'mark@mail.com', nation: 'England'},
	];

	it('should filter an array of objects validating just one of the filters', () => {
	// filters are applied using OR operator
	const filters: FiltersBy<Person> = {
	nation: country => country.toUpperCase() === 'USA',
	age: age => age < 30,
	};

	const expected: Person[] = [
	{age: 28, name: 'John', email: 'johnson@mail.com', nation: 'USA'},
	{age: 28, name: 'Mark', email: 'mark@mail.com', nation: 'England'},
	];

	const filtered = arrayFilterSome(users, filters);
	expect(filtered).toStrictEqual(expected);
	});

	it('should filter an array of objects validating all filters', () => {
	// filters are applied using OR operator
	const filters: FiltersBy<Person> = {
	age: age => age < 30,
	nation: country => country.toUpperCase() === 'USA',
	};

	const expected: Person[] = [
	{age: 28, name: 'John', email: 'johnson@mail.com', nation: 'USA'},
	];

	const filtered = arrayFilterEvery(users, filters);
	expect(filtered).toStrictEqual(expected);
	});
	});
	type Product = {
	name: string;
	color: string;
	size: number;
	locations: string[];
	details: {length: number; width: number};
	};

	describe('Testing filterArrayBy()', () => {
	it('should filter an array of products by multiple properties', () => {
	const products: Product[] = [
	{ name: 'A', color: 'Blue', size: 50, locations: ['USA', 'Europe'], details: { length: 20, width: 70 } },
	{ name: 'B', color: 'Blue', size: 60, locations: [], details: { length: 20, width: 70 } },
	{ name: 'C', color: 'Black', size: 70, locations: ['Japan'], details: { length: 20, width: 71 } },
	{ name: 'D', color: 'Green', size: 50, locations: ['USA'], details: { length: 20, width: 71 } },
	];

	// filters are applied using AND operator
	const filters: FiltersBy<Product> = {
	size: size => size === 50 \|\| size === 70,
	color: color => ['blue', 'black'].includes(color.toLowerCase()),
	locations: locations => !!locations.find(c => ['japan', 'usa'].includes(c.toLowerCase())),
	details: details => details.length < 30 && details.width >= 70,
	};

	const expected: Product[] = [
	{ name: 'A', color: 'Blue', size: 50, locations: ['USA', 'Europe'], details: { length: 20, width: 70 } },
	{ name: 'C', color: 'Black', size: 70, locations: ['Japan'], details: { length: 20, width: 71 } },
	];

	const filtered = filterArrayBy(products, filters);
	expect(filtered).toStrictEqual(expected);
	});
	});
	const value = <T>(v: T) => (typeof v === 'string' ? v.toUpperCase() : v);

	/**
	* Filters an array of objects using a list of valid values.
	* @param array List of elements to filter
	* @param filters Object whith lists of valid values
	* @returns Filtered array
	*/
	function filterArrayByEq<T extends {[key: string]: unknown}>(
	array: T[],
	filters: FiltersByEq<T>,
	): T[] {
	const filterKeys = Object.keys(filters);
	return array.filter(item => {
	// validates all filters (AND operator)
	return filterKeys.every(key => {
	// ignores empty filters
	if (!filters[key].length) return true;
	return filters[key].find(f => value(f) === value(item[key]));
	});
	});
	}

	type FiltersByEq<T> = {
	[K in keyof T]?: T[K][];
	};