j-templates 8.0.5 → 8.0.6

package/Store/Diff/diffAsync.d.ts

@@ -28,7 +28,7 @@ export declare class DiffAsync implements IDiffTreeAsync {
      * @param value - The new value to compare
      * @returns Promise that resolves to diff results showing changes
      */
-    DiffPath(path: string, value: any): Promise<JsonDiffResult>;
+    DiffPath(path: string, value: any, flatten?: boolean): Promise<JsonDiffResult>;
     /**
      * Computes diffs for a batch of path/value pairs asynchronously.
      * @param data - Array of objects with path and value properties

package/Store/Diff/diffAsync.js

@@ -28,10 +28,10 @@ class DiffAsync {
      * @param value - The new value to compare
      * @returns Promise that resolves to diff results showing changes
      */
-    async DiffPath(path, value) {
+    async DiffPath(path, value, flatten = true) {
         return await this.workerQueue.Push({
             method: "diffpath",
-            arguments: [path, value],
+            arguments: [path, value, flatten],
         });
     }
     /**

package/Store/Diff/diffSync.d.ts

@@ -21,7 +21,7 @@ export declare class DiffSync implements IDiffTree {
      * @param value - The new value to compare
      * @returns Diff results showing changes
      */
-    DiffPath(path: string, value: any): import("../../Utils/json").JsonDiffResult;
+    DiffPath(path: string, value: any, flatten?: boolean): import("../../Utils/json").JsonDiffResult;
     /**
      * Computes diffs for a batch of path/value pairs.
      * @param data - Array of objects with path and value properties

package/Store/Diff/diffSync.js

@@ -25,8 +25,8 @@ class DiffSync {
      * @param value - The new value to compare
      * @returns Diff results showing changes
      */
-    DiffPath(path, value) {
-        return this.diffTree.DiffPath(path, value);
+    DiffPath(path, value, flatten = true) {
+        return this.diffTree.DiffPath(path, value, flatten);
     }
     /**
      * Computes diffs for a batch of path/value pairs.

package/Store/Diff/diffTree.d.ts

@@ -27,7 +27,7 @@ export interface IDiffTree {
      * @param value - The new value to compare
      * @returns Diff results showing changes
      */
-    DiffPath(path: string, value: any): JsonDiffResult;
+    DiffPath(path: string, value: any, flatten?: boolean): JsonDiffResult;
 }
 /**
  * Constructor interface for IDiffTree.

package/Store/Diff/diffTree.js

@@ -25,7 +25,7 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
                     break;
                 }
                 case "diffpath": {
-                    const diff = diffTree.DiffPath(data.arguments[0], data.arguments[1]);
+                    const diff = diffTree.DiffPath(data.arguments[0], data.arguments[1], data.arguments[2]);
                     ctx.postMessage(diff);
                     break;
                 }
@@ -133,18 +133,18 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
      * @param keyFunc - Optional function to extract keys from objects
      * @returns Diff results showing all changes made
      */
-    function UpdateSource(source, path, value, keyFunc) {
+    function UpdateSource(source, path, value, flatten, keyFunc) {
         const diffResult = [];
         if (keyFunc) {
             const keyPath = ResolveKeyPath(source, path, keyFunc);
             if (keyPath !== path) {
-                const keyDiffResult = UpdateSource(source, keyPath, value, keyFunc);
+                const keyDiffResult = UpdateSource(source, keyPath, value, flatten, keyFunc);
                 diffResult.push(...keyDiffResult);
             }
         }
         const sourceValue = GetPathValue(source, path);
         JsonDiff(value, sourceValue, path, diffResult);
-        if (keyFunc) {
+        if (flatten && keyFunc) {
             let flattened = {};
             flattened = FlattenValue(flattened, value, keyFunc);
             flattened = JsonDeepClone(flattened);
@@ -189,8 +189,8 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
          * @param value - The new value to compare
          * @returns Diff results showing changes
          */
-        DiffPath(path, value) {
-            return UpdateSource(this.rootState, path, value, this.keyFunc);
+        DiffPath(path, value, flatten = true) {
+            return UpdateSource(this.rootState, path, value, flatten, this.keyFunc);
         }
         /**
          * Retrieves the current value at a path.

package/Store/Store/store.d.ts

@@ -6,7 +6,7 @@ import { JsonDiffResult } from "../../Utils/json";
  * @see StoreSync
  * @see StoreAsync
  */
-export declare class Store {
+export declare abstract class Store {
     protected keyFunc?: (value: any) => string | undefined;
     private rootMap;
     private createNode;
@@ -31,6 +31,10 @@ export declare class Store {
      * @returns The value or the default value
      */
     Get<O>(id: string, defaultValue: O): O;
+    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;
+    abstract Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<any[]> | any[];
     /**
      * Updates the root map with diff results by grouping changes by root path.
      * @param results - Array of diff results to apply

package/Store/Store/store.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Store = void 0;
+const json_1 = require("../../Utils/json");
 const observableNode_1 = require("../Tree/observableNode");
 /**
  * Base class for observable data store management.
@@ -27,6 +28,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);
                 const alias = rootValue[key];
                 return alias;
             });
@@ -70,7 +72,7 @@ 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]: results[0].value });
+            const newRootObject = this.createNode({ [rootPath]: (0, json_1.JsonDeepClone)(results[0].value) });
             this.rootMap.set(rootPath, newRootObject);
             return;
         }

package/Store/Store/storeAsync.d.ts

@@ -47,6 +47,10 @@ export declare class StoreAsync extends Store {
      * @param keyFunc Optional function to generate a key for a given data value.
      */
     constructor(keyFunc?: (value: any) => string | undefined);
+    /**
+     * Returns a promise that resolve once all current queued writes have completed
+     */
+    Flush(): Promise<void>;
     /**
      * Writes data to the store asynchronously.
      * This method ensures that write operations are queued and executed in a non-blocking manner.

package/Store/Store/storeAsync.js

@@ -52,6 +52,12 @@ class StoreAsync extends store_1.Store {
         this.queue = new asyncQueue_1.AsyncQueue();
         this.diff = new diffAsync_1.DiffAsync(keyFunc);
     }
+    /**
+     * Returns a promise that resolve once all current queued writes have completed
+     */
+    async Flush() {
+        return this.queue.Flush();
+    }
     /**
      * Writes data to the store asynchronously.
      * This method ensures that write operations are queued and executed in a non-blocking manner.
@@ -82,7 +88,7 @@ class StoreAsync extends store_1.Store {
                 throw "Unable to patch undefined value";
             const json = value.toJSON();
             const mergedJson = (0, json_1.JsonMerge)(json, patch);
-            const diffResult = await this.diff.DiffPath(key, mergedJson);
+            const diffResult = await this.diff.DiffPath(key, mergedJson, false);
             this.UpdateRootMap(diffResult);
         });
     }

package/Store/Store/storeSync.js

@@ -68,7 +68,7 @@ class StoreSync extends store_1.Store {
             throw "Unable to patch undefined value";
         const json = observableNode_1.ObservableNode.Unwrap(value);
         const mergedJson = (0, json_1.JsonMerge)(json, patch);
-        const diffResult = this.diff.DiffPath(key, mergedJson);
+        const diffResult = this.diff.DiffPath(key, mergedJson, false);
         this.UpdateRootMap(diffResult);
     }
     /**

package/Store/Tree/observableNode.d.ts

@@ -46,6 +46,9 @@ export declare namespace ObservableNode {
      * @param prop Optional property name or index to touch a specific nested property.
      */
     function Update<T>(value: T, prop?: keyof T): void;
+    function Assign<T>(value: T, prop: keyof T, propValue: any): void;
+    function Touch<T>(value: T, prop?: keyof T): void;
+    function Read<T>(value: T, prop: keyof T): void;
     /**
      * Merges a new value into an observable node in-place, preserving the node's object identity.
      * Computes the diff between the node's current value and the provided value, then applies only

package/Store/Tree/observableNode.js

@@ -8,7 +8,8 @@ const NODE_VALUE = Symbol("NODE_VALUE");
 const NODE_PROXY = Symbol("NODE_PROXY");
 const toJSON = "toJSON";
 const IS_NODE = Symbol("IS_NODE");
-const OBJECT_SCOPE = Symbol("ARRAY_SCOPE");
+const OBJECT_SCOPE = Symbol("OBJECT_SCOPE");
+const ITERATOR_SCOPE = Symbol("ITERATOR_SCOPE");
 function Identity(value) {
     return value;
 }
@@ -31,15 +32,19 @@ function getOwnPropertyDescriptorArray(target, prop) {
     };
 }
 function has(value, prop) {
+    observableScope_1.ObservableScope.Touch(value[ITERATOR_SCOPE]);
     return Object.hasOwn(value[NODE_VALUE], prop);
 }
 function hasArray(value, prop) {
+    observableScope_1.ObservableScope.Touch(value[ITERATOR_SCOPE]);
     return Object.hasOwn(value[NODE_VALUE], prop);
 }
 function ownKeys(value) {
+    observableScope_1.ObservableScope.Touch(value[ITERATOR_SCOPE]);
     return Object.keys(value[NODE_VALUE]);
 }
 function ownKeysArray(value) {
+    observableScope_1.ObservableScope.Touch(value[ITERATOR_SCOPE]);
     return Object.keys(value[NODE_VALUE]);
 }
 function UnwrapProxy(value, type = (0, json_2.JsonType)(value)) {
@@ -85,6 +90,9 @@ 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));
+}
 function CreateProxyFactory(alias) {
     function ToJsonCopy(value) {
         const type = (0, json_2.JsonType)(value);
@@ -204,7 +212,8 @@ function CreateProxyFactory(alias) {
     function CreateObjectProxy(value) {
         const wrapper = {
             [NODE_VALUE]: value,
-            [NODE_PROXY]: null
+            [NODE_PROXY]: null,
+            [ITERATOR_SCOPE]: observableScope_1.ObservableScope.Basic(Identity.bind(null, value))
         };
         const proxy = wrapper[NODE_PROXY] = new Proxy(wrapper, {
             get: ObjectProxyGetter,
@@ -224,6 +233,7 @@ function CreateProxyFactory(alias) {
         return true;
     }
     function ObjectProxyGetter(object, prop) {
+        observableScope_1.ObservableScope.Touch(object[OBJECT_SCOPE]);
         switch (prop) {
             case IS_NODE:
                 return true;
@@ -239,7 +249,7 @@ function CreateProxyFactory(alias) {
         }
     }
     function GetAccessorValue(object, prop) {
-        const scope = object[prop] ??= observableScope_1.ObservableScope.Basic(Property.bind(null, object[NODE_VALUE], prop));
+        const scope = GetPropertyScope(object, prop);
         const value = observableScope_1.ObservableScope.Value(scope);
         return CreateProxyFromValue(value);
     }
@@ -330,14 +340,51 @@ var ObservableNode;
      * @param value The observable node to touch.
      * @param prop Optional property name or index to touch a specific nested property.
      */
-    function Update(value, prop = OBJECT_SCOPE) {
+    function Update(value, prop) {
         const wrapper = wrapperCache.get(value);
         if (wrapper) {
-            const scope = Array.isArray(wrapper) ? wrapper[OBJECT_SCOPE] : wrapper[prop] ?? wrapper[OBJECT_SCOPE];
+            const scope = Array.isArray(wrapper) ? wrapper[OBJECT_SCOPE] : (prop && wrapper[prop]) ?? wrapper[ITERATOR_SCOPE];
             observableScope_1.ObservableScope.Update(scope);
         }
     }
     ObservableNode.Update = Update;
+    function Assign(value, prop, propValue) {
+        const propExists = Object.hasOwn(value, prop);
+        value[prop] = propValue;
+        const wrapper = wrapperCache.get(value);
+        if (wrapper) {
+            if (Array.isArray(wrapper))
+                observableScope_1.ObservableScope.Update(wrapper[OBJECT_SCOPE]);
+            else {
+                const scope = wrapper[prop];
+                if (scope) {
+                    // A prop was just added to the object, fire the iterator scope
+                    if (!propExists)
+                        observableScope_1.ObservableScope.Update(wrapper[ITERATOR_SCOPE]);
+                    observableScope_1.ObservableScope.Update(scope);
+                }
+                else
+                    observableScope_1.ObservableScope.Update(wrapper[ITERATOR_SCOPE]);
+            }
+        }
+    }
+    ObservableNode.Assign = Assign;
+    function Touch(value, prop) {
+        const wrapper = wrapperCache.get(value);
+        if (wrapper) {
+            const scope = prop && GetPropertyScope(wrapper, prop) || wrapper[OBJECT_SCOPE];
+            observableScope_1.ObservableScope.Touch(scope);
+        }
+    }
+    ObservableNode.Touch = Touch;
+    function Read(value, prop) {
+        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);
+        }
+    }
+    ObservableNode.Read = Read;
     /**
      * Merges a new value into an observable node in-place, preserving the node's object identity.
      * Computes the diff between the node's current value and the provided value, then applies only
@@ -372,7 +419,7 @@ var ObservableNode;
         const root = rootNode[NODE_VALUE];
         if (diffResult.length === 1 && diffResult[0].path.length === 0) {
             // Replacing rootNode
-            const rootPatch = diffResult[0].value;
+            const rootPatch = (0, json_1.JsonDeepClone)(diffResult[0].value);
             const rootType = (0, json_2.JsonType)(root);
             const rootPatchType = (0, json_2.JsonType)(rootPatch);
             if (rootType !== rootPatchType)
@@ -418,8 +465,9 @@ var ObservableNode;
                 }
             }
             const assignValue = pathTuples[y][1];
-            assignValue[path[y]] = value;
-            ObservableNode.Update(assignValue, path[y]);
+            // assignValue[path[y]] = JsonDeepClone(value);
+            // ObservableNode.Update(assignValue, path[y]);
+            ObservableNode.Assign(assignValue, path[y], (0, json_1.JsonDeepClone)(value));
         }
     }
     ObservableNode.ApplyDiff = ApplyDiff;

package/Store/index.d.ts

@@ -1,3 +1,4 @@
+export { Store } from "./Store/store";
 export { StoreSync } from "./Store/storeSync";
 export { StoreAsync } from "./Store/storeAsync";
 export { ObservableScope } from "./Tree/observableScope";

package/Store/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableNode = exports.ObservableScope = exports.StoreAsync = exports.StoreSync = void 0;
+exports.ObservableNode = exports.ObservableScope = exports.StoreAsync = exports.StoreSync = exports.Store = void 0;
+var store_1 = require("./Store/store");
+Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return store_1.Store; } });
 var storeSync_1 = require("./Store/storeSync");
 Object.defineProperty(exports, "StoreSync", { enumerable: true, get: function () { return storeSync_1.StoreSync; } });
 var storeAsync_1 = require("./Store/storeAsync");

package/Utils/asyncQueue.d.ts

@@ -4,6 +4,7 @@
 export declare class AsyncQueue {
     private running;
     private queue;
+    Flush(): Promise<void>;
     /**
      * Adds a callback to the queue and returns a promise that resolves when it executes.
      * @template T - The type the callback promise resolves to

package/Utils/asyncQueue.js

@@ -10,6 +10,13 @@ class AsyncQueue {
         this.running = false;
         this.queue = list_1.List.Create();
     }
+    Flush() {
+        const ret = new Promise(resolve => {
+            list_1.List.Add(this.queue, resolve);
+        });
+        this.Start();
+        return ret;
+    }
     /**
      * Adds a callback to the queue and returns a promise that resolves when it executes.
      * @template T - The type the callback promise resolves to

package/package.json

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