@woltz/rich-domain 1.7.0 → 1.8.0

package/dist/esm/core/change-tracker.js

@@ -0,0 +1,785 @@
+import { Id } from "./id.js";
+import { Entity } from "./entity.js";
+import { ValueObject } from "./value-object.js";
+import { AggregateChanges } from "./aggregate-changes.js";
+/**
+ * Tracks changes in Aggregates using Proxy.
+ *
+ * Features:
+ * - Tracks changes in primitive properties
+ * - Tracks changes in nested entities (1:1)
+ * - Tracks changes in collections (1:N)
+ * - Calculates depth automatically
+ * - Generates AggregateChanges for persistence
+ * - Supports validation on change via onChangeValidator
+ */
+export class ChangeTracker {
+    target;
+    rootEntityName;
+    path;
+    depth;
+    parentId;
+    parentEntity;
+    rootTracker;
+    history = [];
+    originalValues = new Map();
+    trackedArrays = new Map();
+    trackedEntities = new Map();
+    onChangeValidator;
+    constructor(target, rootEntityName, path = "", depth = 0, 
+    // @ts-expect-error - This is a private property
+    parentId, 
+    // @ts-expect-error - This is a private property
+    parentEntity, rootTracker) {
+        this.target = target;
+        this.rootEntityName = rootEntityName;
+        this.path = path;
+        this.depth = depth;
+        this.parentId = parentId;
+        this.parentEntity = parentEntity;
+        this.rootTracker = rootTracker;
+        if (!rootTracker) {
+            this.rootTracker = this;
+        }
+        this.captureInitialState();
+    }
+    /**
+     * Sets a validator callback that will be called on every property change.
+     * The validator can:
+     * - Return false to reject the change (value will be reverted)
+     * - Throw an error to reject the change with an error
+     * - Return true/undefined to accept the change
+     */
+    setOnChangeValidator(validator) {
+        this.getRootTracker().onChangeValidator = validator;
+    }
+    captureInitialState() {
+        if (this.depth > 0)
+            return;
+        this.captureEntityState(this.target, this.rootEntityName, "", 0);
+    }
+    captureEntityState(obj, entityName, path, depth, parentId, parentEntity) {
+        if (!obj || typeof obj !== "object")
+            return;
+        const id = this.getEntityId(obj);
+        const key = path || "root";
+        this.trackedEntities.set(key, {
+            entity: obj,
+            metadata: {
+                entityName,
+                depth,
+                parentId,
+                parentEntity,
+                path,
+            },
+            originalState: this.deepClone(obj),
+        });
+        const propsToScan = obj.props || obj;
+        for (const [propName, value] of Object.entries(propsToScan)) {
+            if (propName === "id")
+                continue;
+            const propPath = path ? `${path}.${propName}` : propName;
+            if (Array.isArray(value)) {
+                this.captureArrayState(value, propPath, depth + 1, id, entityName);
+            }
+            else if (value instanceof Entity) {
+                const nestedName = this.getEntityName(value);
+                this.captureEntityState(value, nestedName, propPath, depth + 1, id, entityName);
+            }
+        }
+    }
+    captureArrayState(arr, path, depth, parentId, parentEntity) {
+        const entityName = arr.length > 0 ? this.getEntityName(arr[0]) : "Unknown";
+        this.trackedArrays.set(path, {
+            cloned: this.cloneArray(arr),
+            original: arr.slice(),
+            metadata: {
+                entityName,
+                depth,
+                parentId,
+                parentEntity,
+                path,
+            },
+        });
+        arr.forEach((item, index) => {
+            if (item instanceof Entity) {
+                const itemPath = `${path}[${index}]`;
+                this.captureEntityState(item, this.getEntityName(item), itemPath, depth, parentId, parentEntity);
+            }
+        });
+    }
+    createProxy() {
+        const handler = {
+            get: (target, prop, receiver) => {
+                const value = Reflect.get(target, prop, receiver);
+                if (this.shouldSkipProperty(prop)) {
+                    return value;
+                }
+                if (typeof value === "function") {
+                    return value.bind(target);
+                }
+                const currentPath = this.buildPath(String(prop));
+                if (Array.isArray(value)) {
+                    return this.createArrayProxy(value, currentPath);
+                }
+                if (value instanceof Entity) {
+                    const nestedTracker = new ChangeTracker(value, this.getEntityName(value), currentPath, this.depth + 1, this.getEntityId(this.target), this.rootEntityName, this.rootTracker);
+                    return nestedTracker.createProxy();
+                }
+                return value;
+            },
+            set: (target, prop, newValue, receiver) => {
+                const currentPath = this.buildPath(String(prop));
+                const oldValue = Reflect.get(target, prop, receiver);
+                if (!Array.isArray(newValue) && oldValue === newValue) {
+                    return true;
+                }
+                const rootTracker = this.getRootTracker();
+                if (rootTracker.onChangeValidator) {
+                    try {
+                        const result = rootTracker.onChangeValidator(currentPath, newValue);
+                        if (result === false) {
+                            return true;
+                        }
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                }
+                if (!rootTracker.originalValues.has(currentPath)) {
+                    rootTracker.originalValues.set(currentPath, oldValue);
+                }
+                rootTracker.history.push({
+                    path: currentPath,
+                    previousValue: oldValue,
+                    currentValue: newValue,
+                    timestamp: Date.now(),
+                });
+                const result = Reflect.set(target, prop, newValue, receiver);
+                if (Array.isArray(newValue)) {
+                    this.handleArrayAssignment(currentPath, oldValue);
+                }
+                else if (newValue instanceof Entity || oldValue instanceof Entity) {
+                    this.handleEntityChange(currentPath, oldValue, newValue);
+                }
+                return result;
+            },
+        };
+        const proxy = new Proxy(this.target, handler);
+        Object.defineProperty(proxy, "__isProxy", { value: true, writable: false });
+        return proxy;
+    }
+    createArrayProxy(array, path) {
+        const tracker = this;
+        const rootTracker = this.getRootTracker();
+        if (!rootTracker.trackedArrays.has(path)) {
+            const parentId = this.getEntityId(this.target);
+            rootTracker.captureArrayState(array, path, this.depth + 1, parentId, this.rootEntityName);
+        }
+        return new Proxy(array, {
+            get(target, prop, receiver) {
+                const value = Reflect.get(target, prop, receiver);
+                if (typeof value === "function") {
+                    const mutatingMethods = [
+                        "push",
+                        "pop",
+                        "shift",
+                        "unshift",
+                        "splice",
+                        "sort",
+                        "reverse",
+                    ];
+                    if (mutatingMethods.includes(String(prop))) {
+                        return function (...args) {
+                            const oldArray = target.slice();
+                            if (rootTracker.onChangeValidator) {
+                                try {
+                                    const result = rootTracker.onChangeValidator(path, [
+                                        ...oldArray,
+                                        ...args,
+                                    ]);
+                                    if (result === false) {
+                                        return undefined;
+                                    }
+                                }
+                                catch (error) {
+                                    throw error;
+                                }
+                            }
+                            const result = value.apply(target, args);
+                            rootTracker.history.push({
+                                path,
+                                previousValue: oldArray,
+                                currentValue: target.slice(),
+                                timestamp: Date.now(),
+                            });
+                            return result;
+                        };
+                    }
+                    return value.bind(target);
+                }
+                if (!isNaN(Number(prop)) && value instanceof Entity) {
+                    const nestedPath = `${path}[${String(prop)}]`;
+                    const nestedTracker = new ChangeTracker(value, tracker.getEntityName(value), nestedPath, tracker.depth + 1, tracker.getEntityId(tracker.target), tracker.rootEntityName, rootTracker);
+                    return nestedTracker.createProxy();
+                }
+                return value;
+            },
+            set(target, prop, newValue, receiver) {
+                if (!isNaN(Number(prop))) {
+                    const oldArray = target.slice();
+                    if (rootTracker.onChangeValidator) {
+                        try {
+                            const result = rootTracker.onChangeValidator(path, newValue);
+                            if (result === false) {
+                                return true;
+                            }
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    const result = Reflect.set(target, prop, newValue, receiver);
+                    rootTracker.history.push({
+                        path,
+                        previousValue: oldArray,
+                        currentValue: target.slice(),
+                        timestamp: Date.now(),
+                    });
+                    return result;
+                }
+                return Reflect.set(target, prop, newValue, receiver);
+            },
+        });
+    }
+    /**
+     * Returns all detected changes as AggregateChanges.
+     */
+    getChanges() {
+        const changes = new AggregateChanges();
+        const rootTracker = this.getRootTracker();
+        this.analyzeRootChanges(changes, rootTracker);
+        this.analyzeCollectionChanges(changes, rootTracker);
+        this.analyzeEntityChanges(changes, rootTracker);
+        return changes;
+    }
+    analyzeRootChanges(changes, rootTracker) {
+        const changedFields = {};
+        let hasChanges = false;
+        for (const [path, originalValue] of rootTracker.originalValues) {
+            if (path.includes(".") || path.includes("["))
+                continue;
+            const currentValue = this.target[path];
+            if (!this.isEqual(originalValue, currentValue)) {
+                changedFields[path] =
+                    currentValue instanceof ValueObject
+                        ? currentValue.value
+                        : currentValue;
+                hasChanges = true;
+            }
+        }
+        if (hasChanges) {
+            const id = this.getEntityId(this.target);
+            if (id) {
+                changes.addUpdate(this.rootEntityName, id, this.target, changedFields, 0);
+            }
+        }
+    }
+    analyzeCollectionChanges(changes, rootTracker) {
+        const allTrackedArrays = new Map();
+        const processedArrays = new Set();
+        for (const [path, arrayState] of rootTracker.trackedArrays) {
+            const currentArray = this.getValueAtPath(this.target, path);
+            if (Array.isArray(currentArray) && !processedArrays.has(currentArray)) {
+                allTrackedArrays.set(path, arrayState);
+                processedArrays.add(currentArray);
+            }
+        }
+        this.collectNestedArrays(this.target, "", allTrackedArrays, processedArrays);
+        for (const [path, arrayState] of allTrackedArrays) {
+            const currentArray = this.getValueAtPath(this.target, path);
+            if (!Array.isArray(currentArray))
+                continue;
+            const { created, updated, deleted } = this.detectArrayChanges(arrayState.cloned, arrayState.original, currentArray);
+            const { depth, parentId, parentEntity } = arrayState.metadata;
+            const relationField = this.extractRelationField(path);
+            for (const item of created) {
+                const itemEntityName = this.getEntityName(item);
+                changes.addCreate(itemEntityName, item, depth, parentId, parentEntity, relationField);
+                this.markNestedItemsAsCreated(item, depth, changes);
+            }
+            for (const item of updated) {
+                const id = this.getEntityId(item);
+                if (id) {
+                    const original = arrayState.cloned.find((o) => this.getEntityId(o) === id);
+                    const changedFields = this.detectChangedFields(original, item);
+                    if (Object.keys(changedFields).length > 0) {
+                        const itemEntityName = this.getEntityName(item);
+                        changes.addUpdate(itemEntityName, id, item, changedFields, depth);
+                    }
+                }
+            }
+            for (const item of deleted) {
+                const id = this.getEntityId(item);
+                const key = this.getItemKey(item);
+                if (id || key) {
+                    const itemEntityName = this.getEntityName(item);
+                    const deleteId = id || key;
+                    changes.addDelete(itemEntityName, deleteId, item, depth, relationField, parentId, parentEntity);
+                    this.markNestedItemsAsDeleted(item, depth, changes, rootTracker);
+                }
+            }
+        }
+    }
+    /**
+     * Recursively marks all nested items as created when a parent is created.
+     */
+    markNestedItemsAsCreated(item, parentDepth, changes) {
+        if (!item || typeof item !== "object")
+            return;
+        const propsToScan = item.props || item;
+        const parentId = this.getEntityId(item);
+        const parentEntity = this.getEntityName(item);
+        for (const [propName, value] of Object.entries(propsToScan)) {
+            if (propName === "id")
+                continue;
+            if (Array.isArray(value)) {
+                const relationField = propName;
+                for (const child of value) {
+                    if (child instanceof Entity) {
+                        const childEntityName = this.getEntityName(child);
+                        changes.addCreate(childEntityName, child, parentDepth + 1, parentId, parentEntity, relationField);
+                        this.markNestedItemsAsCreated(child, parentDepth + 1, changes);
+                    }
+                }
+            }
+            else if (value instanceof Entity) {
+                const childEntityName = this.getEntityName(value);
+                changes.addCreate(childEntityName, value, parentDepth + 1, parentId, parentEntity, propName);
+                this.markNestedItemsAsCreated(value, parentDepth + 1, changes);
+            }
+        }
+    }
+    /**
+     * Recursively marks all nested items as deleted when a parent is deleted.
+     * Uses the original captured state to find nested items.
+     */
+    markNestedItemsAsDeleted(item, parentDepth, changes, rootTracker) {
+        if (!item || typeof item !== "object")
+            return;
+        const itemId = this.getEntityId(item);
+        if (!itemId)
+            return;
+        for (const [path, arrayState] of rootTracker.trackedArrays) {
+            if (arrayState.metadata.parentId === itemId) {
+                const relationField = this.extractRelationField(path);
+                const parentEntity = arrayState.metadata.parentEntity;
+                const parentId = arrayState.metadata.parentId;
+                for (const nestedItem of arrayState.cloned) {
+                    const id = typeof nestedItem === "object" && nestedItem !== null
+                        ? nestedItem.id
+                        : undefined;
+                    if (id) {
+                        const entityName = arrayState.metadata.entityName;
+                        changes.addDelete(entityName, id, nestedItem, parentDepth + 1, relationField, parentEntity, parentId);
+                        this.markNestedJsonItemAsDeleted(id, parentDepth + 1, changes, rootTracker);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Recursively marks nested items as deleted from a JSON object.
+     * This is used when processing cloned (JSON) state.
+     */
+    markNestedJsonItemAsDeleted(itemId, parentDepth, changes, rootTracker) {
+        for (const [path, arrayState] of rootTracker.trackedArrays) {
+            if (arrayState.metadata.parentId === itemId) {
+                const relationField = this.extractRelationField(path);
+                for (const nestedJsonItem of arrayState.cloned) {
+                    if (typeof nestedJsonItem !== "object" || nestedJsonItem === null)
+                        continue;
+                    const nestedId = nestedJsonItem.id;
+                    const entityName = arrayState.metadata.entityName;
+                    const parentEntity = arrayState.metadata.parentEntity;
+                    const parentId = arrayState.metadata.parentId;
+                    if (nestedId) {
+                        changes.addDelete(entityName, nestedId, nestedJsonItem, parentDepth + 1, relationField, parentId, parentEntity);
+                        this.markNestedJsonItemAsDeleted(nestedId, parentDepth + 1, changes, rootTracker);
+                    }
+                    else {
+                        const key = this.extractIdentityKeyFromJson(nestedJsonItem, arrayState.original);
+                        if (key) {
+                            changes.addDelete(entityName, key, nestedJsonItem, parentDepth + 1, relationField, parentId, parentEntity);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Extracts identity key from a JSON object by looking at the original Entity instances.
+     */
+    extractIdentityKeyFromJson(jsonItem, originalArray) {
+        for (const originalItem of originalArray) {
+            if (originalItem instanceof Entity) {
+                const originalJson = this.deepClone(originalItem);
+                if (JSON.stringify(originalJson) === JSON.stringify(jsonItem)) {
+                    const key = this.getItemKey(originalItem);
+                    if (key)
+                        return key;
+                }
+            }
+        }
+        if (jsonItem.id)
+            return jsonItem.id;
+        return undefined;
+    }
+    collectNestedArrays(obj, basePath, allArrays, processedArrays) {
+        if (!obj || typeof obj !== "object")
+            return;
+        for (const [propName, value] of Object.entries(obj)) {
+            if (propName === "id" || propName === "proxy" || propName === "_props")
+                continue;
+            const propPath = basePath ? `${basePath}.${propName}` : propName;
+            if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    if (item instanceof Entity) {
+                        this.collectNestedArrays(item, `${propPath}[${index}]`, allArrays, processedArrays);
+                    }
+                });
+            }
+            else if (value instanceof Entity) {
+                this.collectNestedArrays(value, propPath, allArrays, processedArrays);
+            }
+        }
+    }
+    analyzeEntityChanges(changes, rootTracker) {
+        for (const [path, trackedItem] of rootTracker.trackedEntities) {
+            if (path === "root")
+                continue;
+            if (path.includes("["))
+                continue;
+            const currentValue = this.getValueAtPath(this.target, path);
+            const originalValue = trackedItem.originalState;
+            const originalEntity = trackedItem.entity;
+            const { entityName, depth, parentId, parentEntity } = trackedItem.metadata;
+            const relationField = this.extractRelationField(path);
+            const state = this.detectEntityChangeState(originalValue, currentValue);
+            switch (state) {
+                case "created":
+                    changes.addCreate(entityName, currentValue, depth, parentId, parentEntity, relationField);
+                    break;
+                case "deleted":
+                    const id = this.getEntityId(originalValue);
+                    if (id) {
+                        changes.addDelete(entityName, id, originalEntity, depth, relationField, parentId, parentEntity);
+                    }
+                    break;
+                case "replaced":
+                    const oldId = this.getEntityId(originalValue);
+                    if (oldId) {
+                        changes.addDelete(entityName, oldId, originalEntity, depth, relationField, parentId, parentEntity);
+                    }
+                    changes.addCreate(entityName, currentValue, depth, parentId, parentEntity, relationField);
+                    break;
+                case "updated":
+                    const updateId = this.getEntityId(currentValue);
+                    if (updateId) {
+                        const changedFields = this.detectChangedFields(originalValue, currentValue);
+                        if (Object.keys(changedFields).length > 0) {
+                            changes.addUpdate(entityName, updateId, currentValue, changedFields, depth);
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+    detectEntityChangeState(previous, current) {
+        if (previous === null && current !== null) {
+            return "created";
+        }
+        if (previous !== null && current === null) {
+            return "deleted";
+        }
+        if (previous !== null && current !== null) {
+            const prevId = this.getEntityId(previous);
+            const currId = this.getEntityId(current);
+            if (prevId && currId && prevId === currId) {
+                return this.hasChanged(previous, current) ? "updated" : "unchanged";
+            }
+            else {
+                return "replaced";
+            }
+        }
+        return "unchanged";
+    }
+    detectArrayChanges(oldCloned, oldOriginal, newArray) {
+        const created = [];
+        const updated = [];
+        const deleted = [];
+        const oldMap = new Map();
+        const newMap = new Map();
+        oldCloned.forEach((item) => {
+            const key = this.getItemKey(item);
+            if (key)
+                oldMap.set(key, item);
+        });
+        newArray.forEach((item) => {
+            const key = this.getItemKey(item);
+            if (key)
+                newMap.set(key, item);
+        });
+        newArray.forEach((item) => {
+            const key = this.getItemKey(item);
+            if (!key) {
+                created.push(item);
+            }
+            else if (!oldMap.has(key)) {
+                created.push(item);
+            }
+            else if (this.hasChanged(oldMap.get(key), item)) {
+                updated.push(item);
+            }
+        });
+        oldOriginal.forEach((item) => {
+            const key = this.getItemKey(item);
+            if (key && !newMap.has(key)) {
+                deleted.push(item);
+            }
+        });
+        return { created, updated, deleted };
+    }
+    detectChangedFields(original, current) {
+        const changes = {};
+        if (!original || !current)
+            return changes;
+        const origProps = original.props || original;
+        const currProps = current.props || current;
+        for (const key of Object.keys(currProps)) {
+            if (key === "id")
+                continue;
+            const origValue = origProps[key];
+            const currValue = currProps[key];
+            if (Array.isArray(currValue) || currValue instanceof Entity) {
+                continue;
+            }
+            if (!this.isEqual(origValue, currValue)) {
+                changes[key] =
+                    currValue instanceof ValueObject ? currValue.value : currValue;
+            }
+        }
+        return changes;
+    }
+    handleArrayAssignment(path, oldValue) {
+        const rootTracker = this.getRootTracker();
+        if (!rootTracker.trackedArrays.has(path)) {
+            const parentId = this.getEntityId(this.target);
+            rootTracker.captureArrayState(Array.isArray(oldValue) ? oldValue : [], path, this.depth + 1, parentId, this.rootEntityName);
+        }
+    }
+    handleEntityChange(path, oldValue, newValue) {
+        const rootTracker = this.getRootTracker();
+        const entityName = newValue
+            ? this.getEntityName(newValue)
+            : this.getEntityName(oldValue);
+        const existingTracked = rootTracker.trackedEntities.get(path);
+        rootTracker.trackedEntities.set(path, {
+            entity: existingTracked?.entity || oldValue,
+            metadata: {
+                entityName,
+                depth: this.depth + 1,
+                parentId: this.getEntityId(this.target),
+                parentEntity: this.rootEntityName,
+                path,
+            },
+            originalState: existingTracked?.originalState,
+        });
+    }
+    getRootTracker() {
+        return this.rootTracker || this;
+    }
+    buildPath(prop) {
+        return this.path ? `${this.path}.${prop}` : prop;
+    }
+    shouldSkipProperty(prop) {
+        const skipProps = [
+            "__isProxy",
+            "__tracker",
+            "__originalTarget",
+            "__path",
+            "constructor",
+            "prototype",
+        ];
+        return skipProps.includes(String(prop));
+    }
+    getValueAtPath(obj, path) {
+        if (!path)
+            return obj;
+        const parts = path.split(/[.\[\]]+/).filter(Boolean);
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined)
+                return undefined;
+            const propsToAccess = current.props || current;
+            current = propsToAccess[part];
+        }
+        return current;
+    }
+    extractRelationField(path) {
+        const withoutIndices = path.replace(/\[\d+\]/g, "");
+        const parts = withoutIndices.split(".");
+        return parts[parts.length - 1];
+    }
+    getItemKey(item) {
+        const id = this.getEntityId(item);
+        if (id)
+            return id;
+        return undefined;
+    }
+    getEntityId(item) {
+        if (!item)
+            return undefined;
+        if (item.id instanceof Id)
+            return item.id.value;
+        if (item.id !== undefined)
+            return String(item.id);
+        return undefined;
+    }
+    getEntityName(item) {
+        if (!item)
+            return "Unknown";
+        return item.constructor?.name || "Unknown";
+    }
+    isEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a instanceof Id && b instanceof Id)
+            return a.equals(b);
+        if (a instanceof ValueObject && b instanceof ValueObject)
+            return a.equals(b);
+        if (a instanceof Date && b instanceof Date)
+            return a.getTime() === b.getTime();
+        try {
+            return this.hasChanged(a, b) === false;
+        }
+        catch {
+            return this.deepEqual(a, b);
+        }
+    }
+    deepEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a == null || b == null)
+            return a === b;
+        if (typeof a !== typeof b)
+            return false;
+        if (typeof a !== "object")
+            return a === b;
+        if (Array.isArray(a) !== Array.isArray(b))
+            return false;
+        if (Array.isArray(a)) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (!this.deepEqual(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        const keysA = Object.keys(a).filter((key) => {
+            const value = a[key];
+            return (typeof value !== "object" ||
+                value instanceof Date ||
+                value instanceof Id ||
+                value === null);
+        });
+        const keysB = Object.keys(b).filter((key) => {
+            const value = b[key];
+            return (typeof value !== "object" ||
+                value instanceof Date ||
+                value instanceof Id ||
+                value === null);
+        });
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const key of keysA) {
+            if (!keysB.includes(key))
+                return false;
+            if (!this.isEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    hasChanged(obj1, obj2) {
+        const json1 = this.normalizeAndStringify(this.deepClone(obj1));
+        const json2 = this.normalizeAndStringify(this.deepClone(obj2));
+        return json1 !== json2;
+    }
+    cloneArray(arr) {
+        return arr.map((item) => this.deepClone(item));
+    }
+    deepClone(obj) {
+        if (obj === null || obj === undefined || typeof obj !== "object") {
+            return obj;
+        }
+        if (obj instanceof Id) {
+            return obj.value;
+        }
+        if (obj instanceof ValueObject) {
+            return obj.value;
+        }
+        if (typeof obj.toJSON === "function") {
+            return obj.toJSON();
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.deepClone(item));
+        }
+        if (obj instanceof Date) {
+            return new Date(obj.getTime());
+        }
+        try {
+            return structuredClone(obj);
+        }
+        catch {
+            const cloned = {};
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    cloned[key] = this.deepClone(obj[key]);
+                }
+            }
+            return cloned;
+        }
+    }
+    normalizeAndStringify(obj) {
+        if (obj === null || typeof obj !== "object") {
+            return JSON.stringify(obj);
+        }
+        if (Array.isArray(obj)) {
+            return `[${obj
+                .map((item) => this.normalizeAndStringify(item))
+                .join(",")}]`;
+        }
+        const keys = Object.keys(obj).sort();
+        const parts = keys.map((key) => `"${key}":${this.normalizeAndStringify(obj[key])}`);
+        return `{${parts.join(",")}}`;
+    }
+    getHistory() {
+        return [...this.getRootTracker().history];
+    }
+    clearHistory() {
+        const rootTracker = this.getRootTracker();
+        rootTracker.history = [];
+        rootTracker.originalValues.clear();
+        rootTracker.trackedArrays.clear();
+        rootTracker.trackedEntities.clear();
+        this.captureInitialState();
+    }
+    markAsClean() {
+        this.clearHistory();
+    }
+    getTarget() {
+        return this.target;
+    }
+}
+//# sourceMappingURL=change-tracker.js.map