j-templates 8.0.7 → 8.0.9

package/Store/Diff/diffAsync.d.ts

@@ -1,4 +1,4 @@
-import { IDiffTree } from "./diffTree";
+import { DiffSpliceResult, IDiffTree } from "./diffTree";
 import { JsonDiffResult } from "../../Utils/json";
 /**
  * Async version of IDiffTree interface with all methods returning promises.
@@ -38,6 +38,7 @@ export declare class DiffAsync implements IDiffTreeAsync {
         path: string;
         value: any;
     }>): Promise<JsonDiffResult>;
+    SplicePath(path: string, start: number, deleteCount: number, items: any[], flatten?: boolean): Promise<DiffSpliceResult<unknown>>;
     /**
      * Destroys the DiffAsync instance and terminates the worker.
      */

package/Store/Diff/diffAsync.js

@@ -45,6 +45,12 @@ class DiffAsync {
             arguments: [data],
         });
     }
+    async SplicePath(path, start, deleteCount, items, flatten) {
+        return await this.workerQueue.Push({
+            method: "splicepath",
+            arguments: [path, start, deleteCount, items, flatten]
+        });
+    }
     /**
      * Destroys the DiffAsync instance and terminates the worker.
      */

package/Store/Diff/diffSync.d.ts

@@ -1,4 +1,4 @@
-import { IDiffTree } from "./diffTree";
+import { DiffSpliceResult, IDiffTree } from "./diffTree";
 /**
  * Synchronous diff implementation.
  * Computes diffs immediately without queuing or workers.
@@ -31,4 +31,5 @@ export declare class DiffSync implements IDiffTree {
         path: string;
         value: any;
     }>): import("../../Utils/json").JsonDiffResult;
+    SplicePath(path: string, start: number, deleteCount: number | undefined, items: any[], flatten?: boolean): DiffSpliceResult;
 }

package/Store/Diff/diffSync.js

@@ -36,5 +36,8 @@ class DiffSync {
     DiffBatch(data) {
         return this.diffTree.DiffBatch(data);
     }
+    SplicePath(path, start, deleteCount, items, flatten) {
+        return this.diffTree.SplicePath(path, start, deleteCount, items, flatten);
+    }
 }
 exports.DiffSync = DiffSync;

package/Store/Diff/diffTree.d.ts

@@ -4,10 +4,19 @@ import { JsonDiffFactoryResult, JsonDiffResult } from "../../Utils/json";
  */
 export interface IDiffMethod {
     /** The method to call */
-    method: "create" | "diffpath" | "diffbatch" | "updatepath" | "getpath";
+    method: "create" | "diffpath" | "splicepath" | "diffbatch" | "updatepath" | "getpath";
     /** Arguments for the method call */
     arguments: Array<any>;
 }
+export type DiffSpliceResult<T = unknown> = {
+    /** Array path segments (strings for object keys, numbers for array indices) */
+    path: (string | number)[];
+    /** Required by the splice operation **/
+    start: number;
+    deleteCount: number;
+    spliceResult: any[];
+    diffResult: JsonDiffResult;
+};
 /**
  * Interface for diff tree operations.
  */
@@ -28,6 +37,7 @@ 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.

package/Store/Diff/diffTree.js

@@ -29,6 +29,11 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
                     ctx.postMessage(diff);
                     break;
                 }
+                case "splicepath": {
+                    const diff = diffTree.SplicePath(data.arguments[0], data.arguments[1], data.arguments[2], data.arguments[3], data.arguments[4]);
+                    ctx.postMessage(diff);
+                    break;
+                }
                 case "diffbatch": {
                     const diff = diffTree.DiffBatch(data.arguments[0]);
                     ctx.postMessage(diff);
@@ -158,6 +163,34 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
         }
         return diffResult;
     }
