typedash/dist/isEqual/index.cjs

modern, type-safe collection of utility functions

'use strict';

// src/functions/zip/zip.ts
function zip(first, second) {
  const result = [];
  for (let index = 0; index < Math.min(first.length, second.length); index++) {
    result.push([first[index], second[index]]);
  }
  return result;
}

// src/functions/isEqual/_internal/array/areArraysEqual.ts
function areArraysEqual(array1, array2, context) {
  if (array1.length !== array2.length) {
    return false;
  }
  for (const [index, [element1, element2]] of zip(array1, array2).entries()) {
    if (!context.equals(element1, element2, index, index, array1, array2, context)) {
      return false;
    }
  }
  return true;
}

// src/functions/isEqual/_internal/createIsCircularTypeEqualityComparator.ts
function createIsCircularTypeEqualityComparator(areItemsEqual) {
  return function isCircular(a, b, context) {
    if (!a || !b || typeof a !== "object" || typeof b !== "object") {
      return areItemsEqual(a, b, context);
    }
    const { cache } = context;
    const cachedA = cache.get(a);
    const cachedB = cache.get(b);
    if (cachedA && cachedB) {
      return cachedA === b && cachedB === a;
    }
    cache.set(a, b);
    cache.set(b, a);
    const result = areItemsEqual(a, b, context);
    cache.delete(a);
    cache.delete(b);
    return result;
  };
}

// src/functions/isEqual/_internal/date/areDatesEqual.ts
function areDatesEqual(value1, value2) {
  return Object.is(value1.getTime(), value2.getTime());
}

// src/functions/isEqual/_internal/date/dateTag.ts
var DATE_TAG = "[object Date]";

// src/functions/isEqual/_internal/map/areMapsEqual.ts
function areMapsEqual(value1, value2, context) {
  if (value1.size !== value2.size) {
    return false;
  }
  const matchedIndices = {};
  let index = 0;
  for (const [aKey, aValue] of value1) {
    let hasMatch = false;
    let matchIndex = 0;
    for (const [bKey, bValue] of value2) {
      if (!hasMatch && !matchedIndices[matchIndex] && // eslint-disable-next-line no-cond-assign
      (hasMatch = context.equals(
        aKey,
        bKey,
        index,
        matchIndex,
        value1,
        value2,
        context
      ) && context.equals(aValue, bValue, aKey, bKey, value1, value2, context))) {
        matchedIndices[matchIndex] = true;
      }
      matchIndex++;
    }
    if (!hasMatch) {
      return false;
    }
    index++;
  }
  return true;
}

// src/functions/isEqual/_internal/react/reactOwnerPropertyName.ts
var REACT_OWNER_PROPERTY_NAME = "_owner";

// src/functions/isEqual/_internal/object/getObjectProperties.ts
function getObjectProperties(object) {
  return [
    ...Object.getOwnPropertyNames(object),
    ...Object.getOwnPropertySymbols(object)
  ];
}

// src/functions/isEqual/_internal/object/areObjectsEqual.ts
function areObjectsEqual(value1, value2, context) {
  const properties = getObjectProperties(value1);
  if (getObjectProperties(value2).length !== properties.length) {
    return false;
  }
  for (const property of properties) {
    if (property === REACT_OWNER_PROPERTY_NAME && (value1.$$typeof || value2.$$typeof) && value1.$$typeof !== value2.$$typeof) {
      return false;
    }
    if (!Object.hasOwn(value2, property)) {
      return false;
    }
    if (!context.equals(
      value1[property],
      value2[property],
      property,
      property,
      value1,
      value2,
      context
    )) {
      return false;
    }
  }
  return true;
}

// src/functions/isEqual/_internal/primitiveWrappers/arePrimitiveWrappersEqual.ts
function arePrimitiveWrappersEqual(value1, value2) {
  return Object.is(value1.valueOf(), value2.valueOf());
}

// src/functions/isEqual/_internal/regExp/areRegExpsEqual.ts
function areRegExpsEqual(value1, value2) {
  return value1.source === value2.source && value1.flags === value2.flags;
}

// src/functions/isEqual/_internal/regExp/regExpTag.ts
var REG_EXP_TAG = "[object RegExp]";

// src/functions/isEqual/_internal/set/areSetsEqual.ts
function areSetsEqual(set1, set2, context) {
  if (set1.size !== set2.size) {
    return false;
  }
  const matchedIndices = {};
  for (const element1 of set1) {
    let hasMatch = false;
    let matchIndex = 0;
    for (const element2 of set2) {
      if (!hasMatch && !matchedIndices[matchIndex] && // eslint-disable-next-line no-cond-assign
      (hasMatch = context.equals(
        element1,
        element2,
        element1,
        element2,
        set1,
        set2,
        context
      ))) {
        matchedIndices[matchIndex] = true;
      }
      matchIndex++;
    }
    if (!hasMatch) {
      return false;
    }
  }
  return true;
}

