j-templates 8.0.5 → 8.0.7

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.
@@ -19,7 +20,7 @@ class Store {
         this.keyFunc = keyFunc;
         this.rootMap = new Map();
         const aliasFunc = keyFunc &&
-            ((value) => {
+            ((value, reactive = true) => {
                 const key = keyFunc(value);
                 if (key === undefined)
                     return undefined;
@@ -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];
+                reactive && 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.
@@ -80,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

@@ -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.
@@ -52,6 +51,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 +87,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);
         });
     }
@@ -118,10 +123,9 @@ 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 arrValue = arr.toJSON();
+            const spliceResult = arrValue.splice(start, deleteCount, ...items);
+            const diffResult = await this.diff.DiffPath(key, arrValue);
             this.UpdateRootMap(diffResult);
             return 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

@@ -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);
     }
     /**
@@ -98,10 +98,9 @@ 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 arrValue = arr.toJSON();
+        const spliceResult = arrValue.splice(start, deleteCount, ...items);
+        const diffResult = this.diff.DiffPath(key, arrValue);
         this.UpdateRootMap(diffResult);
         return spliceResult;
     }

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
@@ -79,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

@@ -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,19 +90,22 @@ 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);
         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]]);
@@ -108,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;
@@ -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,7 @@ var ObservableNode;
                 }
             }
             const assignValue = pathTuples[y][1];
-            assignValue[path[y]] = 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.7",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",