+    function SpliceSource(source, path, start, deleteCount, items, flatten, keyFunc) {
+        const sourceValue = GetPathValue(source, path);
+        if (!Array.isArray(sourceValue))
+            throw `Value found at path ${path} is not an array`;
+        deleteCount ??= sourceValue.length - start;
+        const spliceResult = {
+            path: path.split("."),
+            start,
+            deleteCount,
+            spliceResult: null,
+            diffResult: []
+        };
+        spliceResult.spliceResult = sourceValue.splice(start, deleteCount, ...items);
+        if (flatten && keyFunc) {
+            // Register the keyed entities the new items carry, diffed against the roots
+            // already held: a new entity is added whole, one re-inserted unchanged (an undo)
+            // produces no diff, so its readers aren't woken.
+            const flattened = JsonDeepClone(FlattenValue({}, items, keyFunc));
+            const keys = Object.keys(flattened);
+            for (let x = 0; x < keys.length; x++)
+                JsonDiff(flattened[keys[x]], source[keys[x]], keys[x], spliceResult.diffResult);
+        }
+        const filteredDiffResult = spliceResult.diffResult.filter((diff) => diff.value !== undefined);
+        for (let x = 0; x < filteredDiffResult.length; x++) {
+            SetPathValue(source, filteredDiffResult[x].path, filteredDiffResult[x].value);
+        }
+        return spliceResult;
+    }
     /**
      * Internal diff tree implementation.
      * Maintains root state and computes diffs for path/value updates.
@@ -192,6 +225,9 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
         DiffPath(path, value, flatten = true) {
             return UpdateSource(this.rootState, path, value, flatten, this.keyFunc);
         }
+        SplicePath(path, start, deleteCount, items, flatten = true) {
+            return SpliceSource(this.rootState, path, start, deleteCount, items, flatten, this.keyFunc);
+        }
         /**
          * Retrieves the current value at a path.
          * @param path - Dot-separated path to the value

package/Store/Store/store.d.ts

@@ -8,6 +8,7 @@ import { JsonDiffResult } from "../../Utils/json";
  */
 export declare abstract class Store {
     protected keyFunc?: (value: any) => string | undefined;
+    private cloneData;
     private rootMap;
     private createNode;
     /**
@@ -15,7 +16,7 @@ export declare abstract class Store {
      * @param keyFunc Optional function to generate a key for a given data value.
      * When provided, enables alias functionality where values can reference other root objects.
      */
-    constructor(keyFunc?: (value: any) => string | undefined);
+    constructor(keyFunc?: (value: any) => string | undefined, cloneData?: boolean);
     /**
      * Retrieves a value from the store by id.
      * @template O - The type of the value to retrieve
@@ -31,6 +32,7 @@ export declare abstract class Store {
      * @returns The value or the default value
      */
     Get<O>(id: string, defaultValue: O): O;
+    Has(id: string): boolean;
     abstract Write(data: unknown, key?: string): Promise<void> | void;
     abstract Patch(key: string, patch: unknown): Promise<void> | void;
     abstract Push(key: string, ...data: unknown[]): Promise<void> | void;
@@ -41,6 +43,7 @@ export declare abstract class Store {
      * @protected
      */
     protected UpdateRootMap(results: JsonDiffResult): void;
+    protected SpliceRootObject(rootPath: string | number, start: number, deleteCount: number, items: any[]): void;
     /**
      * Updates a specific root object with diff results.
      * Creates the root object if it doesn't exist.

package/Store/Store/store.js

@@ -16,8 +16,9 @@ class Store {
      * @param keyFunc Optional function to generate a key for a given data value.
      * When provided, enables alias functionality where values can reference other root objects.
      */
-    constructor(keyFunc) {
+    constructor(keyFunc, cloneData = true) {
         this.keyFunc = keyFunc;
+        this.cloneData = cloneData;
         this.rootMap = new Map();
         const aliasFunc = keyFunc &&
             ((value, reactive = true) => {
@@ -44,6 +45,9 @@ class Store {
         }
         return result[id];
     }
+    Has(id) {
+        return this.rootMap.has(id);
+    }
     /**
      * Updates the root map with diff results by grouping changes by root path.
      * @param results - Array of diff results to apply
@@ -59,6 +63,11 @@ class Store {
             this.UpdateRootObject(rootGroup[0].path[0], rootGroup);
         }
     }
+    // protected SpliceRootMap(spliceResult: DiffSpliceResult) {
+    SpliceRootObject(rootPath, start, deleteCount, items) {
+        const rootObject = this.rootMap.get(rootPath);
+        observableNode_1.ObservableNode.ApplySplice(rootObject[rootPath], start, deleteCount, items, this.cloneData);
+    }
     /**
      * Updates a specific root object with diff results.
      * Creates the root object if it doesn't exist.
@@ -72,7 +81,8 @@ 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 newRootObject = this.createNode({ [rootPath]: (0, json_1.JsonDeepClone)(results[0].value) });
+            const rootData = this.cloneData ? (0, json_1.JsonDeepClone)(results[0].value) : results[0].value;
+            const newRootObject = this.createNode({ [rootPath]: rootData });
             this.rootMap.set(rootPath, newRootObject);
             return;
         }

package/Store/Store/storeAsync.d.ts

@@ -84,7 +84,7 @@ export declare class StoreAsync extends Store {
      * @param items Optional elements to insert into the array.
      * @returns The array of deleted elements.
      */
-    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<any>;
+    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<any[]>;
     /**
      * Destroys the StoreAsync instance, stopping the async queue and cleaning up the diff instance.
      * This method should be called when the instance is no longer needed to free up resources.

package/Store/Store/storeAsync.js

@@ -43,7 +43,7 @@ class StoreAsync extends store_1.Store {
      * @param keyFunc Optional function to generate a key for a given data value.
      */
     constructor(keyFunc) {
-        super(keyFunc);
+        super(keyFunc, false);
         /**
          * The async queue instance used to manage asynchronous operations in a non-blocking manner.
          * @private
@@ -82,6 +82,8 @@ class StoreAsync extends store_1.Store {
      */
     async Patch(key, patch) {
         await this.queue.Next(async () => {
+            if (!this.Has(key))
+                throw "Key not found in store";
             const value = this.Get(key);
             if (value === undefined)
                 throw "Unable to patch undefined value";
@@ -99,6 +101,8 @@ class StoreAsync extends store_1.Store {
      */
     async Push(key, ...data) {
         await this.queue.Next(async () => {
+            if (!this.Has(key))
+                throw "Key not found in store";
             const arr = this.Get(key);
             const batch = data.map(function (d, i) {
                 return {
@@ -122,12 +126,12 @@ class StoreAsync extends store_1.Store {
      */
     async Splice(key, start, deleteCount, ...items) {
         return await this.queue.Next(async () => {
-            const arr = this.Get(key);
-            const arrValue = arr.toJSON();
-            const spliceResult = arrValue.splice(start, deleteCount, ...items);
-            const diffResult = await this.diff.DiffPath(key, arrValue);
-            this.UpdateRootMap(diffResult);
-            return spliceResult;
+            if (!this.Has(key))
+                throw "Key not found in store";
+            const spliceResult = await this.diff.SplicePath(key, start, deleteCount, items);
+            this.UpdateRootMap(spliceResult.diffResult);
+            this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, (0, json_1.JsonDeepClone)(items));
+            return spliceResult.spliceResult;
         });
     }
     /**

package/Store/Store/storeSync.d.ts

@@ -67,5 +67,5 @@ export declare class StoreSync extends Store {
      * @param items Optional elements to insert into the array.
      * @returns The array of deleted elements.
      */
-    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): any;
+    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): any[];
 }

package/Store/Store/storeSync.js

@@ -63,6 +63,8 @@ class StoreSync extends store_1.Store {
      * @throws Will throw an error if the value to be patched is undefined.
      */
     Patch(key, patch) {
+        if (!this.Has(key))
+            throw "Key not found in store";
         const value = this.Get(key);
         if (value === undefined)
             throw "Unable to patch undefined value";
@@ -77,6 +79,8 @@ class StoreSync extends store_1.Store {
      * @param data The data items to be pushed into the array.
      */
     Push(key, ...data) {
+        if (!this.Has(key))
+            throw "Key not found in store";
         const arr = this.Get(key);
         const batch = data.map(function (d, i) {
             return {
@@ -97,12 +101,12 @@ class StoreSync extends store_1.Store {
      * @returns The array of deleted elements.
      */
     Splice(key, start, deleteCount, ...items) {
-        const arr = this.Get(key);
-        const arrValue = arr.toJSON();
-        const spliceResult = arrValue.splice(start, deleteCount, ...items);
-        const diffResult = this.diff.DiffPath(key, arrValue);
-        this.UpdateRootMap(diffResult);
-        return spliceResult;
+        if (!this.Has(key))
+            throw "Key not found in 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);
     }
 }
 exports.StoreSync = StoreSync;

package/Store/Tree/observableNode.d.ts

@@ -68,13 +68,14 @@ export declare namespace ObservableNode {
      * @remarks No-op when `value` deep-equals the node's current value (empty diff).
      */
     function Apply(rootNode: any, value: any): void;
+    function ApplySplice(rootNode: any, start: number, deleteCount: number, items: any[], cloneData?: boolean): void;
     /**
      * Applies a JSON diff result to an observable node, efficiently updating only changed properties.
      * Optimizes nested object updates by computing paths incrementally and touching modified properties.
      * @param rootNode The observable node to apply the diff to.
      * @param diffResult The diff result from JsonDiff containing path-value pairs of changes.
      */
-    function ApplyDiff(rootNode: any, diffResult: JsonDiffResult): void;
+    function ApplyDiff(rootNode: any, diffResult: JsonDiffResult, cloneData?: boolean): void;
     /**
      * Creates a factory function for making values observable with optional aliasing.
      * The alias function transforms values before creating the observable proxy,

package/Store/Tree/observableNode.js

@@ -409,17 +409,24 @@ var ObservableNode;
         ApplyDiff(rootNode, diff);
     }
     ObservableNode.Apply = Apply;
+    function ApplySplice(rootNode, start, deleteCount, items, cloneData = true) {
+        const root = rootNode[NODE_VALUE];
+        const addItems = cloneData ? (0, json_1.JsonDeepClone)(items) : items;
+        root.splice(start, deleteCount, ...addItems);
+        ObservableNode.Update(root);
+    }
+    ObservableNode.ApplySplice = ApplySplice;
     /**
      * Applies a JSON diff result to an observable node, efficiently updating only changed properties.
      * Optimizes nested object updates by computing paths incrementally and touching modified properties.
      * @param rootNode The observable node to apply the diff to.
      * @param diffResult The diff result from JsonDiff containing path-value pairs of changes.
      */
-    function ApplyDiff(rootNode, diffResult) {
+    function ApplyDiff(rootNode, diffResult, cloneData = true) {
         const root = rootNode[NODE_VALUE];
         if (diffResult.length === 1 && diffResult[0].path.length === 0) {
             // Replacing rootNode
-            const rootPatch = (0, json_1.JsonDeepClone)(diffResult[0].value);
+            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);
             if (rootType !== rootPatchType)
@@ -465,7 +472,8 @@ var ObservableNode;
                 }
             }
             const assignValue = pathTuples[y][1];
-            ObservableNode.Assign(assignValue, path[y], (0, json_1.JsonDeepClone)(value));
+            const assignData = cloneData ? (0, json_1.JsonDeepClone)(value) : value;
+            ObservableNode.Assign(assignValue, path[y], assignData);
         }
     }
     ObservableNode.ApplyDiff = ApplyDiff;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "j-templates",
-  "version": "8.0.7",
+  "version": "8.0.9",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",