@3dsource/utils 0.0.1

package/src/lib/math/calculateMedian.ts

@@ -0,0 +1,33 @@
+/**
+ * Calculates the median of an array of numbers.
+ *
+ * The median is the middle value of a sorted list of numbers. If the list has an even number
+ * of elements, the median is the average of the two middle numbers.
+ *
+ * @param numbers - An array of numbers for which the median will be calculated.
+ * @returns The median value as a number, or `null` if the array is empty.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [3, 1, 4, 2];
+ * const median = calculateMedian(numbers);
+ * console.log(median); // Output: 2.5
+ * ```
+ */
+export function calculateMedian(numbers: number[]): number {
+  if (numbers.length === 0) return 0;
+
+  // Sort the array in ascending order
+  const sorted = [...numbers].sort((a, b) => a - b);
+
+  const length = sorted.length;
+  const middle = Math.floor(length / 2);
+
+  // If the length is even, return the average of the two middle numbers
+  if (length % 2 === 0) {
+    return (sorted[middle - 1] + sorted[middle]) / 2;
+  }
+
+  // If the length is odd, return the middle number
+  return sorted[middle];
+}

package/src/lib/math/circularIndex.ts

@@ -0,0 +1,39 @@
+import { clampf } from './clampf';
+
+/**
+ * Computes a circular index within a given range.
+ *
+ * This function ensures that the index wraps around within the range of 0 to `totalItems - 1`.
+ * It uses the `clampf` function to clamp the result within the valid range.
+ *
+ * @param index - The current index to be wrapped.
+ * @param totalItems - The total number of items in the range.
+ * @returns The wrapped index within the range of 0 to `totalItems - 1`.
+ *
+ * @example
+ * ```typescript
+ * import { circularIndex } from './circularIndex';
+ *
+ * // Example 1: Basic usage
+ * const index1 = circularIndex(5, 5);
+ * console.log(index1); // Output: 0
+ *
+ * // Example 2: Index greater than totalItems
+ * const index2 = circularIndex(6, 5);
+ * console.log(index2); // Output: 1
+ *
+ * // Example 3: Negative index
+ * const index3 = circularIndex(-2, 5);
+ * console.log(index3); // Output: 3
+ *
+ * // Example 4: Large Negative index
+ * const index4 = circularIndex(-6, 5);
+ * console.log(index4); // Output: 4
+ *
+ * // Example 5: Index equal to totalItems
+ * const index5 = circularIndex(1, 1);
+ * console.log(index5); // Output: 0
+ */
+export function circularIndex(index: number, totalItems: number): number {
+  return clampf(0, totalItems - 1, (totalItems * 2 + index) % totalItems);
+}

package/src/lib/math/clampf.ts

@@ -0,0 +1,14 @@
+/**
+ * Clamps value between min and max;
+ * @param min minValue
+ * @param max maxValue
+ * @param value inputValue
+ * @returns number
+ */
+
+export function clampf(min: number, max: number, value: number): number {
+  if (min > max) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, value));
+}

package/src/lib/math/degrees.ts

@@ -0,0 +1,7 @@
+export function degreesToRadians(degrees: number): number {
+  return degrees * (Math.PI / 180);
+}
+
+export function radiansToDegrees(radians: number): number {
+  return radians * (180 / Math.PI);
+}

package/src/lib/math/floatCompare.ts

