j-templates 8.0.13 → 8.0.15

package/Store/Diff/diffTreeWorker.d.ts

@@ -0,0 +1,8 @@
+import { DiffTree } from "./diffTree";
+export interface IDiffMethod {
+    /** The method to call */
+    method: "create" | "diffpath" | "splicepath" | "diffbatch" | "updatepath" | "getpath";
+    /** Arguments for the method call */
+    arguments: Array<any>;
+}
+export declare function ConnectWorkerToDiffTree(diffTree: DiffTree, worker: Worker): void;

package/Store/Diff/diffTreeWorker.js

@@ -0,0 +1,27 @@
+export function ConnectWorkerToDiffTree(diffTree, worker) {
+    worker.onmessage = function (event) {
+        const data = event.data;
+        switch (data.method) {
+            case "diffpath": {
+                const diff = diffTree.DiffPath(data.arguments[0], data.arguments[1], data.arguments[2]);
+                worker.postMessage(diff);
+                break;
+            }
+            case "splicepath": {
+                const diff = diffTree.SplicePath(data.arguments[0], data.arguments[1], data.arguments[2], data.arguments[3], data.arguments[4]);
+                worker.postMessage(diff);
+                break;
+            }
+            case "diffbatch": {
+                const diff = diffTree.DiffBatch(data.arguments[0]);
+                worker.postMessage(diff);
+                break;
+            }
+            case "getpath": {
+                const ret = diffTree.GetPath(data.arguments[0]);
+                worker.postMessage(ret);
+                break;
+            }
+        }
+    };
+}

