j-templates 8.0.13 → 8.0.14

package/Node/vNode.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.vNode = void 0;
-const Store_1 = require("../Store");
-const observableScope_1 = require("../Store/Tree/observableScope");
-const array_1 = require("../Utils/array");
-const emitter_1 = require("../Utils/emitter");
-const functions_1 = require("../Utils/functions");
-const injector_1 = require("../Utils/injector");
-const thread_1 = require("../Utils/thread");
-const nodeConfig_1 = require("./nodeConfig");
-const vNode_types_1 = require("./vNode.types");
-var vNode;
+import { ObservableScope } from "../Store";
+import { InlineScope, MappedScope, } from "../Store/Tree/observableScope";
+import { RemoveNulls } from "../Utils/array";
+import { Emitter } from "../Utils/emitter";
+import { IsAsync } from "../Utils/functions";
+import { Injector } from "../Utils/injector";
+import { Schedule, Thread } from "../Utils/thread";
+import { NodeConfig } from "./nodeConfig";
+import { isStringNode, TEXT_NODE, FRAGMENT_NODE, STRING_NODE, } from "./vNode.types";
+export var vNode;
 (function (vNode) {
     function Create(definition) {
         return {
             definition,
             type: definition.type,
             injector: definition.componentFactory
-                ? new injector_1.Injector()
-                : (injector_1.Injector.Current() ?? new injector_1.Injector()),
+                ? new Injector()
+                : (Injector.Current() ?? new Injector()),
             parentNode: null,
             node: definition.node ?? null,
             children: null,
@@ -30,7 +27,7 @@ var vNode;
     }
     vNode.Create = Create;
     function Init(vnode, parentNode = null) {
-        if ((0, vNode_types_1.isStringNode)(vnode) || vnode.definition === null)
+        if (isStringNode(vnode) || vnode.definition === null)
             return;
         InitNode(vnode, parentNode);
     }
@@ -41,12 +38,12 @@ var vNode;
     }
     vNode.InitAll = InitAll;
     function Destroy(vnode) {
-        if ((0, vNode_types_1.isStringNode)(vnode) || vnode.destroyed)
+        if (isStringNode(vnode) || vnode.destroyed)
             return;
         vnode.destroyed = true;
         vnode.component?.Destroy();
-        Store_1.ObservableScope.DestroyAll(vnode.scopes);
-        vnode.onDestroyed && emitter_1.Emitter.Emit(vnode.onDestroyed);
+        ObservableScope.DestroyAll(vnode.scopes);
+        vnode.onDestroyed && Emitter.Emit(vnode.onDestroyed);
         vnode.children && DestroyAll(vnode.children);
     }
     vNode.Destroy = Destroy;
@@ -71,15 +68,15 @@ var vNode;
     }
     vNode.ToFunction = ToFunction;
     function Attach(node, vnode) {
-        if (vnode.type === vNode_types_1.FRAGMENT_NODE)
+        if (vnode.type === FRAGMENT_NODE)
             throw new Error("Cannot attach a fragment directly. A fragment has no DOM node — " +
                 "wrap it in a real element (e.g. div) before attaching.");
         Init(vnode);
-        nodeConfig_1.NodeConfig.addChild(node, vnode.node);
+        NodeConfig.addChild(node, vnode.node);
         return vnode;
     }
     vNode.Attach = Attach;
-})(vNode || (exports.vNode = vNode = {}));
+})(vNode || (vNode = {}));
 function ComponentChildren() {
     return this.Template();
 }