@@ -0,0 +1,69 @@
+/**
+ * A small epsilon value used for floating-point comparisons.
+ *
+ * @remarks
+ * The value of `EPSILON` is `0.01`. This can be overridden in the comparison functions if needed.
+ */
+const EPSILON = 0.01;
+
+/**
+ * Checks if floating-point number `A` is less than `B` considering a small margin of error.
+ *
+ * @param A - The first floating-point number to compare.
+ * @param B - The second floating-point number to compare.
+ * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
+ * @returns `true` if `A` is less than `B` considering the epsilon margin, otherwise `false`.
+ *
+ * @example
+ * ```
+ * const result = fpIsALessThanB(0.0034, 0.0066); // true
+ * ```
+ */
+export function fpIsALessThanB(
+  A: number,
+  B: number,
+  Epsilon?: number,
+): boolean {
+  Epsilon = Epsilon || EPSILON;
+  return A - B < Epsilon && Math.abs(A - B) > Epsilon;
+}
+
+/**
+ * Checks if floating-point number `A` is greater than `B` considering a small margin of error.
+ *
+ * @param A - The first floating-point number to compare.
+ * @param B - The second floating-point number to compare.
+ * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
+ * @returns `true` if `A` is greater than `B` considering the epsilon margin, otherwise `false`.
+ *
+ * @example
+ * ```
+ * const result = fpIsAGreaterThanB(0.0066, 0.0034); // true
+ * ```
+ */
+export function fpIsAGreaterThanB(
+  A: number,
+  B: number,
+  Epsilon?: number,
+): boolean {
+  Epsilon = Epsilon || EPSILON;
+  return A - B > Epsilon && Math.abs(A - B) > Epsilon;
+}
+
+/**
+ * Checks if floating-point number `A` is approximately the same as `B` considering a small margin of error.
+ *
+ * @param A - The first floating-point number to compare.
+ * @param B - The second floating-point number to compare.
+ * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
+ * @returns `true` if `A` is approximately equal to `B` considering the epsilon margin, otherwise `false`.
+ *
+ * @example
+ * ```
+ * const result = fpIsASameAsB(0.005, 0.0051); // true
+ * ```
+ */
+export function fpIsASameAsB(A: number, B: number, Epsilon?: number): boolean {
+  Epsilon = Epsilon || EPSILON;
+  return Math.abs(A - B) < Epsilon;
+}

package/src/lib/math/index.ts

@@ -0,0 +1,8 @@
+export * from './baseSortedIndex';
+export * from './calculateMedian';
+export * from './circularIndex';
+export * from './clampf';
+export * from './degrees';
+export * from './floatCompare';
+export * from './inverseLerp';
+export * from './lerp';

package/src/lib/math/inverseLerp.ts

@@ -0,0 +1,38 @@
+/**
+ * Performs an inverse linear interpolation.
+ *
+ * Given a range defined by `min` and `max`, this function calculates the
+ * interpolation factor (or percentage) of `value` within that range. Optionally,
+ * it can clamp the result to be between 0 and 1 to ensure the return value is
+ * within the range of a standard lerp operation.
+ *
+ * @param {number} min - The minimum value of the interpolation range.
+ * @param {number} max - The maximum value of the interpolation range.
+ * @param {number} value - The value to interpolate.
+ * @param {boolean} [clampToNormal=false] - Whether to clamp the result between 0 and 1.
+ * @returns {number} The interpolation factor of `value` between `min` and `max`.
+ * If `clampToNormal` is true, the result is clamped between 0 and 1.
+ * If the difference between `min` and `max` is 0, returns 1 to avoid division by zero.
+ */
+export function inverseLerp(
+  min: number,
+  max: number,
+  value: number,
+  clampToNormal = false,
+): number {
+  if (clampToNormal) {
+    value = Math.min(max, value);
+    value = Math.max(min, value);
+  }
+  const difference = max - min;
+
+  // Avoid JS division error
+  if (difference === 0) {
+    return 1;
+  }
+  const result = (value - min) / difference;
+  if (clampToNormal) {
+    return Math.min(1, Math.max(0, result));
+  }
+  return result;
+}

package/src/lib/math/lerp.ts

@@ -0,0 +1,12 @@
+import { clampf } from './clampf';
+
+/**
+ * @param min minimums
+ * @param max maximums
+ * @param value current float value in 0-1 range
+ * @returns clamped value
+ */
+export function lerp(min: number, max: number, value: number): number {
+  value = clampf(0, 1, value);
+  return value * (max - min) + min;
+}

package/src/lib/math/test/baseSortedIndex.spec.ts

