@shirudo/ddd-kit 0.16.0 → 1.0.0-rc.2

package/dist/utils.d.ts

@@ -1,2 +1,93 @@
+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 (Date, RegExp, Map, Set,
+ * TypedArrays, ArrayBuffer, DataView) are cloned by type rather than walked
+ * — their internal structure has no key filtering to apply. Cycles are
+ * preserved: a cycle `a → a` clones to `a' → a'`.
+ *
+ * **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;
 
-export {  }
+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;
+
+/**
+ * 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;
+
+export { type DeepEqualExceptOptions, type DeepOmitOptions, type Key, type PathSegment, deepEqual, deepEqualExcept, deepOmit };

package/dist/utils.js

@@ -1,2 +1,284 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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 ArrayBuffer]",
+  "[object SharedArrayBuffer]",
+  "[object DataView]"
+]);
+function isBuiltInObject(obj, tag) {
+  if (tag.endsWith("Array]")) return true;
+  if (ArrayBuffer.isView(obj)) return true;
+  return BUILT_IN_TAGS.has(tag);
+}
+__name(isBuiltInObject, "isBuiltInObject");
+
+// src/utils/array/deep-equal.ts
+var objProto = Object.prototype;
+var objToString = objProto.toString;
+var objHasOwn = objProto.hasOwnProperty;
+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 (arrA[i] !== arrB[i]) return false;
+    }
+    return true;
+  }
+  const tagA = objToString.call(objA);
+  const tagB = objToString.call(objB);
+  if (tagA !== tagB) return false;
+  switch (tagA) {
+    case "[object Array]": {
+      const arrA = objA;
+      const arrB = objB;
+      const len = arrA.length;
+      if (len !== arrB.length) return false;
+      for (let i = 0; i < len; i++) {
+        if (!deepEqualInner(arrA[i], arrB[i], visited)) return false;
+      }
+      return true;
+    }
+    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]": {
+      const timeA = objA.getTime();
+      const timeB = objB.getTime();
+      return timeA === timeB;
+    }
+    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]": {
+      return objA.valueOf() === objB.valueOf();
+    }
+    default: {
+      if (isBuiltInObject(objA, tagA) && isBuiltInObject(objB, tagB)) {
+        return objA === objB;
+      }
+      const recA = objA;
+      const recB = objB;
+      const stringKeysA = Object.keys(objA);
+      const stringKeysB = Object.keys(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(deepEqualInner, "deepEqualInner");
+
+// 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;
+  return omitInternal(value, options, ignoreKeys, [], visited);
+}
+__name(deepOmit, "deepOmit");
+function omitInternal(value, options, ignoreKeys, path, visited) {
+  if (value === null) return value;
+  if (typeof value !== "object") return value;
+  const obj = value;
+  if (visited.has(obj)) {
+    return visited.get(obj);
+  }
+  const tag = Object.prototype.toString.call(obj);
+  if (tag === "[object Array]") {
+    const arr = obj;
+    const clone2 = new Array(arr.length);
+    visited.set(obj, clone2);
+    for (let i = 0; i < arr.length; i++) {
+      path.push(i);
+      clone2[i] = omitInternal(arr[i], options, ignoreKeys, path, visited);
+      path.pop();
+    }
+    return clone2;
+  }
+  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
+      )
+    );
+    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
+      )
+    );
+    path.pop();
+  }
+  return clone;
+}
+__name(omitInternal, "omitInternal");
+function assignOwn(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+__name(assignOwn, "assignOwn");
+function cloneBuiltIn(obj, tag) {
+  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

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"utils.js"}
+{"version":3,"sources":["../src/utils/array/is-built-in.ts","../src/utils/array/deep-equal.ts","../src/utils/array/deep-omit.ts","../src/utils/array/deep-equal-except.ts"],"names":["tagA","tagB","len","clone"],"mappings":"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","file":"utils.js","sourcesContent":["/**\n * Set of `Object.prototype.toString.call(x)` tags that the library treats\n * as built-in atomic types. Members of this set are compared/cloned by\n * reference (or with type-specific logic) rather than walked structurally.\n *\n * The detection is purely tag-based — `Object.prototype.toString` reads\n * `Symbol.toStringTag`, which gives the same answer across realms (an\n * iframe's `Date` has the same tag as the main window's `Date`). The\n * previous strategy also checked `globalThis[name] === constructor` and a\n * `proto !== Object.prototype` heuristic; both broke for cross-realm\n * objects and the latter additionally misclassified ordinary user classes\n * as built-ins. Tag-only is the simplest robust choice.\n */\nconst BUILT_IN_TAGS: ReadonlySet<string> = new Set([\n\t\"[object Date]\",\n\t\"[object RegExp]\",\n\t\"[object Map]\",\n\t\"[object Set]\",\n\t\"[object WeakMap]\",\n\t\"[object WeakSet]\",\n\t\"[object Promise]\",\n\t\"[object Error]\",\n\t\"[object Boolean]\",\n\t\"[object Number]\",\n\t\"[object String]\",\n\t\"[object ArrayBuffer]\",\n\t\"[object SharedArrayBuffer]\",\n\t\"[object DataView]\",\n]);\n\n/**\n * Returns `true` when `obj` is a built-in JavaScript type that should be\n * treated atomically (compared/cloned as a unit, not walked structurally).\n * Cross-realm safe.\n *\n * @param obj - The object to classify\n * @param tag - The result of `Object.prototype.toString.call(obj)` — passed\n *              in so callers that already computed it don't pay twice\n */\nexport function isBuiltInObject(obj: object, tag: string): boolean {\n\t// All TypedArrays produce tags ending in \"Array]\" — future-proof match.\n\tif (tag.endsWith(\"Array]\")) return true;\n\t// ArrayBuffer view covers DataView + all TypedArrays as a belt-and-braces.\n\tif (ArrayBuffer.isView(obj)) return true;\n\treturn BUILT_IN_TAGS.has(tag);\n}\n","import { isBuiltInObject } from \"./is-built-in\";\n\nconst objProto = Object.prototype;\nconst objToString = objProto.toString;\nconst objHasOwn = objProto.hasOwnProperty;\n\n/**\n * Performs a deep equality check between two values.\n *\n * This function compares values recursively, handling:\n * - Primitives (with special handling for NaN)\n * - Arrays (nested arrays supported)\n * - Objects (plain objects and class instances)\n * - TypedArrays (Uint8Array, Int32Array, etc.)\n * - DataView\n * - Maps and Sets\n * - Dates and RegExp\n * - Wrapper objects (Boolean, Number, String)\n * - Circular references (detected and handled)\n *\n * @param a - The first value to compare\n * @param b - The second value to compare\n * @returns `true` if the values are deeply equal, `false` otherwise\n *\n * @example\n * ```ts\n * deepEqual([1, 2, 3], [1, 2, 3]); // true\n * deepEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }); // true\n * deepEqual(NaN, NaN); // true\n * deepEqual([1, 2], [1, 2, 3]); // false\n * ```\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n\treturn deepEqualInner(a, b, new WeakMap<object, WeakSet<object>>());\n}\n\n/**\n * Visited pair tracker for cycle detection. The cache is a pair-set:\n * for every left-hand object we keep the set of right-hand objects we\n * have already paired it with. Encountering an already-known pair returns\n * the cycle hypothesis (assume equal); a new (a, b') pair with b' ≠ any\n * previously cached b for that a is walked normally — the previous shape\n * (`WeakMap<object, object>`) could only remember one B per A, which\n * could short-circuit unrelated comparisons that happened to revisit the\n * same A with a different B.\n */\ntype VisitedPairs = WeakMap<object, WeakSet<object>>;\n\n/**\n * Internal recursive function for deep equality comparison.\n *\n * @internal\n */\nfunction deepEqualInner(\n\ta: unknown,\n\tb: unknown,\n\tvisited: VisitedPairs,\n): boolean {\n\t// 1. Fast path: reference equality\n\tif (a === b) return true;\n\n\tconst typeA = typeof a;\n\tconst typeB = typeof b;\n\n\t// 2. If one is not an object → primitive / function\n\tif (typeA !== \"object\" || a === null || typeB !== \"object\" || b === null) {\n\t\t// Special case: NaN should be equal\n\t\tif (typeA === \"number\" && typeB === \"number\") {\n\t\t\treturn Number.isNaN(a as number) && Number.isNaN(b as number);\n\t\t}\n\t\t// Everything else is directly unequal with !== (including functions)\n\t\treturn false;\n\t}\n\n\t// From here on: both are non-null objects\n\n\tconst objA = a as object;\n\tconst objB = b as object;\n\n\t// 3. Cycles: already seen this exact (a, b) pair?\n\tlet cachedBs = visited.get(objA);\n\tif (cachedBs?.has(objB)) {\n\t\t// Cycle hypothesis: pretend equal so the walk can terminate. If the\n\t\t// structure is actually unequal elsewhere, a different recursive\n\t\t// branch will surface the mismatch.\n\t\treturn true;\n\t}\n\tif (!cachedBs) {\n\t\tcachedBs = new WeakSet();\n\t\tvisited.set(objA, cachedBs);\n\t}\n\tcachedBs.add(objB);\n\n\t// 4. Handle Typed Arrays / DataView first\n\tif (ArrayBuffer.isView(objA) || ArrayBuffer.isView(objB)) {\n\t\tif (!ArrayBuffer.isView(objA) || !ArrayBuffer.isView(objB)) return false;\n\n\t\tconst tagA = objToString.call(objA);\n\t\tconst tagB = objToString.call(objB);\n\t\tif (tagA !== tagB) return false;\n\n\t\t// DataView: compare byte by byte\n\t\tif (tagA === \"[object DataView]\") {\n\t\t\tconst viewA = objA as DataView;\n\t\t\tconst viewB = objB as DataView;\n\t\t\tif (viewA.byteLength !== viewB.byteLength) return false;\n\n\t\t\tconst len = viewA.byteLength;\n\t\t\tfor (let i = 0; i < len; i++) {\n\t\t\t\tif (viewA.getUint8(i) !== viewB.getUint8(i)) return false;\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\n\t\t// Typed Arrays: element by element (length + numeric index access are\n\t\t// part of the TypedArray contract; the indexed read is sound).\n\t\tconst arrA = objA as unknown as Record<number, unknown> & { length: number };\n\t\tconst arrB = objB as unknown as Record<number, unknown> & { length: number };\n\n\t\tconst len = arrA.length;\n\t\tif (len !== arrB.length) return false;\n\n\t\tfor (let i = 0; i < len; i++) {\n\t\t\tif (arrA[i] !== arrB[i]) return false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t// 5. Tag-based type detection (robust across realms)\n\tconst tagA = objToString.call(objA);\n\tconst tagB = objToString.call(objB);\n\tif (tagA !== tagB) return false;\n\n\tswitch (tagA) {\n\t\tcase \"[object Array]\": {\n\t\t\tconst arrA = objA as unknown[];\n\t\t\tconst arrB = objB as unknown[];\n\t\t\tconst len = arrA.length;\n\t\t\tif (len !== arrB.length) return false;\n\n\t\t\tfor (let i = 0; i < len; i++) {\n\t\t\t\tif (!deepEqualInner(arrA[i], arrB[i], visited)) return false;\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\n\t\tcase \"[object Map]\": {\n\t\t\tconst mapA = objA as Map<unknown, unknown>;\n\t\t\tconst mapB = objB as Map<unknown, unknown>;\n\n\t\t\tif (mapA.size !== mapB.size) return false;\n\n\t\t\tfor (const [key, valA] of mapA) {\n\t\t\t\t// Map keys according to JS semantics: reference / SameValueZero\n\t\t\t\tif (!mapB.has(key)) return false;\n\t\t\t\tconst valB = mapB.get(key);\n\t\t\t\tif (!deepEqualInner(valA, valB, visited)) return false;\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\n\t\tcase \"[object Set]\": {\n\t\t\tconst setA = objA as Set<unknown>;\n\t\t\tconst setB = objB as Set<unknown>;\n\n\t\t\tif (setA.size !== setB.size) return false;\n\n\t\t\t// Set elements: same reference (JS semantics)\n\t\t\tfor (const value of setA) {\n\t\t\t\tif (!setB.has(value)) return false;\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\n\t\tcase \"[object Date]\": {\n\t\t\tconst timeA = (objA as Date).getTime();\n\t\t\tconst timeB = (objB as Date).getTime();\n\t\t\treturn timeA === timeB;\n\t\t}\n\n\t\tcase \"[object RegExp]\": {\n\t\t\tconst regA = objA as RegExp;\n\t\t\tconst regB = objB as RegExp;\n\t\t\treturn regA.source === regB.source && regA.flags === regB.flags;\n\t\t}\n\n\t\tcase \"[object Boolean]\":\n\t\tcase \"[object Number]\":\n\t\tcase \"[object String]\": {\n\t\t\t// Wrapper objects (new Boolean/Number/String)\n\t\t\treturn (objA as any).valueOf() === (objB as any).valueOf();\n\t\t}\n\n\t\tdefault: {\n\t\t\t// 6. Check if this is an unhandled built-in type (future-proof)\n\t\t\t// If both are built-ins but not handled above, they should be compared by reference\n\t\t\t// (since we don't know their internal structure)\n\t\t\tif (isBuiltInObject(objA, tagA) && isBuiltInObject(objB, tagB)) {\n\t\t\t\t// Unhandled built-in types: compare by reference as fallback\n\t\t\t\t// This ensures new built-ins don't fall through to plain object comparison\n\t\t\t\treturn objA === objB;\n\t\t\t}\n\n\t\t\t// 7. Fallback: plain / custom objects → compare own enumerable keys + values\n\t\t\tconst recA = objA as Record<string | symbol, unknown>;\n\t\t\tconst recB = objB as Record<string | symbol, unknown>;\n\n\t\t\tconst stringKeysA = Object.keys(objA as object);\n\t\t\tconst stringKeysB = Object.keys(objB as object);\n\t\t\tif (stringKeysA.length !== stringKeysB.length) return false;\n\n\t\t\tconst symbolKeysA = Object.getOwnPropertySymbols(objA as object);\n\t\t\tconst symbolKeysB = Object.getOwnPropertySymbols(objB as object);\n\t\t\tif (symbolKeysA.length !== symbolKeysB.length) return false;\n\n\t\t\t// Build the B-side symbol set once; the previous impl rebuilt the\n\t\t\t// array and ran .includes per key, which was quadratic.\n\t\t\tconst symbolKeysBSet = new Set<symbol>(symbolKeysB);\n\n\t\t\tfor (const key of stringKeysA) {\n\t\t\t\tif (!objHasOwn.call(objB, key)) return false;\n\t\t\t}\n\t\t\tfor (const key of symbolKeysA) {\n\t\t\t\tif (!symbolKeysBSet.has(key)) return false;\n\t\t\t}\n\n\t\t\tfor (const key of stringKeysA) {\n\t\t\t\tif (!deepEqualInner(recA[key], recB[key], visited)) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (const key of symbolKeysA) {\n\t\t\t\tif (!deepEqualInner(recA[key], recB[key], visited)) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t}\n\t}\n}\n","import { isBuiltInObject } from \"./is-built-in\";\n\nexport type Key = string | symbol;\nexport type PathSegment = string | number | symbol;\n\nexport interface DeepOmitOptions {\n\t/**\n\t * Keys to ignore everywhere in the object tree.\n\t * Only applies to object properties, not Map/Set/TypedArray contents.\n\t */\n\treadonly ignoreKeys?: readonly Key[];\n\n\t/**\n\t * Fine-grained control: Key + path (without current key).\n\t * Example path: [\"user\", \"meta\", 0, \"data\"]\n\t */\n\treadonly ignoreKeyPredicate?: (\n\t\tkey: Key,\n\t\tpath: readonly PathSegment[],\n\t) => boolean;\n}\n\n/**\n * Creates a deep copy of `value` with certain keys removed according to the\n * provided rules.\n *\n * Walks the object tree and skips keys that match `ignoreKeys` /\n * `ignoreKeyPredicate`. Built-in atomic types (Date, RegExp, Map, Set,\n * TypedArrays, ArrayBuffer, DataView) are cloned by type rather than walked\n * — their internal structure has no key filtering to apply. Cycles are\n * preserved: a cycle `a → a` clones to `a' → a'`.\n *\n * **Prototype-pollution safety.** `__proto__` and `constructor` keys\n * encountered as *own* properties of the input (typical of `JSON.parse`\n * output) are copied as inert data properties via `Object.defineProperty`\n * so the clone graph cannot bleed into `Object.prototype`.\n *\n * **Class instances.** When the input is a class instance, the clone is\n * built via `Object.create(proto)` so the prototype is preserved, but the\n * constructor is NOT re-invoked — so class invariants enforced by the\n * constructor are not re-checked. `deepOmit` is therefore best used for\n * comparison/serialisation (`voEqualsExcept`, `deepEqualExcept`), not as\n * a general-purpose clone for behaviour-carrying objects.\n *\n * @param value - The value to create a deep copy from\n * @param options - Options specifying which keys to ignore\n * @returns A deep copy of `value` with specified keys removed\n */\nexport function deepOmit<T>(value: T, options: DeepOmitOptions): T {\n\tconst visited = new WeakMap<object, unknown>();\n\t// Materialise ignoreKeys as a Set once so the inner loop probes O(1).\n\tconst ignoreKeys = options.ignoreKeys\n\t\t? new Set<Key>(options.ignoreKeys)\n\t\t: undefined;\n\treturn omitInternal(value, options, ignoreKeys, [], visited) as T;\n}\n\nfunction omitInternal(\n\tvalue: unknown,\n\toptions: DeepOmitOptions,\n\tignoreKeys: ReadonlySet<Key> | undefined,\n\tpath: PathSegment[],\n\tvisited: WeakMap<object, unknown>,\n): unknown {\n\tif (value === null) return value;\n\tif (typeof value !== \"object\") return value;\n\n\tconst obj = value as object;\n\n\t// Cycles: return cached clone if already visited. Use `has` (not\n\t// `cached !== undefined`) so a legitimately-undefined cached clone\n\t// would not be misclassified as \"never seen\".\n\tif (visited.has(obj)) {\n\t\treturn visited.get(obj);\n\t}\n\n\tconst tag = Object.prototype.toString.call(obj);\n\n\t// Arrays: recursively process elements\n\tif (tag === \"[object Array]\") {\n\t\tconst arr = obj as unknown[];\n\t\tconst clone: unknown[] = new Array(arr.length);\n\t\tvisited.set(obj, clone);\n\t\tfor (let i = 0; i < arr.length; i++) {\n\t\t\tpath.push(i);\n\t\t\tclone[i] = omitInternal(arr[i], options, ignoreKeys, path, visited);\n\t\t\tpath.pop();\n\t\t}\n\t\treturn clone;\n\t}\n\n\t// Built-in atomic types: clone by type rather than walk.\n\tif (isBuiltInObject(obj, tag)) {\n\t\tconst builtInClone = cloneBuiltIn(obj, tag);\n\t\tvisited.set(obj, builtInClone);\n\t\treturn builtInClone;\n\t}\n\n\t// Plain / Custom Objects: filter keys, recursively process values.\n\tconst clone = Object.create(Object.getPrototypeOf(obj));\n\tvisited.set(obj, clone);\n\n\tconst stringKeys = Object.keys(obj);\n\tconst symbolKeys = Object.getOwnPropertySymbols(obj);\n\n\tfor (const key of stringKeys) {\n\t\tif (shouldIgnoreKey(key, path, ignoreKeys, options)) continue;\n\t\tpath.push(key);\n\t\tassignOwn(\n\t\t\tclone,\n\t\t\tkey,\n\t\t\tomitInternal(\n\t\t\t\t(obj as Record<PropertyKey, unknown>)[key],\n\t\t\t\toptions,\n\t\t\t\tignoreKeys,\n\t\t\t\tpath,\n\t\t\t\tvisited,\n\t\t\t),\n\t\t);\n\t\tpath.pop();\n\t}\n\tfor (const key of symbolKeys) {\n\t\tif (shouldIgnoreKey(key, path, ignoreKeys, options)) continue;\n\t\tpath.push(key);\n\t\tassignOwn(\n\t\t\tclone,\n\t\t\tkey,\n\t\t\tomitInternal(\n\t\t\t\t(obj as Record<PropertyKey, unknown>)[key],\n\t\t\t\toptions,\n\t\t\t\tignoreKeys,\n\t\t\t\tpath,\n\t\t\t\tvisited,\n\t\t\t),\n\t\t);\n\t\tpath.pop();\n\t}\n\n\treturn clone;\n}\n\n/**\n * Assigns `value` as an OWN data property on `target` without going through\n * any inherited setter — critically, never invokes the `__proto__` setter\n * even when `key === \"__proto__\"`. Required to defeat prototype-pollution\n * payloads that ship `__proto__` as a parsed-JSON own key.\n */\nfunction assignOwn(target: object, key: PropertyKey, value: unknown): void {\n\tObject.defineProperty(target, key, {\n\t\tvalue,\n\t\twritable: true,\n\t\tenumerable: true,\n\t\tconfigurable: true,\n\t});\n}\n\n/**\n * Clones a built-in atomic type by case. Falls back to `structuredClone`\n * for anything not explicitly enumerated (e.g. ArrayBuffer, DataView,\n * Boolean/Number/String wrappers).\n */\nfunction cloneBuiltIn(obj: object, tag: string): unknown {\n\tswitch (tag) {\n\t\tcase \"[object Date]\":\n\t\t\treturn new Date((obj as Date).getTime());\n\t\tcase \"[object RegExp]\": {\n\t\t\tconst re = obj as RegExp;\n\t\t\tconst copy = new RegExp(re.source, re.flags);\n\t\t\tcopy.lastIndex = re.lastIndex;\n\t\t\treturn copy;\n\t\t}\n\t\tcase \"[object Map]\": {\n\t\t\tconst m = obj as Map<unknown, unknown>;\n\t\t\treturn new Map(m);\n\t\t}\n\t\tcase \"[object Set]\": {\n\t\t\tconst s = obj as Set<unknown>;\n\t\t\treturn new Set(s);\n\t\t}\n\t\tdefault:\n\t\t\treturn structuredClone(obj);\n\t}\n}\n\nfunction shouldIgnoreKey(\n\tkey: Key,\n\tpath: readonly PathSegment[],\n\tignoreKeys: ReadonlySet<Key> | undefined,\n\toptions: DeepOmitOptions,\n): boolean {\n\tif (ignoreKeys?.has(key)) return true;\n\tif (options.ignoreKeyPredicate?.(key, path)) return true;\n\treturn false;\n}\n","import { deepEqual } from \"./deep-equal\";\nimport { type DeepOmitOptions, deepOmit } from \"./deep-omit\";\n\nexport type DeepEqualExceptOptions = DeepOmitOptions;\n\n/**\n * Performs a deep equality comparison between two values after omitting specified keys.\n * \n * This function first removes the specified keys from both values using `deepOmit`,\n * then performs a deep equality check using `deepEqual`.\n * \n * @param a - The first value to compare\n * @param b - The second value to compare\n * @param options - Options specifying which keys to omit before comparison\n * @returns `true` if the values are deeply equal after omitting specified keys, `false` otherwise\n * \n * @example\n * ```ts\n * const obj1 = { id: 1, name: \"Alice\", updatedAt: \"2024-01-01\" };\n * const obj2 = { id: 2, name: \"Alice\", updatedAt: \"2024-01-02\" };\n * \n * deepEqualExcept(obj1, obj2, { ignoreKeys: [\"id\", \"updatedAt\"] }); // true\n * ```\n */\nexport function deepEqualExcept(\n\ta: unknown,\n\tb: unknown,\n\toptions: DeepEqualExceptOptions,\n): boolean {\n\tconst prunedA = deepOmit(a, options);\n\tconst prunedB = deepOmit(b, options);\n\treturn deepEqual(prunedA, prunedB);\n}\n"]}

