Function filter

assert/object_match.ts:64–224

(a: Loose, b: Loose)

}

function filter(a: Loose, b: Loose): Loose {
  const seen = new WeakMap<Loose | unknown[], Loose | unknown[]>();
  return filterObject(a, b);

  function filterObject(a: Loose, b: Loose): Loose {
    // Prevent infinite loop with circular references with same filter
    const memo = seen.get(a);
    if (memo && (memo === b)) return a;

    try {
      seen.set(a, b);
    } catch (err) {
      if (err instanceof TypeError) {
        throw new TypeError(
          `Cannot assertObjectMatch ${a === null ? null : `type ${typeof a}`}`,
        );
      }
    }

    // Filter keys and symbols which are present in both actual and expected
    const filtered = {} as Loose;
    const keysA = Reflect.ownKeys(a);
    const keysB = Reflect.ownKeys(b);
    const entries = keysA.filter((key) => keysB.includes(key))
      .map((key) => [key, a[key as string]]) as Array<[string, unknown]>;

    if (keysA.length && keysB.length && !entries.length) {
      // If both objects are not empty but don't have the same keys or symbols,
      // returns the entries in object a.
      for (const key of keysA) defineProperty(filtered, key, a[key]);
      return filtered;
    }

    for (const [key, value] of entries) {
      // On regexp references, keep value as it to avoid losing pattern and flags
      if (value instanceof RegExp) {
        defineProperty(filtered, key, value);
        continue;
      }
      // On date references, keep value as it to avoid losing the timestamp
      if (value instanceof Date) {
        defineProperty(filtered, key, value);
        continue;
      }

      const subset = (b as Loose)[key];

      // On array references, build a filtered array and filter nested objects inside
      if (Array.isArray(value) && Array.isArray(subset)) {
        defineProperty(filtered, key, filterArray(value, subset));
        continue;
      }

      // On nested objects references, build a filtered object recursively
      if (isObject(value) && isObject(subset)) {
        // When both operands are maps, build a filtered map with common keys and filter nested objects inside
        if ((value instanceof Map) && (subset instanceof Map)) {
          defineProperty(