// src/functions/isEqual/_internal/set/setTag.ts
var SET_TAG = "[object Set]";

// src/functions/isEqual/_internal/typedArray/areTypedArraysEqual.ts
function areTypedArraysEqual(array1, array2) {
  if (array1.length !== array2.length) {
    return false;
  }
  for (const [element1, element2] of zip(array1, array2)) {
    if (element1 !== element2) {
      return false;
    }
  }
  return true;
}

// src/functions/isEqual/_internal/typedArray/isTypedArray.ts
var isTypedArray = typeof ArrayBuffer === "function" && ArrayBuffer.isView ? ArrayBuffer.isView : null;

// src/functions/isEqual/_internal/comparator.ts
var ARGUMENTS_TAG = "[object Arguments]";
var BOOLEAN_TAG = "[object Boolean]";
var MAP_TAG = "[object Map]";
var NUMBER_TAG = "[object Number]";
var OBJECT_TAG = "[object Object]";
var STRING_TAG = "[object String]";
var getTag = Object.prototype.toString.call.bind(
  Object.prototype.toString
);
function createEqualityComparatorConfig() {
  return {
    areDatesEqual,
    areRegExpsEqual,
    arePrimitiveWrappersEqual,
    areArraysEqual: createIsCircularTypeEqualityComparator(areArraysEqual),
    areMapsEqual: createIsCircularTypeEqualityComparator(areMapsEqual),
    areObjectsEqual: createIsCircularTypeEqualityComparator(areObjectsEqual),
    areSetsEqual: createIsCircularTypeEqualityComparator(areSetsEqual),
    areTypedArraysEqual
  };
}
function createInternalEqualityComparator(compare) {
  return function internalEqualityComparator(value1, value2, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, context) {
    return compare(value1, value2, context);
  };
}
function createIsEqual({ comparator, equals }) {
  return function isEqual2(value1, value2) {
    return comparator(value1, value2, {
      cache: /* @__PURE__ */ new WeakMap(),
      equals
    });
  };
}

// src/functions/isArray/isArray.ts
var isArray = Array.isArray;

// src/functions/isEqual/_internal/createEqualityComparator.ts
function createEqualityComparator({
  areArraysEqual: areArraysEqual2,
  areDatesEqual: areDatesEqual2,
  areMapsEqual: areMapsEqual2,
  areObjectsEqual: areObjectsEqual2,
  arePrimitiveWrappersEqual: arePrimitiveWrappersEqual2,
  areRegExpsEqual: areRegExpsEqual2,
  areSetsEqual: areSetsEqual2,
  areTypedArraysEqual: areTypedArraysEqual2
}) {
  return function comparator(value1, value2, context) {
    if (Object.is(value1, value2) || value1 === value2) {
      return true;
    }
    if (value1?.constructor !== value2?.constructor) {
      return false;
    }
    if (value1.constructor === Object) {
      return areObjectsEqual2(value1, value2, context);
    }
    if (isArray(value1)) {
      return areArraysEqual2(value1, value2, context);
    }
    if (isTypedArray?.(value1)) {
      return areTypedArraysEqual2(value1, value2, context);
    }
    if (value1.constructor === Date) {
      return areDatesEqual2(value1, value2, context);
    }
    if (value1.constructor === RegExp) {
      return areRegExpsEqual2(value1, value2, context);
    }
    if (value1.constructor === Map) {
      return areMapsEqual2(value1, value2, context);
    }
    if (value1.constructor === Set) {
      return areSetsEqual2(value1, value2, context);
    }
    const tag = getTag(value1);
    switch (tag) {
      case DATE_TAG: {
        return areDatesEqual2(value1, value2, context);
      }
      case REG_EXP_TAG: {
        return areRegExpsEqual2(value1, value2, context);
      }
      case MAP_TAG: {
        return areMapsEqual2(value1, value2, context);
      }
      case SET_TAG: {
        return areSetsEqual2(value1, value2, context);
      }
      case OBJECT_TAG: {
        return (
          // eslint-disable-next-line unicorn/consistent-destructuring
          // eslint-disable-next-line unicorn/consistent-destructuring
          typeof value1.then !== "function" && typeof value2.then !== "function" && areObjectsEqual2(value1, value2, context)
        );
      }
      case ARGUMENTS_TAG: {
        return areObjectsEqual2(value1, value2, context);
      }
      case BOOLEAN_TAG:
      case NUMBER_TAG:
      case STRING_TAG: {
        return arePrimitiveWrappersEqual2(value1, value2, context);
      }
      default: {
        return false;
      }
    }
  };
}

// src/functions/isEqual/isEqual.ts
var isEqual = createCustomEqual();
function createCustomEqual() {
  const config = createEqualityComparatorConfig();
  const comparator = createEqualityComparator(config);
  const equals = createInternalEqualityComparator(comparator);
  return createIsEqual({ comparator, equals });
}

exports.isEqual = isEqual;
//# sourceMappingURL=out.js.map
//# sourceMappingURL=index.cjs.map