package/package.json

@@ -1,67 +1,71 @@
 {
-	"name": "@shirudo/ddd-kit",
-	"version": "0.16.0",
-	"description": "Composable TypeScript toolkit for tactical DDD",
-	"type": "module",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/shi-rudo/ddd-kit-ts.git"
-	},
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		},
-		"./result": {
-			"import": "./dist/result.js",
-			"types": "./dist/result.d.ts"
-		},
-		"./utils": {
-			"import": "./dist/utils.js",
-			"types": "./dist/utils.d.ts"
-		},
-		"./utils/array": {
-			"import": "./dist/utils-array.js",
-			"types": "./dist/utils-array.d.ts"
-		}
-	},
-	"files": [
-		"dist"
-	],
-	"scripts": {
-		"build": "tsup",
-		"test": "vitest",
-		"clean": "rm -rf dist",
-		"lint": "biome lint .",
-		"format": "pnpm exec biome format --write . && pnpm exec biome lint --write . && pnpm exec biome check --write .",
-		"typecheck": "tsc --noEmit",
-		"prepublishOnly": "npm run clean && vitest run && npm run build"
-	},
-	"keywords": [
-		"ddd",
-		"domain",
-		"typescript",
-		"toolkit"
-	],
-	"license": "MIT",
-	"publishConfig": {
-		"access": "public"
-	},
-	"devDependencies": {
-		"@biomejs/biome": "2.1.4",
-		"tsup": "^8.5.0",
-		"typescript": "^5.9.2",
-		"vitest": "^3.2.4"
-	},
-	"private": false,
-	"author": "Shirudo",
-	"contributors": [
-		"Shirudo"
-	],
-	"homepage": "https://github.com/shi-rudo/ddd-kit-ts",
-	"bugs": {
-		"url": "https://github.com/shi-rudo/ddd-kit-ts/issues"
-	}
+  "name": "@shirudo/ddd-kit",
+  "version": "1.0.0-rc.2",
+  "description": "Composable TypeScript toolkit for tactical DDD",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shi-rudo/ddd-kit-ts.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils.js",
+      "types": "./dist/utils.d.ts"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "ddd",
+    "domain",
+    "typescript",
+    "toolkit"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.1.4",
+    "@shirudo/result": "^0.0.6",
+    "tsup": "^8.5.0",
+    "typedoc": "^0.28.19",
+    "typedoc-plugin-markdown": "^4.11.0",
+    "typedoc-vitepress-theme": "^1.1.2",
+    "typescript": "^5.9.2",
+    "vitepress": "^1.6.4",
+    "vitest": "^3.2.4"
+  },
+  "private": false,
+  "author": "Shirudo",
+  "contributors": [
+    "Shirudo"
+  ],
+  "homepage": "https://github.com/shi-rudo/ddd-kit-ts",
+  "bugs": {
+    "url": "https://github.com/shi-rudo/ddd-kit-ts/issues"
+  },
+  "peerDependencies": {
+    "@shirudo/result": "^0.0.6"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest",
+    "clean": "rm -rf dist",
+    "lint": "biome lint .",
+    "format": "pnpm exec biome format --write . && pnpm exec biome lint --write . && pnpm exec biome check --write .",
+    "typecheck": "tsc --noEmit",
+    "docs:api": "typedoc",
+    "docs:dev": "pnpm run docs:api && vitepress dev docs",
+    "docs:build": "pnpm run docs:api && vitepress build docs",
+    "docs:preview": "vitepress preview docs"
+  }
 }

package/dist/deep-equal-except-C8yoSk4L.d.ts

@@ -1,57 +0,0 @@
-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.
- *
- * This function recursively traverses the object tree and removes keys that match
- * the criteria specified in `options`. Built-in types (Date, Map, Set, TypedArrays, etc.)
- * are treated atomically and not modified.
- *
- * @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
- *
- * @example
- * ```ts
- * const obj = { a: 1, b: { c: 2, d: 3 } };
- * const result = deepOmit(obj, { ignoreKeys: ['d'] });
- * // result: { a: 1, b: { c: 2 } }
- * ```
- */
-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 DeepOmitOptions as D, type Key as K, type PathSegment as P, type DeepEqualExceptOptions as a, deepEqualExcept as b, deepOmit as d };