@@ -0,0 +1,43 @@
+import { baseSortedIndex } from '../baseSortedIndex';
+
+describe('baseSortedIndex', () => {
+  it('should return the correct insertion index in a sorted array', () => {
+    const array = [10, 20, 30, 40, 50];
+    const value = 35;
+    const index = baseSortedIndex(array, value);
+    expect(index).toBe(3); // 35 should be inserted at index 3 to maintain sorted order
+  });
+
+  it('should handle empty arrays', () => {
+    const array: number[] = [];
+    const value = 10;
+    const index = baseSortedIndex(array, value);
+    expect(index).toBe(0); // In an empty array, the insertion index is always 0
+  });
+
+  it('should place value at the start if less than all elements', () => {
+    const array = [10, 20, 30, 40, 50];
+    const value = 5;
+    const index = baseSortedIndex(array, value);
+    expect(index).toBe(0); // 5 should be inserted at index 0
+  });
+
+  it('should place value at the end if greater than all elements', () => {
+    const array = [10, 20, 30, 40, 50];
+    const value = 60;
+    const index = baseSortedIndex(array, value);
+    expect(index).toBe(5); // 60 should be inserted at index 5, which is the array's length
+  });
+
+  it('should handle arrays with the maximum safe size', () => {
+    // Assuming a simplified scenario for demonstration, as actually filling an array to max length would be impractical
+    const array = [1, 2]; // Simulate a sorted array
+    const value = 2;
+    // Manually set the array length to mimic a large array scenario
+    Object.defineProperty(array, 'length', { value: Math.pow(2, 31) - 1 });
+    const index = baseSortedIndex(array, value);
+    // The expected index would depend on the actual implementation and purpose of handling large arrays
+    // For this example, we'll assume it should return the position based on the 'value' in a sorted array logic
+    expect(index).not.toBeUndefined(); // Adjust this based on the actual intended behavior for large arrays
+  });
+});

package/src/lib/math/test/circularIndex.spec.ts

@@ -0,0 +1,38 @@
+import { circularIndex } from '../circularIndex';
+
+describe('circularIndex', () => {
+  it('should return 0', () => {
+    expect(circularIndex(5, 5)).toBe(0);
+  });
+
+  it('should return 1', () => {
+    expect(circularIndex(6, 5)).toBe(1);
+  });
+
+  it('should return 4', () => {
+    expect(circularIndex(-1, 5)).toBe(4);
+  });
+
+  it('should return 3', () => {
+    expect(circularIndex(-2, 5)).toBe(3);
+  });
+  it('should return 4', () => {
+    expect(circularIndex(-6, 5)).toBe(4);
+  });
+  it('should return 1', () => {
+    expect(circularIndex(11, 5)).toBe(1);
+  });
+
+  it('should return 0', () => {
+    expect(circularIndex(1, 1)).toBe(0);
+  });
+  it('should return 0', () => {
+    expect(circularIndex(2, 1)).toBe(0);
+  });
+  it('should return 0', () => {
+    expect(circularIndex(-2, 1)).toBe(0);
+  });
+  it('should return 0', () => {
+    expect(circularIndex(10, 0)).toBe(0);
+  });
+});

package/src/lib/mutex/Mutex.ts

@@ -0,0 +1,50 @@
+/**
+ * A Mutex class to handle mutual exclusion locks, ensuring that only one asynchronous task can execute a critical section at a time.
+ *
+ * @example
+ * const mutex = new Mutex();
+ *
+ * async function task(name: string, duration: number) {
+ *   console.log(`${name} waiting to acquire mutex`);
+ *   const release = await mutex.acquire();
+ *   console.log(`${name} acquired mutex`);
+ *   await new Promise(resolve => setTimeout(resolve, duration));
+ *   console.log(`${name} releasing mutex`);
+ *   release();
+ * }
+ *
+ * task('Task 1', 1000);
+ * task('Task 2', 2000);
+ * task('Task 3', 1500);
+ * task('Task 4', 500);
+ *
+ * Outputs
+ * [LOG]: "Task 1 waiting to acquire mutex"
+ * [LOG]: "Task 2 waiting to acquire mutex"
+ * [LOG]: "Task 3 waiting to acquire mutex"
+ * [LOG]: "Task 4 waiting to acquire mutex"
+ * [LOG]: "Task 1 acquired mutex"
+ * [LOG]: "Task 1 releasing mutex"
+ * [LOG]: "Task 2 acquired mutex"
+ * [LOG]: "Task 2 releasing mutex"
+ * [LOG]: "Task 3 acquired mutex"
+ * [LOG]: "Task 3 releasing mutex"
+ * [LOG]: "Task 4 acquired mutex"
+ * [LOG]: "Task 4 releasing mutex"
+ */
+export class Mutex {
+  private mutex = Promise.resolve();
+
+  /**
+   * Acquires the mutex, returning a promise that resolves when the mutex is acquired.
+   * The returned promise provides a release function that should be called to release the mutex.
+   * @returns A promise that resolves with a release function.
+   */
+  async acquire(): Promise<() => void> {
+    let release: () => void;
+    const previous = this.mutex;
+    this.mutex = new Promise<void>((resolve) => (release = resolve));
+    await previous;
+    return release!;
+  }
+}