@@ -87,52 +84,52 @@ function InitNode(vnode, parentNode) {
     const { type, namespace, props, attrs, on, data, componentFactory, children, childrenArray, } = vnode.definition;
     let node = null;
     switch (vnode.type) {
-        case vNode_types_1.FRAGMENT_NODE:
+        case FRAGMENT_NODE:
             break;
-        case vNode_types_1.TEXT_NODE:
-            vnode.node = node = vnode.definition.node ?? nodeConfig_1.NodeConfig.createTextNode();
+        case TEXT_NODE:
+            vnode.node = node = vnode.definition.node ?? NodeConfig.createTextNode();
             break;
         default:
-            vnode.node = node = vnode.definition.node ?? nodeConfig_1.NodeConfig.createNode(type, namespace);
+            vnode.node = node = vnode.definition.node ?? NodeConfig.createNode(type, namespace);
             break;
     }
     vnode.definition = null;
     vnode.parentNode = parentNode;
     if (props) {
         if (typeof props === "function") {
-            const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
-            const scope = Store_1.ObservableScope.Create(props);
+            const assignProperties = NodeConfig.createPropertyAssignment(node);
+            const scope = ObservableScope.Create(props);
             vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
-            assignProperties(Store_1.ObservableScope.Value(scope));
+            ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
+            assignProperties(ObservableScope.Value(scope));
         }
         else
-            nodeConfig_1.NodeConfig.propertyAssignment(node, props);
+            NodeConfig.propertyAssignment(node, props);
     }
     if (on) {
         if (typeof on === "function") {
-            const assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
-            const scope = Store_1.ObservableScope.Create(on);
+            const assignEvents = NodeConfig.createEventAssignment(node);
+            const scope = ObservableScope.Create(on);
             vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
-            assignEvents(Store_1.ObservableScope.Value(scope));
+            ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
+            assignEvents(ObservableScope.Value(scope));
         }
         else
-            nodeConfig_1.NodeConfig.eventAssignment(node, on);
+            NodeConfig.eventAssignment(node, on);
     }
     if (attrs) {
         if (typeof attrs === "function") {
-            const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
-            const scope = Store_1.ObservableScope.Create(attrs);
+            const assignAttributes = NodeConfig.createAttributeAssignment(node);
+            const scope = ObservableScope.Create(attrs);
             vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
-            assignAttributes(Store_1.ObservableScope.Value(scope));
+            ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
+            assignAttributes(ObservableScope.Value(scope));
         }
         else
-            nodeConfig_1.NodeConfig.attributeAssignment(node, attrs);
+            NodeConfig.attributeAssignment(node, attrs);
     }
     if (componentFactory) {
-        vnode.component = injector_1.Injector.Scope(vnode.injector, componentFactory, vnode);
+        vnode.component = Injector.Scope(vnode.injector, componentFactory, vnode);
         vnode.component.Bound();
         Children(vnode, ComponentChildren.bind(vnode.component));
     }
@@ -148,38 +145,38 @@ function InitNode(vnode, parentNode) {
 function Children(vnode, children, data) {
     const childrenScope = CreateChildrenScope(vnode, children, data);
     vnode.scopes.push(childrenScope);
-    Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
+    ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
         if (vnode.destroyed)
             return;
         const oldChildrenLength = vnode.children.length;
-        vnode.children = Store_1.ObservableScope.Value(scope);
+        vnode.children = ObservableScope.Value(scope);
         if (oldChildrenLength !== 0 || vnode.children.length !== 0)
             UpdateChildren(vnode);
     }));