package/Store/Diff/workerQueue.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerQueue = void 0;
-const list_1 = require("../../Utils/list");
-class WorkerQueue {
+import { List } from "../../Utils/list";
+export class WorkerQueue {
     constructor(worker) {
         this.worker = worker;
-        this.callbacks = list_1.List.Create();
+        this.callbacks = List.Create();
         this.worker.onerror = (err) => {
-            const cb = list_1.List.Pop(this.callbacks);
+            const cb = List.Pop(this.callbacks);
             cb && cb(null, err);
         };
         this.worker.onmessage = (message) => {
-            const cb = list_1.List.Pop(this.callbacks);
+            const cb = List.Pop(this.callbacks);
             cb && cb(message.data);
         };
     }
     Push(message) {
         return new Promise((resolve, reject) => {
-            list_1.List.Add(this.callbacks, function (data, err) {
+            List.Add(this.callbacks, function (data, err) {
                 if (err)
                     reject(err);
                 else
@@ -30,4 +27,3 @@ class WorkerQueue {
         this.worker.terminate();
     }
 }
-exports.WorkerQueue = WorkerQueue;

package/Store/Store/store.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Store = void 0;
-const json_1 = require("../../Utils/json");
-const observableNode_1 = require("../Tree/observableNode");
+import { JsonDeepClone } from "../../Utils/json";
+import { ObservableNode } from "../Tree/observableNode";
 /**
  * Base class for observable data store management.
  * Stores root objects as ObservableNode instances and manages updates through diff operations.
@@ -10,7 +7,7 @@ const observableNode_1 = require("../Tree/observableNode");
  * @see StoreSync
  * @see StoreAsync
  */
-class Store {
+export class Store {
     /**
      * Creates an instance of Store.
      * @param keyFunc Optional function to generate a key for a given data value.
@@ -28,14 +25,14 @@ class Store {
                 const rootObject = this.rootMap.get(key);
                 if (rootObject === undefined)
                     throw `No root object found for key: ${key}`;
-                const rootValue = observableNode_1.ObservableNode.Unwrap(rootObject); // rootObject[GET_OBSERVABLE_VALUE];
-                reactive && observableNode_1.ObservableNode.Touch(rootValue, key);
+                const rootValue = ObservableNode.Unwrap(rootObject); // rootObject[GET_OBSERVABLE_VALUE];
+                reactive && ObservableNode.Touch(rootValue, key);
                 const alias = rootValue[key];
                 return alias;
             });
         this.createNode = aliasFunc
-            ? observableNode_1.ObservableNode.CreateFactory(aliasFunc)
-            : observableNode_1.ObservableNode.Create;
+            ? ObservableNode.CreateFactory(aliasFunc)
+            : ObservableNode.Create;
     }
     Get(id, defaultValue) {
         let result = this.rootMap.get(id);
@@ -65,7 +62,7 @@ class Store {
     }
     SpliceRootObject(rootPath, start, deleteCount, items) {
         const rootObject = this.rootMap.get(rootPath);
-        observableNode_1.ObservableNode.ApplySplice(rootObject[rootPath], start, deleteCount, items, this.cloneData);
+        ObservableNode.ApplySplice(rootObject[rootPath], start, deleteCount, items, this.cloneData);
     }
     /**
      * Updates a specific root object with diff results.
@@ -80,12 +77,11 @@ class Store {
         if (rootObject === undefined) {
             if (results.length > 1 || results[0].path.length > 1)
                 throw `Unable to initialize root path ${rootPath} with ${results.length} results and initial path ${results[0].path}`;
-            const rootData = this.cloneData ? (0, json_1.JsonDeepClone)(results[0].value) : results[0].value;
+            const rootData = this.cloneData ? JsonDeepClone(results[0].value) : results[0].value;
             const newRootObject = this.createNode({ [rootPath]: rootData });
             this.rootMap.set(rootPath, newRootObject);
             return;
         }
-        observableNode_1.ObservableNode.ApplyDiff(rootObject, results);
+        ObservableNode.ApplyDiff(rootObject, results);
     }
 }
-exports.Store = Store;

package/Store/Store/storeAsync.d.ts

@@ -1,4 +1,3 @@
-import { DiffTreeProjectionMap } from "../Diff/diffTree";
 import { Store } from "./store";
 /**
  * StoreAsync class extends the base Store class to provide asynchronous data management operations.
@@ -52,7 +51,7 @@ export declare class StoreAsync extends Store {
      * worker, the same mechanic used for `keyFunc`, so it must not close over state that
      * doesn't survive that round trip.
      */
-    constructor(keyFunc?: (value: any) => string | undefined, projections?: DiffTreeProjectionMap);
+    constructor(diffWorker: Worker, keyFunc?: (value: any) => string | undefined);
     /**
      * Returns a promise that resolve once all current queued writes have completed
      */

package/Store/Store/storeAsync.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreAsync = void 0;
-const asyncQueue_1 = require("../../Utils/asyncQueue");
-const json_1 = require("../../Utils/json");
-const diffAsync_1 = require("../Diff/diffAsync");
-const store_1 = require("./store");
+import { AsyncQueue } from "../../Utils/asyncQueue";
+import { JsonDeepClone, JsonMerge } from "../../Utils/json";
+import { DiffAsync } from "../Diff/diffAsync";
+import { Store } from "./store";
 /**
  * StoreAsync class extends the base Store class to provide asynchronous data management operations.
  * This class handles writing, patching, pushing, and splicing data in an asynchronous manner.
@@ -37,7 +34,7 @@ const store_1 = require("./store");
  * @see StoreSync
  * @see DiffAsync
  */
-class StoreAsync extends store_1.Store {
+export class StoreAsync extends Store {
     /**
      * Creates an instance of StoreAsync.
      * @param keyFunc Optional function to generate a key for a given data value.
@@ -47,14 +44,14 @@ class StoreAsync extends store_1.Store {
      * worker, the same mechanic used for `keyFunc`, so it must not close over state that
      * doesn't survive that round trip.
      */
-    constructor(keyFunc, projections) {
+    constructor(diffWorker, keyFunc) {
         super(keyFunc, false);
         /**
          * The async queue instance used to manage asynchronous operations in a non-blocking manner.
          * @private
          */
-        this.queue = new asyncQueue_1.AsyncQueue();
-        this.diff = new diffAsync_1.DiffAsync(keyFunc, projections);
+        this.queue = new AsyncQueue();
+        this.diff = new DiffAsync(diffWorker);
     }
     /**
      * Returns a promise that resolve once all current queued writes have completed
@@ -93,7 +90,7 @@ class StoreAsync extends store_1.Store {
             if (value === undefined)
                 throw "Unable to patch undefined value";
             const json = value.toJSON();
-            const mergedJson = (0, json_1.JsonMerge)(json, patch);
+            const mergedJson = JsonMerge(json, patch);
             const diffResult = await this.diff.DiffPath(key, mergedJson, false);
             this.UpdateRootMap(diffResult);
         });
@@ -130,7 +127,7 @@ class StoreAsync extends store_1.Store {
      * @returns The array of deleted elements.
      */
     async Splice(key, start, deleteCount, ...items) {
-        items = (0, json_1.JsonDeepClone)(items);
+        items = JsonDeepClone(items);
         return await this.queue.Next(async () => {
             if (!this.Has(key))
                 throw "Key not found in store";
@@ -149,4 +146,3 @@ class StoreAsync extends store_1.Store {
         this.diff.Destroy();
     }
 }
-exports.StoreAsync = StoreAsync;

package/Store/Store/storeSync.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreSync = void 0;
-const json_1 = require("../../Utils/json");
-const diffSync_1 = require("../Diff/diffSync");
-const observableNode_1 = require("../Tree/observableNode");
-const store_1 = require("./store");
+import { JsonMerge, JsonDeepClone } from "../../Utils/json";
+import { DiffSync } from "../Diff/diffSync";
+import { ObservableNode } from "../Tree/observableNode";
+import { Store } from "./store";
 /**
  * StoreSync class extends the base Store class to provide synchronous data management operations.
  * This class handles writing, patching, pushing, and splicing data in a synchronous manner.
@@ -33,7 +30,7 @@ const store_1 = require("./store");
  * @see StoreAsync
  * @see DiffSync
  */
-class StoreSync extends store_1.Store {
+export class StoreSync extends Store {
     /**
      * Creates an instance of StoreSync.
      * @param keyFunc Optional function to generate a key for a given data value.
@@ -42,7 +39,7 @@ class StoreSync extends store_1.Store {
      */
     constructor(keyFunc, projections) {
         super(keyFunc);
-        this.diff = new diffSync_1.DiffSync(keyFunc, projections);
+        this.diff = new DiffSync(keyFunc, projections);
     }
     /**
      * Writes data to the store synchronously.
@@ -54,7 +51,7 @@ class StoreSync extends store_1.Store {
         key = key || this.keyFunc?.(data);
         if (!key)
             throw "No key provided for data";
-        data = observableNode_1.ObservableNode.Unwrap(data);
+        data = ObservableNode.Unwrap(data);
         const diffResult = this.diff.DiffPath(key, data);
         this.UpdateRootMap(diffResult);
     }
@@ -70,8 +67,8 @@ class StoreSync extends store_1.Store {
         const value = this.Get(key);
         if (value === undefined)
             throw "Unable to patch undefined value";
-        const json = observableNode_1.ObservableNode.Unwrap(value);
-        const mergedJson = (0, json_1.JsonMerge)(json, patch);
+        const json = ObservableNode.Unwrap(value);
+        const mergedJson = JsonMerge(json, patch);
         const diffResult = this.diff.DiffPath(key, mergedJson, false);
         this.UpdateRootMap(diffResult);
     }
@@ -108,7 +105,6 @@ class StoreSync extends store_1.Store {
         const spliceResult = this.diff.SplicePath(key, start, deleteCount, items);
         this.UpdateRootMap(spliceResult.diffResult);
         this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, items);
-        return (0, json_1.JsonDeepClone)(spliceResult.spliceResult);
+        return JsonDeepClone(spliceResult.spliceResult);
     }
 }
-exports.StoreSync = StoreSync;

package/Store/Tree/observableNode.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableNode = void 0;
-const json_1 = require("../../Utils/json");
-const json_2 = require("../../Utils/json");
-const observableScope_1 = require("./observableScope");
+import { JsonDeepClone, JsonDiff } from "../../Utils/json";
+import { JsonType } from "../../Utils/json";
+import { ObservableScope } from "./observableScope";
 const NODE_VALUE = Symbol("NODE_VALUE");
 const NODE_PROXY = Symbol("NODE_PROXY");
 const NODE_SNAPSHOT = Symbol("NODE_SNAPSHOT");
@@ -51,22 +48,22 @@ function getOwnPropertyDescriptorArray(target, prop) {
     };
 }
 function has(value, prop) {
-    observableScope_1.ObservableScope.Touch(value[ITERATOR_SCOPE]);
+    ObservableScope.Touch(value[ITERATOR_SCOPE]);
     return Object.hasOwn(value[NODE_VALUE], prop);
 }
 function hasArray(value, prop) {
-    observableScope_1.ObservableScope.Touch(value[ITERATOR_SCOPE]);
+    ObservableScope.Touch(value[ITERATOR_SCOPE]);
     return Object.hasOwn(value[NODE_VALUE], prop);
 }
 function ownKeys(value) {
-    observableScope_1.ObservableScope.Touch(value[ITERATOR_SCOPE]);
+    ObservableScope.Touch(value[ITERATOR_SCOPE]);
     return Object.keys(value[NODE_VALUE]);
 }
 function ownKeysArray(value) {
-    observableScope_1.ObservableScope.Touch(value[ITERATOR_SCOPE]);
+    ObservableScope.Touch(value[ITERATOR_SCOPE]);
     return Object.keys(value[NODE_VALUE]);
 }
-function UnwrapProxy(value, type = (0, json_2.JsonType)(value)) {
+function UnwrapProxy(value, type = JsonType(value)) {
     if (type === "value")
         return value;
     if (value[IS_NODE]) {
@@ -88,11 +85,11 @@ function UnwrapProxy(value, type = (0, json_2.JsonType)(value)) {
     }
     return value;
 }
-function CloneProxy(value, type = (0, json_2.JsonType)(value)) {
+function CloneProxy(value, type = JsonType(value)) {
     if (type === "value")
         return value;
     if (value[IS_NODE]) {
-        return (0, json_1.JsonDeepClone)(value);
+        return JsonDeepClone(value);
     }
     switch (type) {
         case "object": {
@@ -110,19 +107,19 @@ function CloneProxy(value, type = (0, json_2.JsonType)(value)) {
     return value;
 }
 function GetPropertyScope(object, prop) {
-    return object[prop] ??= observableScope_1.ObservableScope.Basic(Property.bind(null, object[NODE_VALUE], prop));
+    return object[prop] ??= ObservableScope.Basic(Property.bind(null, object[NODE_VALUE], prop));
 }
 function SetObjectValue(object, prop, value) {
     const propExists = Object.hasOwn(object[NODE_VALUE], prop);
     object[NODE_VALUE][prop] = value;
     InvalidateSnapshotForValue(object[NODE_VALUE]);
-    observableScope_1.ObservableScope.Update(object[prop]);
-    !propExists && observableScope_1.ObservableScope.Update(object[ITERATOR_SCOPE]);
+    ObservableScope.Update(object[prop]);
+    !propExists && ObservableScope.Update(object[ITERATOR_SCOPE]);
 }
 function SetArrayValue(object, prop, value) {
     object[NODE_VALUE][prop] = value;
     InvalidateSnapshotForValue(object[NODE_VALUE]);
-    observableScope_1.ObservableScope.Update(object[OBJECT_SCOPE]);
+    ObservableScope.Update(object[OBJECT_SCOPE]);
 }
 function CreateProxyFactory(alias) {
     /**
@@ -135,7 +132,7 @@ function CreateProxyFactory(alias) {
      * shared between snapshots. Keyed children are read through their root.
      */
     function CreateSnapshot(value) {
-        if ((0, json_2.JsonType)(value) === "value")
+        if (JsonType(value) === "value")
             return value;
         const cached = valueSnapshotCache.get(value);
         if (cached !== undefined)
@@ -162,7 +159,7 @@ function CreateProxyFactory(alias) {
      * (one that changes which entity a slot holds) mutates that copy in place.
      */
     function ChildSnapshot(parent, child) {
-        if ((0, json_2.JsonType)(child) === "value")
+        if (JsonType(child) === "value")
             return child;
         CreateSnapshotLink(child, parent);
         const resolved = alias?.(child, false);
@@ -177,7 +174,7 @@ function CreateProxyFactory(alias) {
         const wrapper = Object.assign([], {
             [NODE_VALUE]: value,
             [NODE_PROXY]: null,
-            [OBJECT_SCOPE]: observableScope_1.ObservableScope.Basic(Identity.bind(null, value))
+            [OBJECT_SCOPE]: ObservableScope.Basic(Identity.bind(null, value))
         });
         const proxy = wrapper[NODE_PROXY] = new Proxy(wrapper, {
             get: ArrayProxyGetter,
@@ -221,7 +218,7 @@ function CreateProxyFactory(alias) {
                 return CreateSnapshot(object[NODE_VALUE]);
             default: {
                 const scope = object[OBJECT_SCOPE];
-                const array = observableScope_1.ObservableScope.Value(scope);
+                const array = ObservableScope.Value(scope);
                 const arrayValue = array[prop];
                 if (typeof prop === "symbol")
                     return arrayValue;
@@ -243,7 +240,7 @@ function CreateProxyFactory(alias) {
                                 for (let x = 0; x < proxyArray.length; x++)
                                     array[x] = UnwrapProxy(proxyArray[x]);
                                 InvalidateSnapshotForValue(object[NODE_VALUE]);
-                                observableScope_1.ObservableScope.Update(scope);
+                                ObservableScope.Update(scope);
                                 break;
                         }
                         return result;
@@ -257,7 +254,7 @@ function CreateProxyFactory(alias) {
         const wrapper = {
             [NODE_VALUE]: value,
             [NODE_PROXY]: null,
-            [ITERATOR_SCOPE]: observableScope_1.ObservableScope.Basic(Identity.bind(null, value))
+            [ITERATOR_SCOPE]: ObservableScope.Basic(Identity.bind(null, value))
         };
         const proxy = wrapper[NODE_PROXY] = new Proxy(wrapper, {
             get: ObjectProxyGetter,
@@ -277,7 +274,7 @@ function CreateProxyFactory(alias) {
         return true;
     }
     function ObjectProxyGetter(object, prop) {
-        observableScope_1.ObservableScope.Touch(object[OBJECT_SCOPE]);
+        ObservableScope.Touch(object[OBJECT_SCOPE]);
         switch (prop) {
             case IS_NODE:
                 return true;
@@ -296,11 +293,11 @@ function CreateProxyFactory(alias) {
     }
     function GetAccessorValue(object, prop) {
         const scope = GetPropertyScope(object, prop);
-        const value = observableScope_1.ObservableScope.Value(scope);
+        const value = ObservableScope.Value(scope);
         return CreateProxyFromValue(value);
     }
     function CreateProxyFromValue(value) {
-        const type = (0, json_2.JsonType)(value);
+        const type = JsonType(value);
         switch (type) {
             case "object": {
                 const wrapper = wrapperCache.get(value);
@@ -317,7 +314,7 @@ function CreateProxyFactory(alias) {
             case "array": {
                 const wrapper = wrapperCache.get(value);
                 const proxy = wrapper?.[NODE_PROXY] ?? CreateArrayProxy(value);
-                observableScope_1.ObservableScope.Touch(wrapper?.[OBJECT_SCOPE]);
+                ObservableScope.Touch(wrapper?.[OBJECT_SCOPE]);
                 return proxy;
             }
             default:
@@ -330,7 +327,7 @@ function CreateProxyFactory(alias) {
     };
 }
 const DefaultCreateProxy = CreateProxyFactory();
-var ObservableNode;
+export var ObservableNode;
 (function (ObservableNode) {
     /**
      * Unwraps an observable node to get the raw underlying value.
@@ -396,7 +393,7 @@ var ObservableNode;
         const wrapper = wrapperCache.get(value);
         if (wrapper) {
             const scope = Array.isArray(wrapper) ? wrapper[OBJECT_SCOPE] : (prop && wrapper[prop]) ?? wrapper[ITERATOR_SCOPE];
-            observableScope_1.ObservableScope.Update(scope);
+            ObservableScope.Update(scope);
         }
     }
     ObservableNode.Update = Update;
@@ -420,7 +417,7 @@ var ObservableNode;
         const wrapper = wrapperCache.get(value);
         if (wrapper) {
             const scope = prop && GetPropertyScope(wrapper, prop) || wrapper[OBJECT_SCOPE];
-            observableScope_1.ObservableScope.Touch(scope);
+            ObservableScope.Touch(scope);
         }
     }
     ObservableNode.Touch = Touch;
@@ -428,7 +425,7 @@ var ObservableNode;
         const wrapper = wrapperCache.get(value);
         if (wrapper) {
             const scope = Array.isArray(wrapper) ? wrapper[OBJECT_SCOPE] : (prop && wrapper[prop]) ?? wrapper[ITERATOR_SCOPE];
-            observableScope_1.ObservableScope.Update(scope);
+            ObservableScope.Update(scope);
         }
     }
     ObservableNode.Read = Read;
@@ -452,14 +449,14 @@ var ObservableNode;
      */
     function Apply(rootNode, value) {
         const root = rootNode[NODE_VALUE];
-        const diff = (0, json_1.JsonDiff)(value, root);
+        const diff = JsonDiff(value, root);
         ApplyDiff(rootNode, diff);
     }
     ObservableNode.Apply = Apply;
     function ApplySplice(rootNode, start, deleteCount, items, cloneData = true) {
         const root = rootNode[NODE_VALUE];
         InvalidateSnapshotForValue(rootNode[NODE_VALUE]);
-        const addItems = cloneData ? (0, json_1.JsonDeepClone)(items) : items;
+        const addItems = cloneData ? JsonDeepClone(items) : items;
         root.splice(start, deleteCount, ...addItems);
         ObservableNode.Update(root);
     }
@@ -475,9 +472,9 @@ var ObservableNode;
         if (diffResult.length === 1 && diffResult[0].path.length === 0) {
             // Replacing rootNode
             InvalidateSnapshotForValue(root);
-            const rootPatch = cloneData ? (0, json_1.JsonDeepClone)(diffResult[0].value) : diffResult[0].value;
-            const rootType = (0, json_2.JsonType)(root);
-            const rootPatchType = (0, json_2.JsonType)(rootPatch);
+            const rootPatch = cloneData ? JsonDeepClone(diffResult[0].value) : diffResult[0].value;
+            const rootType = JsonType(root);
+            const rootPatchType = JsonType(rootPatch);
             if (rootType !== rootPatchType)
                 throw new Error("Unable to change type of Root ObservableNode: " + rootType);
             switch (rootType) {
@@ -521,7 +518,7 @@ var ObservableNode;
                 }
             }
             const assignValue = pathTuples[y][1];
-            const assignData = cloneData ? (0, json_1.JsonDeepClone)(value) : value;
+            const assignData = cloneData ? JsonDeepClone(value) : value;
             ObservableNode.Assign(assignValue, path[y], assignData);
         }
     }
@@ -537,4 +534,4 @@ var ObservableNode;
         return CreateProxyFactory(alias);
     }
     ObservableNode.CreateFactory = CreateFactory;
-})(ObservableNode || (exports.ObservableNode = ObservableNode = {}));
+})(ObservableNode || (ObservableNode = {}));