package/src/lib/mutex/Semaphore.ts

@@ -0,0 +1,62 @@
+/**
+ * A Semaphore controls access to a resource that can handle a limited number of concurrent operations.
+ *
+ * @example
+ * const semaphore = new Semaphore(2);
+ *
+ * async function task(name: string, duration: number) {
+ *   console.log(`${name} waiting to acquire semaphore`);
+ *   await semaphore.acquire();
+ *   console.log(`${name} acquired semaphore`);
+ *   await new Promise(resolve => setTimeout(resolve, duration));
+ *   console.log(`${name} releasing semaphore`);
+ *   semaphore.release();
+ * }
+ *
+ * task('Task 1', 1000);
+ * task('Task 2', 2000);
+ * task('Task 3', 1500);
+ * task('Task 4', 500);
+ *
+ * Outputs
+ * [LOG]: "Task 1 waiting to acquire semaphore"
+ * [LOG]: "Task 2 waiting to acquire semaphore"
+ * [LOG]: "Task 3 waiting to acquire semaphore"
+ * [LOG]: "Task 4 waiting to acquire semaphore"
+ * [LOG]: "Task 1 acquired semaphore"
+ * [LOG]: "Task 2 acquired semaphore"
+ * [LOG]: "Task 1 releasing semaphore"
+ * [LOG]: "Task 3 acquired semaphore"
+ * [LOG]: "Task 2 releasing semaphore"
+ * [LOG]: "Task 4 acquired semaphore"
+ * [LOG]: "Task 4 releasing semaphore"
+ * [LOG]: "Task 3 releasing semaphore"
+ */
+export class Semaphore {
+  private tasks: (() => void)[] = [];
+  private currentCount = 0;
+
+  constructor(private readonly maxConcurrency: number) {}
+
+  public acquire(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.currentCount < this.maxConcurrency) {
+        this.currentCount++;
+        resolve();
+      } else {
+        this.tasks.push(resolve);
+      }
+    });
+  }
+
+  public release(): void {
+    if (this.tasks.length > 0) {
+      const nextTask = this.tasks.shift();
+      if (nextTask) {
+        nextTask();
+      }
+    } else if (this.currentCount > 0) {
+      this.currentCount--;
+    }
+  }
+}

package/src/lib/mutex/TaskRunner.ts

@@ -0,0 +1,26 @@
+import type { Observable } from 'rxjs';
+import { finalize, from, switchMap } from 'rxjs';
+import { Logger } from '../dev';
+import { Mutex } from './Mutex';
+
+export class TaskRunner {
+  private mutex = new Mutex();
+
+  runTask(name: string, task: () => Observable<string | null>) {
+    // Log that the task is waiting to acquire the mutex
+    Logger.log(`${name} waiting to acquire mutex`);
+
+    return from(this.mutex.acquire()).pipe(
+      switchMap((release) => {
+        // Log that the mutex has been acquired
+        Logger.log(`${name} acquired mutex`);
+        return task().pipe(
+          finalize(() => {
+            Logger.log(`${name} releasing mutex`);
+            release();
+          }),
+        );
+      }),
+    );
+  }
+}

package/src/lib/mutex/index.ts

@@ -0,0 +1,3 @@
+export * from './Mutex';
+export * from './Semaphore';
+export * from './TaskRunner';

package/src/lib/predicates/BooleanPredictors.ts