-    vnode.children = Store_1.ObservableScope.Value(childrenScope);
+    vnode.children = ObservableScope.Value(childrenScope);
 }
 function CreateChildrenScope(vnode, children, data) {
     if (data === undefined) {
-        const scope = Store_1.ObservableScope.Create(GetNextNodesAsArray.bind(null, vnode.injector, children));
-        Store_1.ObservableScope.OnUpdated(scope, DestroyScopedVNodes);
-        Store_1.ObservableScope.OnDestroyed(scope, DestroyScopedVNodes);
+        const scope = ObservableScope.Create(GetNextNodesAsArray.bind(null, vnode.injector, children));
+        ObservableScope.OnUpdated(scope, DestroyScopedVNodes);
+        ObservableScope.OnDestroyed(scope, DestroyScopedVNodes);
         return scope;
     }
-    if ((0, functions_1.IsAsync)(data)) {
+    if (IsAsync(data)) {
         const asyncData = data;
         data = function () {
-            return (0, observableScope_1.InlineScope)(async function () {
+            return InlineScope(async function () {
                 return asyncData();
             });
         };
     }
-    return Store_1.ObservableScope.Create(DynamicChildrenFunction.bind(null, vnode.injector, children, data));
+    return ObservableScope.Create(DynamicChildrenFunction.bind(null, vnode.injector, children, data));
 }
 function ToVNodeType(children) {
-    return typeof children === "string" ? { type: vNode_types_1.STRING_NODE, node: children } : children;
+    return typeof children === "string" ? { type: STRING_NODE, node: children } : children;
 }
 function GetNextNodes(injector, children, data) {
-    return ToVNodeType(injector_1.Injector.Scope(injector, children, data));
+    return ToVNodeType(Injector.Scope(injector, children, data));
 }
 function GetNextNodesAsArray(injector, children, data) {
     const nodes = GetNextNodes(injector, children, data);
@@ -193,7 +190,7 @@ function DynamicChildrenFunction(injector, children, data) {
     const getNextNodes = GetNextNodes.bind(null, injector, children);
     let results = new Array(nextData.length);
     for (let x = 0; x < nextData.length; x++) {
-        const nodes = (0, observableScope_1.MappedScope)(nextData[x], getNextNodes, DestroyScopedVNodes, DestroyScopedVNodes);
+        const nodes = MappedScope(nextData[x], getNextNodes, DestroyScopedVNodes, DestroyScopedVNodes);
         results[x] = nodes;
     }
     return results.flat();
@@ -207,7 +204,7 @@ function ToArray(result) {
 }
 function MapNode(vnode) {
     switch (vnode.type) {
-        case vNode_types_1.FRAGMENT_NODE:
+        case FRAGMENT_NODE:
             return vnode.children.flatMap(MapNode);
         default:
             return vnode.node;
@@ -215,47 +212,47 @@ function MapNode(vnode) {
 }
 function CleanupChildrenArray(children) {
     const nodes = children.flatMap(MapNode);
-    (0, array_1.RemoveNulls)(nodes);
+    RemoveNulls(nodes);
     return nodes;
 }
 function UpdateChildren(vnode, init = false, skipInit = false) {
     if (!vnode.children)
         return;
     const children = vnode.children;
-    (0, thread_1.Thread)(function () {
+    Thread(function () {
         if (vnode.destroyed || children !== vnode.children)
             return;
         for (let x = 0; !skipInit && x < children.length; x++) {
             const childNode = children[x];
-            if (!(0, vNode_types_1.isStringNode)(childNode) && childNode.definition) {
-                (0, thread_1.Schedule)(function () {
+            if (!isStringNode(childNode) && childNode.definition) {
+                Schedule(function () {
                     if (vnode.destroyed || children !== vnode.children)
                         return;
                     vNode.Init(childNode, vnode);
                 });
             }
         }
-        (0, thread_1.Thread)(function (async) {
+        Thread(function (async) {
             if (vnode.destroyed || children !== vnode.children)
                 return;
             if (init) {
                 if (vnode.node !== null)
-                    nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, CleanupChildrenArray(vnode.children));
+                    NodeConfig.reconcileChildren(vnode.node, CleanupChildrenArray(vnode.children));
             }
             else if (!async) {
                 let reconcileNode = vnode;
                 while (reconcileNode.node === null)
                     reconcileNode = reconcileNode.parentNode;
-                nodeConfig_1.NodeConfig.reconcileChildren(reconcileNode.node, CleanupChildrenArray(reconcileNode.children));
+                NodeConfig.reconcileChildren(reconcileNode.node, CleanupChildrenArray(reconcileNode.children));
             }
             else {
-                nodeConfig_1.NodeConfig.scheduleUpdate(function () {
+                NodeConfig.scheduleUpdate(function () {
                     if (vnode.destroyed || children !== vnode.children)
                         return;
                     let reconcileNode = vnode;
                     while (reconcileNode.node === null)
                         reconcileNode = reconcileNode.parentNode;
-                    nodeConfig_1.NodeConfig.reconcileChildren(reconcileNode.node, CleanupChildrenArray(reconcileNode.children));
+                    NodeConfig.reconcileChildren(reconcileNode.node, CleanupChildrenArray(reconcileNode.children));
                 });
             }
         });
@@ -267,9 +264,9 @@ function ScheduledAssignment(assign) {
         if (scheduled)
             return;
         scheduled = true;
-        nodeConfig_1.NodeConfig.scheduleUpdate(function () {
+        NodeConfig.scheduleUpdate(function () {
             scheduled = false;
-            const value = Store_1.ObservableScope.Peek(scope);
+            const value = ObservableScope.Peek(scope);
             assign(value);
         });
     };
@@ -280,7 +277,7 @@ function CreateScheduledCallback(callback) {
         if (scheduled)
             return;
         scheduled = true;
-        nodeConfig_1.NodeConfig.scheduleUpdate(function () {
+        NodeConfig.scheduleUpdate(function () {
             scheduled = false;
             callback(...args);
         });

package/Node/vNode.types.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FRAGMENT_NODE = exports.TEXT_NODE = exports.STRING_NODE = void 0;
-exports.isStringNode = isStringNode;
-exports.STRING_NODE = Symbol("STRING_NODE");
-exports.TEXT_NODE = Symbol("TEXT_NODE");
-exports.FRAGMENT_NODE = Symbol("FRAGMENT_NODE");
-function isStringNode(vnode) {
-    return vnode.type === exports.STRING_NODE;
+export const STRING_NODE = Symbol("STRING_NODE");
+export const TEXT_NODE = Symbol("TEXT_NODE");
+export const FRAGMENT_NODE = Symbol("FRAGMENT_NODE");
+export function isStringNode(vnode) {
+    return vnode.type === STRING_NODE;
 }

package/Store/Diff/defaultDiffTreeWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/Store/Diff/defaultDiffTreeWorker.js

@@ -0,0 +1,4 @@
+import { DiffTree } from "./diffTree";
+import { ConnectWorkerToDiffTree } from "./diffTreeWorker";
+const diffTree = new DiffTree();
+ConnectWorkerToDiffTree(diffTree, self);

package/Store/Diff/diffAsync.d.ts

@@ -1,4 +1,4 @@
-import { DiffSpliceResult, DiffTreeProjectionMap, IDiffTree } from "./diffTree";
+import { DiffSpliceResult, IDiffTree } from "./diffTree";
 import { JsonDiffResult } from "../../Utils/json";
 /**
  * Async version of IDiffTree interface with all methods returning promises.
@@ -22,9 +22,7 @@ export declare class DiffAsync implements IDiffTreeAsync {
      *   projection's function is serialized with `.toString()` and `eval`'d back into a
      *   function in the worker, the same mechanic used for `keyFunc`.
      */
-    constructor(keyFunc?: {
-        (val: any): string;
-    }, projections?: DiffTreeProjectionMap);
+    constructor(diffWorker: Worker);
     /**
      * Computes the diff between a new value and the current value at a path asynchronously.
      * @param path - Dot-separated path to the value

package/Store/Diff/diffAsync.js

@@ -1,25 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffAsync = void 0;
-const workerQueue_1 = require("./workerQueue");
-const diffWorker_1 = require("./diffWorker");
-/**
- * Serializes a `DiffTreeProjectionMap` for the worker boundary: `reads` survives structured
- * clone as-is, and each `projection` function is serialized with `.toString()`, the same
- * mechanic used below for `keyFunc`.
- */
-function SerializeProjections(projections) {
-    const serialized = {};
-    const ids = Object.keys(projections);
-    for (let x = 0; x < ids.length; x++) {
-        const id = ids[x];
-        serialized[id] = {
-            reads: projections[id].reads,
-            projection: projections[id].projection.toString(),
-        };
-    }
-    return serialized;
-}
+import { WorkerQueue } from "./workerQueue";
 /**
  * Asynchronous diff implementation using web workers.
  * Offloads diff computation to a worker to prevent blocking the main thread.
@@ -27,7 +6,7 @@ function SerializeProjections(projections) {
  * @see StoreAsync
  * @see DiffSync
  */
-class DiffAsync {
+export class DiffAsync {
     /**
      * Creates a DiffAsync instance and initializes the worker.
      * @param keyFunc - Optional function to extract a key from objects
@@ -35,15 +14,8 @@ class DiffAsync {
      *   projection's function is serialized with `.toString()` and `eval`'d back into a
      *   function in the worker, the same mechanic used for `keyFunc`.
      */
-    constructor(keyFunc, projections) {
-        this.workerQueue = new workerQueue_1.WorkerQueue(diffWorker_1.DiffWorker.Create());
-        this.workerQueue.Push({
-            method: "create",
-            arguments: [
-                keyFunc ? keyFunc.toString() : undefined,
-                projections ? SerializeProjections(projections) : undefined,
-            ],
-        });
+    constructor(diffWorker) {
+        this.workerQueue = new WorkerQueue(diffWorker);
     }
     /**
      * Computes the diff between a new value and the current value at a path asynchronously.
@@ -81,4 +53,3 @@ class DiffAsync {
         this.workerQueue.Destroy();
     }
 }
-exports.DiffAsync = DiffAsync;

package/Store/Diff/diffSync.js

@@ -1,10 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffSync = void 0;
-const array_1 = require("../../Utils/array");
-const json_1 = require("../../Utils/json");
-const diffTree_1 = require("./diffTree");
-const diffCnstr = (0, diffTree_1.DiffTreeFactory)(json_1.JsonDiffFactory, array_1.ArraysEqual);
+import { DiffTree } from "./diffTree";
 /**
  * Synchronous diff implementation.
  * Computes diffs immediately without queuing or workers.
@@ -12,14 +6,14 @@ const diffCnstr = (0, diffTree_1.DiffTreeFactory)(json_1.JsonDiffFactory, array_
  * @see StoreSync
  * @see DiffAsync
  */
-class DiffSync {
+export class DiffSync {
     /**
      * Creates a DiffSync instance.
      * @param keyFunc - Optional function to extract a key from objects
      * @param projections - Optional map of derived-value projections, keyed by id
      */
     constructor(keyFunc, projections) {
-        this.diffTree = new diffCnstr(keyFunc, projections);
+        this.diffTree = new DiffTree(keyFunc, projections);
     }
     /**
      * Computes the diff between a new value and the current value at a path.
@@ -42,4 +36,3 @@ class DiffSync {
         return this.diffTree.SplicePath(path, start, deleteCount, items, flatten);
     }
 }
-exports.DiffSync = DiffSync;

package/Store/Diff/diffTree.d.ts

@@ -1,12 +1,38 @@
-import { JsonDiffFactoryResult, JsonDiffResult } from "../../Utils/json";
+import { type JsonDiffResult } from "../../Utils/json";
 /**
- * Represents a method call for worker-based diff operations.
+ * Interface for diff tree operations.
  */
-export interface IDiffMethod {
-    /** The method to call */
-    method: "create" | "diffpath" | "splicepath" | "diffbatch" | "updatepath" | "getpath";
-    /** Arguments for the method call */
-    arguments: Array<any>;
+export interface IDiffTree {
+    /**
+     * Computes diffs for a batch of path/value pairs.
+     * @param data - Array of objects with path and value properties
+     * @returns Combined diff results
+     */
+    DiffBatch(data: Array<{
+        path: string;
+        value: any;
+    }>): JsonDiffResult;
+    /**
+     * Computes the diff between a new value and the current value at a path.
+     * @param path - Dot-separated path to the value
+     * @param value - The new value to compare
+     * @returns Diff results showing changes
+     */
+    DiffPath(path: string, value: any, flatten?: boolean): JsonDiffResult;
+    SplicePath(path: string, start: number, deleteCount: number | undefined, items: any[], flatten?: boolean): DiffSpliceResult;
+}
+/**
+ * Constructor interface for IDiffTree.
+ */
+export interface IDiffTreeConstructor {
+    /**
+     * Creates a new IDiffTree instance.
+     * @param keyFunc - Optional function to extract a key from a value
+     * @param projections - Optional map of derived-value projections, keyed by id
+     */
+    new (keyFunc?: {
+        (val: any): string;
+    }, projections?: DiffTreeProjectionMap): IDiffTree;
 }
 /**
  * A pure function computing a derived value from the current values at `reads`, passed
@@ -29,17 +55,6 @@ export type DiffTreeProjectionDefinition = {
 export type DiffTreeProjectionMap = {
     [id: string]: DiffTreeProjectionDefinition;
 };
-/**
- * The wire form of a `DiffTreeProjectionMap` sent to the diff worker: `reads` survives
- * structured clone as-is, and `projection` is serialized with `.toString()`, the same
- * mechanic `DiffAsync` already uses to send `keyFunc` across the worker boundary.
- */
-export type DiffTreeSerializedProjectionMap = {
-    [id: string]: {
-        reads: string[];
-        projection: string;
-    };
-};
 /** Reserved key prefix a projection's result is stored under: `$projection_<id>`. */
 export declare const PROJECTION_PREFIX = "$projection_";
 export type DiffSpliceResult<T = unknown> = {
@@ -52,9 +67,25 @@ export type DiffSpliceResult<T = unknown> = {
     diffResult: JsonDiffResult;
 };
 /**
- * Interface for diff tree operations.
+ * Internal diff tree implementation.
+ * Maintains root state and computes diffs for path/value updates.
+ * @private
  */
-export interface IDiffTree {
+export declare class DiffTree {
+    private keyFunc?;
+    private rootState;
+    private projectionOrder;
+    private projectionMemo;
+    /**
+     * Creates a DiffTree instance.
+     * @param keyFunc - Optional function to extract a key from objects
+     * @param projections - Optional map of derived-value projections, keyed by id. Cycles
+     *   and reads of an unregistered projection id are rejected here, at construction.
+     */
+    constructor(keyFunc?: {
+        (val: any): string;
+    }, projections?: DiffTreeProjectionMap);
+    private RunProjections;
     /**
      * Computes diffs for a batch of path/value pairs.
      * @param data - Array of objects with path and value properties
@@ -63,7 +94,10 @@ export interface IDiffTree {
     DiffBatch(data: Array<{
         path: string;
         value: any;
-    }>): JsonDiffResult;
+    }>): {
+        path: (string | number)[];
+        value: unknown;
+    }[];
     /**
      * Computes the diff between a new value and the current value at a path.
      * @param path - Dot-separated path to the value
@@ -71,26 +105,17 @@ export interface IDiffTree {
      * @returns Diff results showing changes
      */
     DiffPath(path: string, value: any, flatten?: boolean): JsonDiffResult;
-    SplicePath(path: string, start: number, deleteCount: number | undefined, items: any[], flatten?: boolean): DiffSpliceResult;
-}
-/**
- * Constructor interface for IDiffTree.
- */
-export interface IDiffTreeConstructor {
+    SplicePath(path: string, start: number, deleteCount: number, items: any[], flatten?: boolean): DiffSpliceResult<unknown>;
     /**
-     * Creates a new IDiffTree instance.
-     * @param keyFunc - Optional function to extract a key from a value
-     * @param projections - Optional map of derived-value projections, keyed by id
+     * Retrieves the current value at a path.
+     * @param path - Dot-separated path to the value
+     * @returns The value at the specified path
      */
-    new (keyFunc?: {
-        (val: any): string;
-    }, projections?: DiffTreeProjectionMap): IDiffTree;
+    GetPath(path: string): any;
+    /**
+     * Returns an immutable, cached snapshot of the value at a path (empty string for the
+     * whole tree). Not part of `IDiffTree`; internal, for a future feature.
+     * @param path - Dot-separated path to the value
+     */
+    Snapshot(path: string): any;
 }
-/**
- * Factory function that creates a DiffTree class.
- * Can operate in worker mode for async operations.
- * @param jsonDiffFactory - Optional factory for JSON diff utilities
- * @param worker - If true, sets up worker message handling
- * @returns DiffTree constructor
- */
-export declare function DiffTreeFactory(jsonDiffFactory: () => JsonDiffFactoryResult, arraysEqual: (left: any[], right: any[]) => boolean, worker?: boolean): IDiffTreeConstructor;