@signaltree/core 5.1.6 → 6.0.1

package/src/lib/types.d.ts

@@ -1,5 +1,24 @@
 import { Signal, WritableSignal } from '@angular/core';
-import type { SecurityValidatorConfig } from './security/security-validator';
+import { SecurityValidatorConfig } from './security/security-validator';
+export interface TimeTravelConfig {
+    enabled?: boolean;
+    maxHistorySize?: number;
+    includePayload?: boolean;
+    actionNames?: {
+        update?: string;
+        set?: string;
+        batch?: string;
+        [key: string]: string | undefined;
+    };
+}
+export interface MemoizationConfig {
+    enabled?: boolean;
+    maxCacheSize?: number;
+    ttl?: number;
+    enableLRU?: boolean;
+    equality?: 'deep' | 'shallow' | 'reference';
+}
+export type Primitive = string | number | boolean | null | undefined | bigint | symbol;
 export type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
 declare module '@angular/core' {
     interface WritableSignal<T> {
@@ -7,73 +26,77 @@ declare module '@angular/core' {
         (updater: (current: T) => T): void;
     }
 }
-export type Primitive = string | number | boolean | null | undefined | bigint | symbol;
-export type BuiltInObject = Date | RegExp | ((...args: unknown[]) => unknown) | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView | Error | Promise<unknown> | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | URL | URLSearchParams | FormData | Blob | File | Headers | Request | Response | AbortController | AbortSignal;
-export type Unwrap<T> = [T] extends [WritableSignal<infer U>] ? U : [T] extends [Signal<infer U>] ? U : [T] extends [BuiltInObject] ? T : [T] extends [readonly unknown[]] ? T : [T] extends [EntityMapMarker<infer E, infer K>] ? EntitySignal<E, K> : [T] extends [object] ? {
-    [K in keyof T]: Unwrap<T[K]>;
-} : T;
 export interface NodeAccessor<T> {
     (): T;
     (value: T): void;
     (updater: (current: T) => T): void;
 }
-export type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
-export type CallableWritableSignal<T> = WritableSignal<T> & {
-    (value: NotFn<T>): void;
-    (updater: (current: T) => T): void;
-};
 export type TreeNode<T> = {
-    [K in keyof T]: [T[K]] extends [EntityMapMarker<infer E, infer Key>] ? EntitySignal<E, Key> : [T[K]] extends [readonly unknown[]] ? CallableWritableSignal<T[K]> : [T[K]] extends [object] ? [T[K]] extends [Signal<unknown>] ? T[K] : [T[K]] extends [BuiltInObject] ? CallableWritableSignal<T[K]> : [T[K]] extends [(...args: unknown[]) => unknown] ? CallableWritableSignal<T[K]> : AccessibleNode<T[K]> : CallableWritableSignal<T[K]>;
+    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends Primitive ? CallableWritableSignal<T[K]> : T[K] extends readonly unknown[] ? CallableWritableSignal<T[K]> : T[K] extends Date | RegExp | Map<any, any> | Set<any> | Error | ((...args: unknown[]) => unknown) ? CallableWritableSignal<T[K]> : T[K] extends object ? NodeAccessor<T[K]> & TreeNode<T[K]> : CallableWritableSignal<T[K]>;
 };
-export type RemoveSignalMethods<T> = T extends infer U ? U : never;
-export type DeepPath<T, Prefix extends string = '', Depth extends readonly number[] = []> = Depth['length'] extends 5 ? never : {
-    [K in keyof T]: K extends string ? T[K] extends readonly unknown[] ? `${Prefix}${K}` : T[K] extends object ? T[K] extends Signal<unknown> ? never : T[K] extends BuiltInObject ? never : T[K] extends (...args: unknown[]) => unknown ? never : `${Prefix}${K}` | DeepPath<T[K], `${Prefix}${K}.`, [...Depth, 1]> : never : never;
-}[keyof T];
-export type DeepAccess<T, Path extends string> = Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? DeepAccess<T[First] & object, Rest> : never : Path extends keyof T ? T[Path] : never;
-export interface EnhancerMeta {
-    name?: string;
-    requires?: string[];
-    provides?: string[];
+export interface ISignalTree<T> extends NodeAccessor<T> {
+    readonly state: TreeNode<T>;
+    readonly $: TreeNode<T>;
+    with<R>(enhancer: (tree: this) => R): R;
+    bind(thisArg?: unknown): NodeAccessor<T>;
+    destroy(): void;
 }
-export type Enhancer<Input = unknown, Output = unknown> = (input: Input) => Output;
-export type EnhancerWithMeta<Input = unknown, Output = unknown> = Enhancer<Input, Output> & {
-    metadata?: EnhancerMeta;
-};
-export declare const ENHANCER_META: unique symbol;
-export type ChainResult<Start, E extends Array<EnhancerWithMeta<unknown, unknown>>> = E extends [infer H, ...infer R] ? H extends EnhancerWithMeta<SignalTree<unknown>, infer O> ? R extends Array<EnhancerWithMeta<unknown, unknown>> ? ChainResult<O, R> : O : H extends EnhancerWithMeta<infer I, infer O> ? Start extends I ? R extends Array<EnhancerWithMeta<unknown, unknown>> ? ChainResult<O, R> : O : unknown : unknown : Start;
-export interface WithMethod<T> {
-    (): SignalTree<T>;
-    <O>(enhancer: (input: SignalTree<T>) => O): O;
-    <O1, O2>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2): O2;
-    <O1, O2, O3>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2, e3: (input: O2) => O3): O3;
-    <O>(enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;
-    <O1, O2>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>): O2;
-    <O1, O2, O3>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>): O3;
+export interface EffectsMethods<T> {
+    effect(fn: (state: T) => void | (() => void)): () => void;
+    subscribe(fn: (state: T) => void): () => void;
 }