@@ -0,0 +1,47 @@
+type TruthyTypesOf<T> = T extends false | '' | 0 | null | undefined ? never : T;
+type FalsyTypesOf<T> = T extends false | '' | 0 | null | undefined ? T : never;
+type EmptyTypesOf<T> = T extends undefined | null | object | '' ? T : never;
+type NonEmptyTypesOf<T> = T extends undefined | null | object | '' ? never : T;
+/**
+ * The Boolean object represents a truth value: true or false.
+ * @param value
+ * @constructor
+ * Returns:boolean
+ */
+export const Truthy: <T>(value: T) => value is TruthyTypesOf<T> = <T>(
+  value?: T,
+): value is TruthyTypesOf<T> =>
+  !!value && value !== 'false' && value !== 'undefined' && value !== 'null';
+
+/**
+ * The Boolean object represents a INVERSE truth value: true or false.
+ * @param value
+ * @constructor
+ * Returns:boolean
+ */
+export const Falsy: <T>(value: T) => value is FalsyTypesOf<T> = <T>(
+  value?: T,
+): value is FalsyTypesOf<T> => !Truthy(value);
+
+/**
+ * Checks if a value is empty.
+ *
+ * @param {any} value - The value to check.
+ * @return {boolean} Returns true if the value is empty, otherwise false.
+ */
+export const IsEmpty: <T>(value: T) => value is EmptyTypesOf<T> = <T>(
+  value: T,
+): value is EmptyTypesOf<T> => {
+  return (
+    value === undefined ||
+    value === null ||
+    (typeof value === 'object' && Object.keys(value).length === 0) ||
+    (typeof value === 'string' && value.trim().length === 0)
+  );
+};
+
+export const NotEmpty: <T>(value: T) => value is NonEmptyTypesOf<T> = <T>(
+  value: T,
+): value is NonEmptyTypesOf<T> => {
+  return !IsEmpty(value);
+};

package/src/lib/predicates/index.ts

@@ -0,0 +1,3 @@
+export * from './BooleanPredictors';
+export * from './textForSearch';
+export * from './where';

package/src/lib/predicates/test/BooleanPredictors.spec.ts

@@ -0,0 +1,71 @@
+import { Falsy, IsEmpty, Truthy } from '../BooleanPredictors';
+
+describe('Truthy function', () => {
+  it('should return true for truthy values', () => {
+    expect(Truthy(true)).toBeTruthy();
+    expect(Truthy('true')).toBeTruthy();
+    expect(Truthy(1)).toBeTruthy();
+    expect(Truthy('non-empty')).toBeTruthy();
+    expect(Truthy({ key: 'value' })).toBeTruthy();
+    expect(Truthy([1, 2, 3])).toBeTruthy();
+    expect(Truthy([])).toBeTruthy();
+    expect(Truthy({})).toBeTruthy();
+  });
+
+  it('should return false for falsy values', () => {
+    expect(Truthy('undefined')).toBeFalsy();
+    expect(Truthy(undefined)).toBeFalsy();
+    expect(Truthy(null)).toBeFalsy();
+    expect(Truthy('null')).toBeFalsy();
+    expect(Truthy('false')).toBeFalsy();
+    expect(Truthy(false)).toBeFalsy();
+    expect(Truthy(0)).toBeFalsy();
+    expect(Truthy(-0)).toBeFalsy();
+    expect(Truthy(-0)).toBeFalsy();
+    expect(Truthy(NaN)).toBeFalsy();
+    expect(Truthy('')).toBeFalsy();
+  });
+});
+
+describe('Falsy function', () => {
+  it('should return false for truthy values', () => {
+    expect(Falsy(1)).toBeFalsy();
+    expect(Falsy('non-empty')).toBeFalsy();
+    expect(Falsy({ key: 'value' })).toBeFalsy();
+    expect(Falsy([1, 2, 3])).toBeFalsy();
+    expect(Falsy([])).toBeFalsy();
+    expect(Falsy({})).toBeFalsy();
+    expect(Falsy('true')).toBeFalsy();
+  });
+
+  it('should return true for falsy values', () => {
+    expect(Falsy('false')).toBeTruthy();
+    expect(Falsy('undefined')).toBeTruthy();
+    expect(Falsy('null')).toBeTruthy();
+    expect(Falsy(false)).toBeTruthy();
+    expect(Falsy(undefined)).toBeTruthy();
+    expect(Falsy(null)).toBeTruthy();
+    expect(Falsy(0)).toBeTruthy();
+    expect(Falsy(-0)).toBeTruthy();
+    expect(Falsy(-0)).toBeTruthy();
+    expect(Falsy(NaN)).toBeTruthy();
+    expect(Falsy('')).toBeTruthy();
+  });
+});
+
+describe('IsEmpty function', () => {
+  it('should return true for empty values', () => {
+    expect(IsEmpty('')).toBeTruthy();
+    expect(IsEmpty('  ')).toBeTruthy();
+    expect(IsEmpty(null)).toBeTruthy();
+    expect(IsEmpty(undefined)).toBeTruthy();
+    expect(IsEmpty({})).toBeTruthy();
+    expect(IsEmpty([])).toBeTruthy();
+  });
+
+  it('should return false for non-empty values', () => {
+    expect(IsEmpty('non-empty')).toBeFalsy();
+    expect(IsEmpty({ key: 'value' })).toBeFalsy();
+    expect(IsEmpty([1])).toBeFalsy();
+  });
+});

