j-templates 8.0.6 → 8.0.8

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

package/Store/Store/store.js

@@ -16,11 +16,12 @@ 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) => {
+            ((value, reactive = true) => {
                 const key = keyFunc(value);
                 if (key === undefined)
                     return undefined;
@@ -28,7 +29,7 @@ class Store {
                 if (rootObject === undefined)
                     throw `No root object found for key: ${key}`;
                 const rootValue = observableNode_1.ObservableNode.Unwrap(rootObject); // rootObject[GET_OBSERVABLE_VALUE];
-                observableNode_1.ObservableNode.Touch(rootValue, key);
+                reactive && observableNode_1.ObservableNode.Touch(rootValue, key);
                 const alias = rootValue[key];
                 return alias;
             });
@@ -72,7 +73,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.js

@@ -4,7 +4,6 @@ exports.StoreAsync = void 0;
 const asyncQueue_1 = require("../../Utils/asyncQueue");
 const json_1 = require("../../Utils/json");
 const diffAsync_1 = require("../Diff/diffAsync");
-const observableNode_1 = require("../Tree/observableNode");
 const store_1 = require("./store");
 /**
  * StoreAsync class extends the base Store class to provide asynchronous data management operations.
@@ -44,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
@@ -124,12 +123,29 @@ 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 = observableNode_1.ObservableNode.Unwrap(arr); // (arr as any)[GET_OBSERVABLE_VALUE] as any[];
-            const arrCopy = arrValue.slice();
-            const spliceResult = (0, json_1.JsonDeepClone)(arrCopy.splice(start, deleteCount, ...items));
-            const diffResult = await this.diff.DiffPath(key, arrCopy);
+            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; */
         });
     }
     /**

package/Store/Store/storeSync.js

@@ -98,10 +98,13 @@ class StoreSync extends store_1.Store {
      */
     Splice(key, start, deleteCount, ...items) {
         const arr = this.Get(key);
-        const arrValue = observableNode_1.ObservableNode.Unwrap(arr); // (arr as any)[GET_OBSERVABLE_VALUE] as any[];
-        const arrCopy = arrValue.slice();
-        const spliceResult = (0, json_1.JsonDeepClone)(arrCopy.splice(start, deleteCount, ...items));
-        const diffResult = this.diff.DiffPath(key, arrCopy);
+        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;
     }

package/Store/Tree/observableNode.d.ts

@@ -74,7 +74,7 @@ export declare namespace ObservableNode {
      * @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,
@@ -82,5 +82,5 @@ export declare namespace ObservableNode {
      * @param alias Optional function to transform values before making them observable.
      * @returns A function that creates observable nodes from plain values.
      */
-    function CreateFactory(alias?: (value: any) => any | undefined): <T>(value: T) => T;
+    function CreateFactory(alias?: (value: any, reactive?: boolean) => any | undefined): <T>(value: T) => T;
 }

package/Store/Tree/observableNode.js

@@ -99,13 +99,13 @@ function CreateProxyFactory(alias) {
         switch (type) {
             case "array": {
                 const typedValue = value;
-                const proxy = CreateProxy(typedValue);
-                return proxy.map(ToJsonCopy);
+                const arrayValue = alias(typedValue, false) ?? typedValue;
+                return arrayValue.map(ToJsonCopy);
             }
             case "object": {
                 const typedValue = alias(value) ?? value;
-                const proxy = CreateProxy(typedValue);
-                const keys = Object.keys(proxy);
+                const objectValue = alias(typedValue, false) ?? typedValue;
+                const keys = Object.keys(objectValue);
                 const copy = {};
                 for (let x = 0; x < keys.length; x++)
                     copy[keys[x]] = ToJsonCopy(typedValue[keys[x]]);
@@ -116,7 +116,7 @@ function CreateProxyFactory(alias) {
         }
     }
     function ToJsonDefault(value) {
-        return value;
+        return (0, json_1.JsonDeepClone)(value);
     }
     const ToJson = alias !== undefined ? ToJsonCopy : ToJsonDefault;
     const readOnly = alias !== undefined;
@@ -415,11 +415,11 @@ var ObservableNode;
      * @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,9 +465,8 @@ var ObservableNode;
                 }
             }
             const assignValue = pathTuples[y][1];
-            // assignValue[path[y]] = JsonDeepClone(value);
-            // ObservableNode.Update(assignValue, path[y]);
-            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.6",
+  "version": "8.0.8",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",