-export type SignalTree<T> = NodeAccessor<T> & {
-    state: TreeNode<T>;
-    $: TreeNode<T>;
-    with: WithMethod<T>;
-    destroy(): void;
-    dispose?(): void;
-    effect(fn: (tree: T) => void): void;
-    subscribe(fn: (tree: T) => void): () => void;
-    batch(updater: (tree: T) => void): void;
-    batchUpdate(updater: (current: T) => Partial<T>): void;
-    memoize<R>(fn: (tree: T) => R, cacheKey?: string): Signal<R>;
-    memoizedUpdate(updater: (current: T) => Partial<T>, cacheKey?: string): void;
+export interface BatchingConfig {
+    enabled?: boolean;
+    debounceMs?: number;
+    batchTimeoutMs?: number;
+    autoFlushDelay?: number;
+    maxBatchSize?: number;
+}
+export interface BatchingMethods<T = unknown> {
+    batch(fn: () => void): void;
+}
+export interface MemoizationMethods<T> {
+    memoize<R>(fn: (state: T) => R, cacheKey?: string): Signal<R>;
+    memoizedUpdate?: (updater: (current: T) => Partial<T>, cacheKey?: string) => void;
     clearMemoCache(key?: string): void;
-    getCacheStats(): {
-        size: number;
-        hitRate: number;
-        totalHits: number;
-        totalMisses: number;
-        keys: string[];
+    clearCache?: (key?: string) => void;
+    getCacheStats(): CacheStats;
+}
+export type CacheStats = {
+    size: number;
+    hitRate: number;
+    totalHits: number;
+    totalMisses: number;
+    keys: string[];
+};
+export interface TimeTravelMethods<T = unknown> {
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getHistory(): TimeTravelEntry<T>[];
+    resetHistory(): void;
+    jumpTo(index: number): void;
+    getCurrentIndex(): number;
+    readonly __timeTravel?: {
+        undo(): void;
+        redo(): void;
+        canUndo(): boolean;
+        canRedo(): boolean;
+        getHistory(): TimeTravelEntry<T>[];
+        resetHistory(): void;
+        jumpTo(index: number): void;
+        getCurrentIndex(): number;
     };
-    optimize(): void;
-    clearCache(): void;
-    invalidatePattern(pattern: string): number;
-    updateOptimized?(updates: Partial<T>, options?: {
+}
+export interface DevToolsMethods {
+    connectDevTools(): void;
+    disconnectDevTools(): void;
+}
+export interface EntitiesEnabled {
+}
+export interface OptimizedUpdateMethods<T> {
+    updateOptimized(updates: Partial<T>, options?: {
         batch?: boolean;
         batchSize?: number;
         maxDepth?: number;
@@ -89,18 +112,13 @@ export type SignalTree<T> = NodeAccessor<T> & {
             batchedUpdates: number;
         };
     };
-    entities<E extends {
-        id: string | number;
-    }>(entityKey?: keyof T): EntityHelpers<E>;
-    undo(): void;
-    redo(): void;
-    getHistory(): TimeTravelEntry<T>[];
-    resetHistory(): void;
-    jumpTo?: (index: number) => void;
-    canUndo?: () => boolean;
-    canRedo?: () => boolean;
-    getCurrentIndex?: () => number;
-};
+}
+export interface TimeTravelEntry<T> {
+    action: string;
+    timestamp: number;
+    state: T;
+    payload?: unknown;
+}
 export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
 export interface TreeConfig {
     batchUpdates?: boolean;
@@ -196,20 +214,6 @@ export interface EntitySignal<E, K extends string | number = string> {
     tap(handlers: TapHandlers<E, K>): () => void;
     intercept(handlers: InterceptHandlers<E, K>): () => void;
 }
-export interface EntityHelpers<E extends {
-    id: string | number;
-}> {
-    add(entity: E): void;
-    update(id: E['id'], updates: Partial<E>): void;
-    remove(id: E['id']): void;
-    upsert(entity: E): void;
-    selectById(id: E['id']): Signal<E | undefined>;
-    selectBy(predicate: (entity: E) => boolean): Signal<E[]>;
-    selectIds(): Signal<Array<string | number>>;
-    selectAll(): Signal<E[]>;
-    selectTotal(): Signal<number>;
-    clear(): void;
-}
 export interface LoggingConfig {
     name?: string;
     filter?: (path: string) => boolean;
@@ -238,7 +242,13 @@ export interface PersistenceConfig {
     deserialize?: (json: string) => unknown;
 }
 export interface DevToolsConfig {
+    enableBrowserDevTools?: boolean;
+    enableLogging?: boolean;
+    performanceThreshold?: number;
     name?: string;
+    treeName?: string;
+    enabled?: boolean;
+    logActions?: boolean;
     maxAge?: number;
     features?: {
         jump?: boolean;
@@ -249,8 +259,14 @@ export interface DevToolsConfig {
 export type EntityType<T> = T extends EntitySignal<infer E, infer K extends string | number> ? E : never;
 export type EntityKeyType<T> = T extends EntitySignal<unknown, infer K extends string | number> ? K : never;
 export type IsEntityMap<T> = T extends EntityMapMarker<unknown, infer K extends string | number> ? true : false;
+export type DeepEntityAwareTreeNode<T> = {
+    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends object ? DeepEntityAwareTreeNode<T[K]> : CallableWritableSignal<T[K]>;
+};
 export type EntityAwareTreeNode<T> = {
-    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends object ? EntityAwareTreeNode<T[K]> : CallableWritableSignal<T[K]>;
+    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : CallableWritableSignal<T[K]>;
+};
+export type TypedSignalTree<T> = ISignalTree<T> & {
+    $: DeepEntityAwareTreeNode<T>;
 };
 export type PathHandler = (value: unknown, prev: unknown, path: string) => void;
 export type PathInterceptor = (ctx: {
@@ -260,11 +276,26 @@ export type PathInterceptor = (ctx: {
     blocked: boolean;
     blockReason?: string;
 }, next: () => void) => void | Promise<void>;
-export interface TimeTravelEntry<T> {
-    action: string;
-    timestamp: number;
-    state: T;
-    payload?: unknown;
+export type CallableWritableSignal<T> = WritableSignal<T> & {
+    (value: NotFn<T>): void;
+    (updater: (current: T) => T): void;
+};
+export type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
+export declare const ENHANCER_META: unique symbol;
+export type Enhancer<TAdded> = <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TAdded;
+export type EnhancerWithMeta<TAdded> = Enhancer<TAdded> & {
+    metadata?: EnhancerMeta;
+};
+export interface EnhancerMeta {
+    name?: string;
+    requires?: string[];
+    provides?: string[];
+    description?: string;
 }
-export declare function isSignalTree<T>(value: unknown): value is SignalTree<T>;
+export type FullSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods<T> & MemoizationMethods<T> & TimeTravelMethods<T> & DevToolsMethods & EntitiesEnabled & OptimizedUpdateMethods<T>;
+export type ProdSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods<T> & MemoizationMethods<T> & EntitiesEnabled & OptimizedUpdateMethods<T>;
+export type MinimalSignalTree<T> = ISignalTree<T> & EffectsMethods<T>;
+export type SignalTree<T> = ISignalTree<T>;
+export type SignalTreeBase<T> = ISignalTree<T>;
+export declare function isSignalTree<T>(value: unknown): value is ISignalTree<T>;
 export {};

package/src/lib/utils.d.ts

@@ -4,6 +4,7 @@ export { deepEqual };
 export { deepEqual as equal };
 export { isBuiltInObject };
 export { parsePath };
+export declare function isEntityMapMarker(value: unknown): boolean;
 export interface MemoryManager {
     getSignal(path: string): WritableSignal<unknown> | undefined;
     cacheSignal(path: string, signal: WritableSignal<unknown>): void;
@@ -26,3 +27,6 @@ export declare function unwrap<T>(node: TreeNode<T>): T;
 export declare function unwrap<T>(node: NodeAccessor<T> & TreeNode<T>): T;
 export declare function unwrap<T>(node: NodeAccessor<T>): T;
 export declare function unwrap<T>(node: unknown): T;
+export declare function snapshotState<T>(state: TreeNode<T>): T;
+export declare function applyState<T>(stateNode: TreeNode<T>, snapshot: T): void;
+export declare function deepCloneJSON<T>(value: T): T;

package/dist/deep-clone.js

@@ -1,80 +0,0 @@
-const globalStructuredClone = typeof globalThis === 'object' && globalThis !== null ? globalThis.structuredClone : undefined;
-function deepClone(value) {
-  if (globalStructuredClone) {
-    try {
-      return globalStructuredClone(value);
-    } catch (_a) {}
-  }
-  return cloneValue(value, new WeakMap());
-}
-function cloneValue(value, seen) {
-  if (value === null || typeof value !== 'object') {
-    return value;
-  }
-  if (typeof value === 'function') {
-    return value;
-  }
-  const existing = seen.get(value);
-  if (existing) {
-    return existing;
-  }
-  if (value instanceof Date) {
-    return new Date(value.getTime());
-  }
-  if (value instanceof RegExp) {
-    return new RegExp(value.source, value.flags);
-  }
-  if (value instanceof Map) {
-    const result = new Map();
-    seen.set(value, result);
-    for (const [key, entryValue] of value) {
-      result.set(cloneValue(key, seen), cloneValue(entryValue, seen));
-    }
-    return result;
-  }
-  if (value instanceof Set) {
-    const result = new Set();
-    seen.set(value, result);
-    for (const entry of value) {
-      result.add(cloneValue(entry, seen));
-    }
-    return result;
-  }
-  if (Array.isArray(value)) {
-    const result = new Array(value.length);
-    seen.set(value, result);
-    for (let i = 0; i < value.length; i++) {
-      result[i] = cloneValue(value[i], seen);
-    }
-    return result;
-  }
-  if (ArrayBuffer.isView(value)) {
-    if (value instanceof DataView) {
-      const bufferClone = cloneValue(value.buffer, seen);
-      return new DataView(bufferClone, value.byteOffset, value.byteLength);
-    }
-    const viewWithSlice = value;
-    if (typeof viewWithSlice.slice === 'function') {
-      return viewWithSlice.slice();
-    }
-    const bufferClone = cloneValue(value.buffer, seen);
-    return new value.constructor(bufferClone, value.byteOffset, value.length);
-  }
-  if (value instanceof ArrayBuffer) {
-    return value.slice(0);
-  }
-  const proto = Object.getPrototypeOf(value);
-  const result = proto ? Object.create(proto) : {};
-  seen.set(value, result);
-  for (const key of Reflect.ownKeys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (!descriptor) continue;
-    if ('value' in descriptor) {
-      descriptor.value = cloneValue(descriptor.value, seen);
-    }
-    Object.defineProperty(result, key, descriptor);
-  }
-  return result;
-}
-
-export { deepClone };

package/dist/enhancers/computed/lib/computed.js

@@ -1,21 +0,0 @@
-import { computed } from '@angular/core';
-import { createEnhancer } from '../../index.js';
-
-function computedEnhancer(_config = {}) {
-  return createEnhancer({
-    name: 'computed',
-    provides: ['computed'],
-    requires: []
-  }, tree => {
-    const computedTree = tree;
-    computedTree.computed = function (computeFn) {
-      return computed(() => computeFn(tree.state));
-    };
-    return computedTree;
-  });
-}
-function createComputed(dependencies, computeFn) {
-  return computed(computeFn);
-}
-
-export { computedEnhancer, createComputed };

package/dist/enhancers/entities/lib/entities.js

@@ -1,66 +0,0 @@
-import { createEntitySignal } from '../../../lib/entity-signal.js';
-import { getPathNotifier } from '../../../lib/path-notifier.js';
-import { isNodeAccessor } from '../../../lib/utils.js';
-
-function isEntityMapMarker(value) {
-  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
-}
-function materializeEntities(tree, notifier = getPathNotifier()) {
-  const state = tree.state;
-  const visit = (parent, key, value, path) => {
-    const nextPath = [...path, key];
-    if (isEntityMapMarker(value)) {
-      const basePath = nextPath.join('.');
-      const config = value.__entityMapConfig ?? {};
-      const entitySignal = createEntitySignal(config, notifier, basePath);
-      if (parent) {
-        try {
-          parent[key] = entitySignal;
-        } catch {}
-      }
-      try {
-        tree[key] = entitySignal;
-      } catch {}
-      return;
-    }
-    if (isNodeAccessor(value)) {
-      const nodeAsAny = value;
-      for (const childKey of Object.keys(nodeAsAny)) {
-        visit(nodeAsAny, childKey, nodeAsAny[childKey], nextPath);
-      }
-      return;
-    }
-    if (value && typeof value === 'object') {
-      for (const childKey of Object.keys(value)) {
-        visit(value, childKey, value[childKey], nextPath);
-      }
-    }
-  };
-  for (const key of Object.keys(state)) {
-    visit(state, key, state[key], []);
-  }
-}
-function withEntities(config = {}) {
-  const {
-    enabled = true
-  } = config;
-  return function enhanceWithEntities(tree) {
-    if (!enabled) {
-      return tree;
-    }
-    materializeEntities(tree);
-    return tree;
-  };
-}
-function enableEntities() {
-  return withEntities({
-    enabled: true
-  });
-}
-function withHighPerformanceEntities() {
-  return withEntities({
-    enabled: true
-  });
-}
-
-export { enableEntities, withEntities, withHighPerformanceEntities };

package/dist/lib/performance/diff-engine.js

@@ -1,156 +0,0 @@
-var ChangeType;
-(function (ChangeType) {
-  ChangeType["ADD"] = "add";
-  ChangeType["UPDATE"] = "update";
-  ChangeType["DELETE"] = "delete";
-  ChangeType["REPLACE"] = "replace";
-})(ChangeType || (ChangeType = {}));
-class DiffEngine {
-  defaultOptions = {
-    maxDepth: 100,
-    detectDeletions: false,
-    ignoreArrayOrder: false,
-    equalityFn: (a, b) => a === b,
-    keyValidator: undefined
-  };
-  diff(current, updates, options = {}) {
-    const opts = {
-      ...this.defaultOptions,
-      ...options
-    };
-    const changes = [];
-    const visited = new WeakSet();
-    this.traverse(current, updates, [], changes, visited, opts, 0);
-    return {
-      changes,
-      hasChanges: changes.length > 0
-    };
-  }
-  traverse(curr, upd, path, changes, visited, opts, depth) {
-    if (depth > opts.maxDepth) {
-      return;
-    }
-    if (typeof upd !== 'object' || upd === null) {
-      if (!opts.equalityFn(curr, upd)) {
-        changes.push({
-          type: curr === undefined ? ChangeType.ADD : ChangeType.UPDATE,
-          path: [...path],
-          value: upd,
-          oldValue: curr
-        });
-      }
-      return;
-    }
-    if (visited.has(upd)) {
-      return;
-    }
-    visited.add(upd);
-    if (Array.isArray(upd)) {
-      this.diffArrays(curr, upd, path, changes, visited, opts, depth);
-      return;
-    }
-    if (!curr || typeof curr !== 'object' || Array.isArray(curr)) {
-      changes.push({
-        type: ChangeType.REPLACE,
-        path: [...path],
-        value: upd,
-        oldValue: curr
-      });
-      return;
-    }
-    const currObj = curr;
-    const updObj = upd;
-    for (const key in updObj) {
-      if (Object.prototype.hasOwnProperty.call(updObj, key)) {
-        if (opts.keyValidator && !opts.keyValidator(key)) {
-          continue;
-        }
-        this.traverse(currObj[key], updObj[key], [...path, key], changes, visited, opts, depth + 1);
-      }
-    }
-    if (opts.detectDeletions) {
-      for (const key in currObj) {
-        if (Object.prototype.hasOwnProperty.call(currObj, key) && !(key in updObj)) {
-          changes.push({
-            type: ChangeType.DELETE,
-            path: [...path, key],
-            oldValue: currObj[key]
-          });
-        }
-      }
-    }
-  }
-  diffArrays(curr, upd, path, changes, visited, opts, depth) {
-    if (!Array.isArray(curr)) {
-      changes.push({
-        type: ChangeType.REPLACE,
-        path: [...path],
-        value: upd,
-        oldValue: curr
-      });
-      return;
-    }
-    if (opts.ignoreArrayOrder) {
-      this.diffArraysUnordered(curr, upd, path, changes, opts);
-    } else {
-      this.diffArraysOrdered(curr, upd, path, changes, visited, opts, depth);
-    }
-  }
-  diffArraysOrdered(curr, upd, path, changes, visited, opts, depth) {
-    const maxLength = Math.max(curr.length, upd.length);
-    for (let i = 0; i < maxLength; i++) {
-      if (i >= upd.length) {
-        if (opts.detectDeletions) {
-          changes.push({
-            type: ChangeType.DELETE,
-            path: [...path, i],
-            oldValue: curr[i]
-          });
-        }
-      } else if (i >= curr.length) {
-        changes.push({
-          type: ChangeType.ADD,
-          path: [...path, i],
-          value: upd[i]
-        });
-      } else {
-        this.traverse(curr[i], upd[i], [...path, i], changes, visited, opts, depth + 1);
-      }
-    }
-  }
-  diffArraysUnordered(curr, upd, path, changes, opts) {
-    const currSet = new Set(curr.map(v => this.stringify(v)));
-    const updSet = new Set(upd.map(v => this.stringify(v)));
-    upd.forEach((value, index) => {
-      const str = this.stringify(value);
-      if (!currSet.has(str)) {
-        changes.push({
-          type: ChangeType.ADD,
-          path: [...path, index],
-          value
-        });
-      }
-    });
-    if (opts.detectDeletions) {
-      curr.forEach((value, index) => {
-        const str = this.stringify(value);
-        if (!updSet.has(str)) {
-          changes.push({
-            type: ChangeType.DELETE,
-            path: [...path, index],
-            oldValue: value
-          });
-        }
-      });
-    }
-  }
-  stringify(value) {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return String(value);
-    }
-  }
-}
-
-export { ChangeType, DiffEngine };