@shirudo/ddd-kit 2.2.0 → 3.0.0-rc.4

package/dist/utils.d.ts

@@ -1,106 +1,2 @@
-/**
- * Performs a deep equality check between two values.
- *
- * This function compares values recursively, handling:
- * - Primitives (with special handling for NaN)
- * - Arrays (nested arrays supported)
- * - Objects (plain objects and class instances)
- * - TypedArrays (Uint8Array, Int32Array, etc.)
- * - DataView
- * - Maps and Sets
- * - Dates and RegExp
- * - Wrapper objects (Boolean, Number, String)
- * - Circular references (detected and handled)
- *
- * @param a - The first value to compare
- * @param b - The second value to compare
- * @returns `true` if the values are deeply equal, `false` otherwise
- *
- * @example
- * ```ts
- * deepEqual([1, 2, 3], [1, 2, 3]); // true
- * deepEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }); // true
- * deepEqual(NaN, NaN); // true
- * deepEqual([1, 2], [1, 2, 3]); // false
- * ```
- */
-declare function deepEqual(a: unknown, b: unknown): boolean;
-
-type Key = string | symbol;
-type PathSegment = string | number | symbol;
-interface DeepOmitOptions {
-    /**
-     * Keys to ignore everywhere in the object tree.
-     * Only applies to object properties, not Map/Set/TypedArray contents.
-     */
-    readonly ignoreKeys?: readonly Key[];
-    /**
-     * Fine-grained control: Key + path (without current key).
-     * Example path: ["user", "meta", 0, "data"]
-     */
-    readonly ignoreKeyPredicate?: (key: Key, path: readonly PathSegment[]) => boolean;
-}
-/**
- * Creates a deep copy of `value` with certain keys removed according to the
- * provided rules.
- *
- * Walks the object tree and skips keys that match `ignoreKeys` /
- * `ignoreKeyPredicate`. Built-in atomic types that `deepEqual` compares by
- * value (Date, RegExp, Map, Set, TypedArrays, DataView) are cloned by type
- * rather than walked, since their internal structure has no key filtering to
- * apply. Types that `deepEqual` compares by reference (Error, ArrayBuffer,
- * SharedArrayBuffer, Promise, WeakMap, WeakSet) are passed through by
- * reference, so `deepEqualExcept(x, x)` stays reflexive. Cycles are
- * preserved: a cycle `a → a` clones to `a' → a'`. Arrays retain sparse
- * holes and all non-ignored own properties, including symbol keys.
- *
- * **Shared references.** Without `ignoreKeyPredicate`, an object reached
- * via several paths dedupes to a single clone. With a predicate, each
- * path gets its own clone, because the predicate may decide differently per
- * path, so memoising the first path's result would be wrong. This is
- * inherently exponential for diamond-shaped sharing (a node reachable
- * via 2^n paths is cloned 2^n times); the walk aborts with a descriptive
- * error after {@link PATH_SENSITIVE_VISIT_BUDGET} node visits instead of
- * hanging the process.
- *
- * **Prototype-pollution safety.** `__proto__` and `constructor` keys
- * encountered as *own* properties of the input (typical of `JSON.parse`
- * output) are copied as inert data properties via `Object.defineProperty`
- * so the clone graph cannot bleed into `Object.prototype`.
- *
- * **Class instances.** When the input is a class instance, the clone is
- * built via `Object.create(proto)` so the prototype is preserved, but the
- * constructor is NOT re-invoked, so class invariants enforced by the
- * constructor are not re-checked. `deepOmit` is therefore best used for
- * comparison/serialisation (`voEqualsExcept`, `deepEqualExcept`), not as
- * a general-purpose clone for behaviour-carrying objects.
- *
- * @param value - The value to create a deep copy from
- * @param options - Options specifying which keys to ignore
- * @returns A deep copy of `value` with specified keys removed
- */
-declare function deepOmit<T>(value: T, options: DeepOmitOptions): T;
-
-type DeepEqualExceptOptions = DeepOmitOptions;
-/**
- * Performs a deep equality comparison between two values after omitting specified keys.
- *
- * This function first removes the specified keys from both values using `deepOmit`,
- * then performs a deep equality check using `deepEqual`.
- *
- * @param a - The first value to compare
- * @param b - The second value to compare
- * @param options - Options specifying which keys to omit before comparison
- * @returns `true` if the values are deeply equal after omitting specified keys, `false` otherwise
- *
- * @example
- * ```ts
- * const obj1 = { id: 1, name: "Alice", updatedAt: "2024-01-01" };
- * const obj2 = { id: 2, name: "Alice", updatedAt: "2024-01-02" };
- *
- * deepEqualExcept(obj1, obj2, { ignoreKeys: ["id", "updatedAt"] }); // true
- * ```
- */
-declare function deepEqualExcept(a: unknown, b: unknown, options: DeepEqualExceptOptions): boolean;
-
-export { type DeepEqualExceptOptions, type DeepOmitOptions, type Key, type PathSegment, deepEqual, deepEqualExcept, deepOmit };
+import { a as DeepOmitPathSegment, i as DeepOmitOptions, n as deepEqualExcept, o as deepOmit, r as DeepOmitKey, s as deepEqual, t as DeepEqualExceptOptions } from "./chunks/utils.js";
+export { type DeepEqualExceptOptions, type DeepOmitKey, type DeepOmitOptions, type DeepOmitPathSegment, deepEqual, deepEqualExcept, deepOmit };

