j-templates 8.0.8 → 8.0.10

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

@@ -32,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;
@@ -42,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

@@ -45,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
@@ -60,6 +63,10 @@ class Store {
             this.UpdateRootObject(rootGroup[0].path[0], rootGroup);
         }
     }
+    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.

package/Store/Store/storeAsync.js

@@ -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 {
@@ -121,31 +125,14 @@ class StoreAsync extends store_1.Store {
      * @returns The array of deleted elements.
      */
     async Splice(key, start, deleteCount, ...items) {
+        items = (0, json_1.JsonDeepClone)(items);
         return await this.queue.Next(async () => {
-            const arr = this.Get(key);
-            const arrNodes = arr.slice(start); // Array starting from the splice start index
-            const spliceResult = arrNodes.splice(0, deleteCount ?? arrNodes.length, ...items);
-            const diffBatch = new Array(arrNodes.length + 1);
-            for (let x = 0; x < arrNodes.length; x++)
-                diffBatch[x] = { path: `${key}.${x + start}`, value: arrNodes[x]?.toJSON?.() ?? arrNodes[x] };
-            diffBatch[diffBatch.length - 1] = { path: `${key}.length`, value: start + arrNodes.length };
-            const diffResult = await this.diff.DiffBatch(diffBatch);
-            this.UpdateRootMap(diffResult);
-            return spliceResult;
-            /* const arr = this.Get(key) as any[];
-            const arrNodes = arr.slice(start); // Array starting from the splice start index
-            const spliceResult = arrNodes.splice(0, deleteCount, ...items);
-      
-            const diffBatch: { path: string, value: any }[] = new Array(arrNodes.length + 1);
-            for (let x = 0; x < arrNodes.length; x++)
-              diffBatch[x] = { path: `${key}.${x + start}`, value: arrNodes[x]?.toJSON?.() };
-      
-            diffBatch[diffBatch.length - 1] = { path: `${key}.length`, value: arrNodes.length + start + items.length };
-      
-            const diffResult = await this.diff.DiffBatch(diffBatch);
-            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, items);
+            return spliceResult.spliceResult;
         });
     }
     /**

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,16 +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 arrNodes = arr.slice(start); // Array starting from the splice start index
-        const spliceResult = arrNodes.splice(0, deleteCount ?? arrNodes.length, ...items);
-        const diffBatch = new Array(arrNodes.length + 1);
-        for (let x = 0; x < arrNodes.length; x++)
-            diffBatch[x] = { path: `${key}.${x + start}`, value: arrNodes[x]?.toJSON?.() ?? arrNodes[x] };
-        diffBatch[diffBatch.length - 1] = { path: `${key}.length`, value: start + arrNodes.length };
-        const diffResult = this.diff.DiffBatch(diffBatch);
-        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,6 +68,7 @@ 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.

package/Store/Tree/observableNode.js

@@ -409,6 +409,13 @@ 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.

package/package.json

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