package/src/lib/predicates/test/where.spec.ts

@@ -0,0 +1,94 @@
+// Mocking the textForSearch if necessary, or import if available
+import { where, whereNot } from '../where';
+
+describe('where', () => {
+  it('should filter records based on a single criteria match', () => {
+    const records = [{ name: 'John Doe' }, { name: 'Jane Doe' }];
+    const criteria = { name: 'John Doe' };
+    const filter = where(criteria);
+    expect(records.filter(filter)).toEqual([{ name: 'John Doe' }]);
+  });
+
+  it('should be case sensitive when specified', () => {
+    const records = [{ name: 'john doe' }, { name: 'Jane Doe' }];
+    const criteria = { name: 'John Doe' };
+    const filter = where(criteria, true);
+    expect(records.filter(filter)).toEqual([]);
+  });
+
+  it('should handle multiple criteria', () => {
+    const records = [
+      { name: 'John Doe', age: 30 },
+      { name: 'Jane Doe', age: 25 },
+    ];
+    const criteria = { name: 'Jane Doe', age: 25 };
+    const filter = where(criteria);
+    expect(records.filter(filter)).toEqual([{ name: 'Jane Doe', age: 25 }]);
+  });
+
+  it('should return empty array if criteria is empty', () => {
+    const records = [{ name: 'John Doe' }, { name: 'Jane Doe' }];
+    const criteria = {};
+    const filter = where(criteria);
+    expect(records.filter(filter)).toEqual([]);
+  });
+
+  it('should handle non-string values correctly', () => {
+    const records = [{ age: 20 }, { age: 30 }];
+    const criteria = { age: 20 };
+    const filter = where(criteria);
+    expect(records.filter(filter)).toEqual([{ age: 20 }]);
+  });
+  it('should handle undefined values correctly', () => {
+    const records = [{ age: 20 }, { age: 30 }];
+    const criteria = { age: undefined };
+    const filter = where(criteria);
+    expect(records.filter(filter)).toEqual([]);
+  });
+});
+
+describe('whereNot', () => {
+  it('should filter records not matching the criteria', () => {
+    const records = [{ name: 'John Doe' }, { name: 'Jane Doe' }];
+    const criteria = { name: 'john doe' };
+    const filter = whereNot(criteria);
+    expect(records.filter(filter)).toEqual([{ name: 'Jane Doe' }]);
+  });
+
+  it('should filter records not matching the criteria', () => {
+    const records = [{ name: 'John Doe' }, { name: 'Jane Doe' }];
+    const criteria = { name: 'john Doe' };
+    const filter = whereNot(criteria, true);
+    expect(records.filter(filter)).toEqual([
+      { name: 'John Doe' },
+      { name: 'Jane Doe' },
+    ]);
+  });
+
+  it('should respect case sensitivity', () => {
+    const records = [{ name: 'john doe' }, { name: 'Jane Doe' }];
+    const criteria = { name: 'Jane Doe' };
+    const filter = whereNot(criteria);
+    expect(records.filter(filter)).toEqual([{ name: 'john doe' }]);
+  });
+
+  it('should process empty values', () => {
+    const records = [{ name: 'john doe' }, { name: 'Jane Doe' }];
+    const criteria = { name: undefined };
+    const filter = whereNot(criteria);
+    expect(records.filter(filter)).toEqual([
+      { name: 'john doe' },
+      { name: 'Jane Doe' },
+    ]);
+  });
+
+  it('should process empty values', () => {
+    const records = [{ name: 'john doe' }, { name: 'Jane Doe' }];
+    const criteria = {};
+    const filter = whereNot(criteria);
+    expect(records.filter(filter)).toEqual([
+      { name: 'john doe' },
+      { name: 'Jane Doe' },
+    ]);
+  });
+});