package/dist/utils.js

@@ -1,531 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { n as deepOmit, r as deepEqual, t as deepEqualExcept } from "./chunks/deep-equal-except.js";
 
-// src/utils/array/is-built-in.ts
-var BUILT_IN_TAGS = /* @__PURE__ */ new Set([
-  "[object Date]",
-  "[object RegExp]",
-  "[object Map]",
-  "[object Set]",
-  "[object WeakMap]",
-  "[object WeakSet]",
-  "[object Promise]",
-  "[object Error]",
-  "[object Boolean]",
-  "[object Number]",
-  "[object String]",
-  "[object BigInt]",
-  "[object ArrayBuffer]",
-  "[object SharedArrayBuffer]",
-  "[object DataView]"
-]);
-function intrinsicGetter(proto, prop) {
-  const get = Object.getOwnPropertyDescriptor(proto, prop)?.get;
-  if (!get) throw new Error(`missing intrinsic getter for ${prop}`);
-  return get;
-}
-__name(intrinsicGetter, "intrinsicGetter");
-var dateGetTime = Date.prototype.getTime;
-var mapSizeGet = intrinsicGetter(Map.prototype, "size");
-var setSizeGet = intrinsicGetter(Set.prototype, "size");
-var weakMapHas = WeakMap.prototype.has;
-var weakSetHas = WeakSet.prototype.has;
-var dataViewByteLengthGet = intrinsicGetter(DataView.prototype, "byteLength");
-var arrayBufferByteLengthGet = intrinsicGetter(
-  ArrayBuffer.prototype,
-  "byteLength"
-);
-var sharedArrayBufferByteLengthGet = typeof SharedArrayBuffer === "undefined" ? void 0 : intrinsicGetter(SharedArrayBuffer.prototype, "byteLength");
-var regExpSourceGet = intrinsicGetter(RegExp.prototype, "source");
-var booleanValueOf = Boolean.prototype.valueOf;
-var numberValueOf = Number.prototype.valueOf;
-var stringValueOf = String.prototype.valueOf;
-var bigIntValueOf = BigInt.prototype.valueOf;
-var functionToString = Function.prototype.toString;
-var PROBE_KEY = {};
-var INTRINSIC_CONSTRUCTOR_NAMES = [
-  "Object",
-  "Array",
-  "Date",
-  "RegExp",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "Promise",
-  "Error",
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError",
-  "AggregateError",
-  "Boolean",
-  "Number",
-  "String",
-  "BigInt",
-  "ArrayBuffer",
-  "SharedArrayBuffer",
-  "DataView",
-  "Int8Array",
-  "Uint8Array",
-  "Uint8ClampedArray",
-  "Int16Array",
-  "Uint16Array",
-  "Int32Array",
-  "Uint32Array",
-  "Float32Array",
-  "Float64Array",
-  "BigInt64Array",
-  "BigUint64Array"
-];
-var intrinsicConstructorSources = new Map(
-  INTRINSIC_CONSTRUCTOR_NAMES.flatMap((name) => {
-    const descriptor = Object.getOwnPropertyDescriptor(globalThis, name);
-    const intrinsic = descriptor?.value;
-    return typeof intrinsic === "function" ? [[name, functionToString.call(intrinsic)]] : [];
-  })
-);
-var intrinsicConstructorSourceSet = new Set(
-  intrinsicConstructorSources.values()
-);
-var ERROR_INTRINSIC_NAMES = [
-  "Error",
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError",
-  "AggregateError"
-];
-function isIntrinsicConstructorPrototype(prototype, expectedName) {
-  const constructorDescriptor = Object.getOwnPropertyDescriptor(
-    prototype,
-    "constructor"
-  );
-  const candidateConstructor = constructorDescriptor?.value;
-  if (constructorDescriptor === void 0 || !("value" in constructorDescriptor) || typeof candidateConstructor !== "function") {
-    return false;
-  }
-  let candidateSource;
-  try {
-    candidateSource = functionToString.call(candidateConstructor);
-  } catch {
-    return false;
-  }
-  const expectedSource = expectedName === void 0 ? void 0 : intrinsicConstructorSources.get(expectedName);
-  if (expectedSource !== void 0 && candidateSource !== expectedSource || expectedSource === void 0 && !intrinsicConstructorSourceSet.has(candidateSource)) {
-    return false;
-  }
-  const nameDescriptor = Object.getOwnPropertyDescriptor(
-    candidateConstructor,
-    "name"
-  );
-  const candidateName = nameDescriptor !== void 0 && "value" in nameDescriptor && typeof nameDescriptor.value === "string" ? nameDescriptor.value : void 0;
-  const intrinsicName = expectedName ?? candidateName;
-  const intrinsicSource = intrinsicName === void 0 ? void 0 : intrinsicConstructorSources.get(intrinsicName);
-  return candidateName === intrinsicName && intrinsicSource !== void 0 && candidateSource === intrinsicSource && Object.getOwnPropertyDescriptor(candidateConstructor, "prototype")?.value === prototype;
-}
-__name(isIntrinsicConstructorPrototype, "isIntrinsicConstructorPrototype");
-var REFERENCE_COMPARED_TAGS = /* @__PURE__ */ new Set([
-  "[object Error]",
-  "[object ArrayBuffer]",
-  "[object SharedArrayBuffer]",
-  "[object Promise]",
-  "[object WeakMap]",
-  "[object WeakSet]"
-]);
-function hasNativePrototype(value, expectedName) {
-  const visited = /* @__PURE__ */ new WeakSet();
-  let prototype = Object.getPrototypeOf(value);
-  while (prototype !== null && !visited.has(prototype)) {
-    visited.add(prototype);
-    if (isIntrinsicConstructorPrototype(prototype, expectedName)) {
-      return true;
-    }
-    prototype = Object.getPrototypeOf(prototype);
-  }
-  return false;
-}
-__name(hasNativePrototype, "hasNativePrototype");
-function hasBrand(obj, tag) {
-  try {
-    switch (tag) {
-      case "[object Date]":
-        dateGetTime.call(obj);
-        return true;
-      case "[object RegExp]":
-        regExpSourceGet.call(obj);
-        return true;
-      case "[object Map]":
-        mapSizeGet.call(obj);
-        return true;
-      case "[object Set]":
-        setSizeGet.call(obj);
-        return true;
-      case "[object WeakMap]":
-        weakMapHas.call(obj, PROBE_KEY);
-        return true;
-      case "[object WeakSet]":
-        weakSetHas.call(obj, PROBE_KEY);
-        return true;
-      case "[object DataView]":
-        dataViewByteLengthGet.call(obj);
-        return true;
-      case "[object ArrayBuffer]":
-        arrayBufferByteLengthGet.call(obj);
-        return true;
-      case "[object SharedArrayBuffer]":
-        if (!sharedArrayBufferByteLengthGet) return false;
-        sharedArrayBufferByteLengthGet.call(obj);
-        return true;
-      case "[object Boolean]":
-        booleanValueOf.call(obj);
-        return true;
-      case "[object Number]":
-        numberValueOf.call(obj);
-        return true;
-      case "[object String]":
-        stringValueOf.call(obj);
-        return true;
-      case "[object BigInt]":
-        bigIntValueOf.call(obj);
-        return true;
-      case "[object Promise]":
-        return hasNativePrototype(obj, "Promise");
-      case "[object Error]":
-        return ERROR_INTRINSIC_NAMES.some(
-          (name) => hasNativePrototype(obj, name)
-        );
-      default:
-        return false;
-    }
-  } catch {
-    return false;
-  }
-}
-__name(hasBrand, "hasBrand");
-function isBuiltInObject(obj, tag) {
-  if (ArrayBuffer.isView(obj)) return true;
-  if (tag.endsWith("Array]")) return false;
-  return BUILT_IN_TAGS.has(tag) && hasBrand(obj, tag);
-}
-__name(isBuiltInObject, "isBuiltInObject");
-
-// src/utils/array/deep-equal.ts
-var objProto = Object.prototype;
-var objToString = objProto.toString;
-var objHasOwn = objProto.hasOwnProperty;
-function sameValueZero(a, b) {
-  return a === b || Number.isNaN(a) && Number.isNaN(b);
-}
-__name(sameValueZero, "sameValueZero");
-function deepEqual(a, b) {
-  return deepEqualInner(a, b, /* @__PURE__ */ new WeakMap());
-}
-__name(deepEqual, "deepEqual");
-function deepEqualInner(a, b, visited) {
-  if (a === b) return true;
-  const typeA = typeof a;
-  const typeB = typeof b;
-  if (typeA !== "object" || a === null || typeB !== "object" || b === null) {
-    if (typeA === "number" && typeB === "number") {
-      return Number.isNaN(a) && Number.isNaN(b);
-    }
-    return false;
-  }
-  const objA = a;
-  const objB = b;
-  let cachedBs = visited.get(objA);
-  if (cachedBs?.has(objB)) {
-    return true;
-  }
-  if (!cachedBs) {
-    cachedBs = /* @__PURE__ */ new WeakSet();
-    visited.set(objA, cachedBs);
-  }
-  cachedBs.add(objB);
-  if (ArrayBuffer.isView(objA) || ArrayBuffer.isView(objB)) {
-    if (!ArrayBuffer.isView(objA) || !ArrayBuffer.isView(objB)) return false;
-    const tagA2 = objToString.call(objA);
-    const tagB2 = objToString.call(objB);
-    if (tagA2 !== tagB2) return false;
-    if (tagA2 === "[object DataView]") {
-      const viewA = objA;
-      const viewB = objB;
-      if (viewA.byteLength !== viewB.byteLength) return false;
-      const len2 = viewA.byteLength;
-      for (let i = 0; i < len2; i++) {
-        if (viewA.getUint8(i) !== viewB.getUint8(i)) return false;
-      }
-      return true;
-    }
-    const arrA = objA;
-    const arrB = objB;
-    const len = arrA.length;
-    if (len !== arrB.length) return false;
-    for (let i = 0; i < len; i++) {
-      if (!sameValueZero(arrA[i], arrB[i])) return false;
-    }
-    return true;
-  }
-  if (Array.isArray(objA) || Array.isArray(objB)) {
-    if (!Array.isArray(objA) || !Array.isArray(objB)) return false;
-    if (objA.length !== objB.length) return false;
-    const keysA = Reflect.ownKeys(objA).filter((key) => key !== "length");
-    const keysB = Reflect.ownKeys(objB).filter((key) => key !== "length");
-    if (keysA.length !== keysB.length) return false;
-    const arrA = objA;
-    const arrB = objB;
-    for (const key of keysA) {
-      if (!objHasOwn.call(objB, key)) return false;
-      if (!deepEqualInner(arrA[key], arrB[key], visited)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  const tagA = objToString.call(objA);
-  const tagB = objToString.call(objB);
-  if (tagA !== tagB) return false;
-  const builtInA = isBuiltInObject(objA, tagA);
-  const builtInB = isBuiltInObject(objB, tagB);
-  if (builtInA !== builtInB) return false;
-  if (!builtInA) {
-    return comparePlainObjects(objA, objB, visited);
-  }
-  switch (tagA) {
-    case "[object Map]": {
-      const mapA = objA;
-      const mapB = objB;
-      if (mapA.size !== mapB.size) return false;
-      for (const [key, valA] of mapA) {
-        if (!mapB.has(key)) return false;
-        const valB = mapB.get(key);
-        if (!deepEqualInner(valA, valB, visited)) return false;
-      }
-      return true;
-    }
-    case "[object Set]": {
-      const setA = objA;
-      const setB = objB;
-      if (setA.size !== setB.size) return false;
-      for (const value of setA) {
-        if (!setB.has(value)) return false;
-      }
-      return true;
-    }
-    case "[object Date]": {
-      return sameValueZero(objA.getTime(), objB.getTime());
-    }
-    case "[object RegExp]": {
-      const regA = objA;
-      const regB = objB;
-      return regA.source === regB.source && regA.flags === regB.flags;
-    }
-    case "[object Boolean]":
-    case "[object Number]":
-    case "[object String]":
-    case "[object BigInt]": {
-      return sameValueZero(
-        objA.valueOf(),
-        objB.valueOf()
-      );
-    }
-    default: {
-      return objA === objB;
-    }
-  }
-}
-__name(deepEqualInner, "deepEqualInner");
-function comparePlainObjects(objA, objB, visited) {
-  const recA = objA;
-  const recB = objB;
-  const stringKeysA = Object.getOwnPropertyNames(objA);
-  const stringKeysB = Object.getOwnPropertyNames(objB);
-  if (stringKeysA.length !== stringKeysB.length) return false;
-  const symbolKeysA = Object.getOwnPropertySymbols(objA);
-  const symbolKeysB = Object.getOwnPropertySymbols(objB);
-  if (symbolKeysA.length !== symbolKeysB.length) return false;
-  const symbolKeysBSet = new Set(symbolKeysB);
-  for (const key of stringKeysA) {
-    if (!objHasOwn.call(objB, key)) return false;
-  }
-  for (const key of symbolKeysA) {
-    if (!symbolKeysBSet.has(key)) return false;
-  }
-  for (const key of stringKeysA) {
-    if (!deepEqualInner(recA[key], recB[key], visited)) {
-      return false;
-    }
-  }
-  for (const key of symbolKeysA) {
-    if (!deepEqualInner(recA[key], recB[key], visited)) {
-      return false;
-    }
-  }
-  return true;
-}
-__name(comparePlainObjects, "comparePlainObjects");
-
-// src/utils/array/deep-omit.ts
-function deepOmit(value, options) {
-  const visited = /* @__PURE__ */ new WeakMap();
-  const ignoreKeys = options.ignoreKeys ? new Set(options.ignoreKeys) : void 0;
-  const budget = options.ignoreKeyPredicate ? { visits: 0 } : void 0;
-  return omitInternal(value, options, ignoreKeys, [], visited, budget);
-}
-__name(deepOmit, "deepOmit");
-var PATH_SENSITIVE_VISIT_BUDGET = 1e6;
-function omitInternal(value, options, ignoreKeys, path, visited, budget) {
-  if (value === null) return value;
-  if (typeof value !== "object") return value;
-  const obj = value;
-  if (visited.has(obj)) {
-    return visited.get(obj);
-  }
-  if (budget && ++budget.visits > PATH_SENSITIVE_VISIT_BUDGET) {
-    throw new Error(
-      `deepOmit: exceeded ${PATH_SENSITIVE_VISIT_BUDGET} node visits. With ignoreKeyPredicate, objects reached via shared references are cloned once per path (the predicate may decide differently per path), which expands exponentially on diamond-shaped sharing. Restructure the input to a tree, or use ignoreKeys for path-independent filtering.`
-    );
-  }
-  if (Array.isArray(obj)) {
-    const arr = obj;
-    const clone2 = new Array(arr.length);
-    const lengthDescriptor = Object.getOwnPropertyDescriptor(arr, "length");
-    visited.set(obj, clone2);
-    for (const key of Reflect.ownKeys(arr)) {
-      if (key === "length") continue;
-      const segment = arrayPathSegment(key);
-      if (typeof segment !== "number" && shouldIgnoreKey(key, path, ignoreKeys, options)) {
-        continue;
-      }
-      const descriptor = Object.getOwnPropertyDescriptor(arr, key);
-      if (descriptor === void 0) continue;
-      path.push(segment);
-      if ("value" in descriptor) {
-        descriptor.value = omitInternal(
-          descriptor.value,
-          options,
-          ignoreKeys,
-          path,
-          visited,
-          budget
-        );
-      }
-      Object.defineProperty(clone2, key, descriptor);
-      path.pop();
-    }
-    if (lengthDescriptor !== void 0) {
-      Object.defineProperty(clone2, "length", lengthDescriptor);
-    }
-    if (budget) visited.delete(obj);
-    return clone2;
-  }
-  const tag = Object.prototype.toString.call(obj);
-  if (isBuiltInObject(obj, tag)) {
-    const builtInClone = cloneBuiltIn(obj, tag);
-    visited.set(obj, builtInClone);
-    return builtInClone;
-  }
-  const clone = Object.create(Object.getPrototypeOf(obj));
-  visited.set(obj, clone);
-  const stringKeys = Object.keys(obj);
-  const symbolKeys = Object.getOwnPropertySymbols(obj);
-  for (const key of stringKeys) {
-    if (shouldIgnoreKey(key, path, ignoreKeys, options)) continue;
-    path.push(key);
-    assignOwn(
-      clone,
-      key,
-      omitInternal(
-        obj[key],
-        options,
-        ignoreKeys,
-        path,
-        visited,
-        budget
-      )
-    );
-    path.pop();
-  }
-  for (const key of symbolKeys) {
-    if (shouldIgnoreKey(key, path, ignoreKeys, options)) continue;
-    path.push(key);
-    assignOwn(
-      clone,
-      key,
-      omitInternal(
-        obj[key],
-        options,
-        ignoreKeys,
-        path,
-        visited,
-        budget
-      )
-    );
-    path.pop();
-  }
-  if (budget) visited.delete(obj);
-  return clone;
-}
-__name(omitInternal, "omitInternal");
-function arrayPathSegment(key) {
-  if (typeof key === "symbol") return key;
-  const index = Number(key);
-  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key ? index : key;
-}
-__name(arrayPathSegment, "arrayPathSegment");
-function assignOwn(target, key, value) {
-  Object.defineProperty(target, key, {
-    value,
-    writable: true,
-    enumerable: true,
-    configurable: true
-  });
-}
-__name(assignOwn, "assignOwn");
-function cloneBuiltIn(obj, tag) {
-  if (REFERENCE_COMPARED_TAGS.has(tag)) return obj;
-  switch (tag) {
-    case "[object Date]":
-      return new Date(obj.getTime());
-    case "[object RegExp]": {
-      const re = obj;
-      const copy = new RegExp(re.source, re.flags);
-      copy.lastIndex = re.lastIndex;
-      return copy;
-    }
-    case "[object Map]": {
-      const m = obj;
-      return new Map(m);
-    }
-    case "[object Set]": {
-      const s = obj;
-      return new Set(s);
-    }
-    default:
-      return structuredClone(obj);
-  }
-}
-__name(cloneBuiltIn, "cloneBuiltIn");
-function shouldIgnoreKey(key, path, ignoreKeys, options) {
-  if (ignoreKeys?.has(key)) return true;
-  if (options.ignoreKeyPredicate?.(key, path)) return true;
-  return false;
-}
-__name(shouldIgnoreKey, "shouldIgnoreKey");
-
-// src/utils/array/deep-equal-except.ts
-function deepEqualExcept(a, b, options) {
-  const prunedA = deepOmit(a, options);
-  const prunedB = deepOmit(b, options);
-  return deepEqual(prunedA, prunedB);
-}
-__name(deepEqualExcept, "deepEqualExcept");
-
-export { deepEqual, deepEqualExcept, deepOmit };
-//# sourceMappingURL=utils.js.map
-//# sourceMappingURL=utils.js.map
+export { deepEqual, deepEqualExcept, deepOmit };