@shirudo/ddd-kit 0.9.8 → 0.10.0

package/README.md

@@ -37,9 +37,9 @@ pnpm add @shirudo/ddd-kit
 Here's a minimal example showing how to create and use a Value Object:
 
 ```typescript
-import { vo, type ValueObject } from "@shirudo/ddd-kit";
+import { vo, type VO } from "@shirudo/ddd-kit";
 
-type EmailAddress = ValueObject<{
+type EmailAddress = VO<{
   value: string;
 }>;
 
@@ -125,10 +125,10 @@ The `Result<T, E>` type provides functional error handling without exceptions. I
 ### Creating a Value Object
 
 ```typescript
-import { vo, voEquals, voEqualsExcept, voWithValidation, type ValueObject } from "@shirudo/ddd-kit";
+import { vo, voEquals, voEqualsExcept, voWithValidation, type VO } from "@shirudo/ddd-kit";
 
-// Simple value object
-type Money = ValueObject<{
+// Simple value object (Functional Style)
+type Money = VO<{
   amount: number;
   currency: string;
 }>;
@@ -136,6 +136,22 @@ type Money = ValueObject<{
 const price = vo({ amount: 99.99, currency: "USD" });
 // price is deeply immutable - nested objects and arrays are also frozen
 
+// Class-based Value Object (OOP Style)
+import { ValueObject } from "@shirudo/ddd-kit";
+
+class Address extends ValueObject<{ street: string; city: string }> {
+  constructor(props: { street: string; city: string }) {
+    super(props);
+  }
+
+  get street(): string {
+    return this.props.street;
+  }
+}
+
+const address = new Address({ street: "Main St", city: "New York" });
+// address.props is immutable
+
 // Value object with validation (returns Result)
 const result = voWithValidation(
   { amount: 100, currency: "USD" },

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

@@ -0,0 +1,57 @@
+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 };