j-templates 7.0.93 → 7.0.94

package/Store/Store/storeSync.js

@@ -49,10 +49,10 @@ class StoreSync extends store_1.Store {
      * @throws Will throw an error if no key is provided for the data.
      */
     Write(data, key) {
-        // data = JsonDeepClone(data);
         key = key || this.keyFunc?.(data);
         if (!key)
             throw "No key provided for data";
+        data = observableNode_1.ObservableNode.Unwrap(data);
         const diffResult = this.diff.DiffPath(key, data);
         this.UpdateRootMap(diffResult);
     }

package/Store/Tree/observableNode.d.ts

@@ -8,6 +8,7 @@ export declare namespace ObservableNode {
      * @returns The unwrapped raw value without proxy wrappers.
      */
     function Unwrap<T>(value: T): T;
+    function Clone<T>(value: T): T;
     /**
      * Creates an observable node from a plain value.
      * Wraps the value in a proxy that tracks changes and enables reactive updates.
@@ -22,7 +23,7 @@ export declare namespace ObservableNode {
      * @param value The observable node to touch.
      * @param prop Optional property name or index to touch a specific nested property.
      */
-    function Touch(value: unknown, prop?: string | number | symbol): void;
+    function Update(value: unknown, prop?: string | number | symbol): void;
     function Apply(rootNode: any, update: any): void;
     /**
      * Applies a JSON diff result to an observable node, efficiently updating only changed properties.

package/Store/Tree/observableNode.js

@@ -42,11 +42,20 @@ function ownKeys(value) {
 function ownKeysArray(value) {
     return Object.keys(value[NODE_VALUE]);
 }
+function TouchValue(value, prop = OBJECT_SCOPE) {
+    const wrapper = wrapperCache.get(value);
+    if (wrapper) {
+        const scope = wrapper[prop] ?? wrapper[OBJECT_SCOPE];
+        observableScope_1.ObservableScope.Touch(scope);
+    }
+}
 function UnwrapProxy(value, type = (0, json_2.JsonType)(value)) {
     if (type === "value")
         return value;
-    if (value[IS_NODE])
-        return value[NODE_VALUE];
+    if (value[IS_NODE]) {
+        const nodeValue = value[NODE_VALUE];
+        return nodeValue;
+    }
     switch (type) {
         case "object": {
             const keys = Object.keys(value);
@@ -62,6 +71,27 @@ function UnwrapProxy(value, type = (0, json_2.JsonType)(value)) {
     }
     return value;
 }
+function CloneProxy(value, type = (0, json_2.JsonType)(value)) {
+    if (type === "value")
+        return value;
+    if (value[IS_NODE]) {
+        return (0, json_1.JsonDeepClone)(value);
+    }
+    switch (type) {
+        case "object": {
+            const keys = Object.keys(value);
+            for (let x = 0; x < keys.length; x++)
+                value[keys[x]] = CloneProxy(value[keys[x]]);
+            break;
+        }
+        case "array": {
+            for (let x = 0; x < value.length; x++)
+                value[x] = CloneProxy(value[x]);
+            break;
+        }
+    }
+    return value;
+}
 function CreateProxyFactory(alias) {
     function ToJsonCopy(value) {
         const type = (0, json_2.JsonType)(value);
@@ -146,7 +176,7 @@ function CreateProxyFactory(alias) {
             case NODE_VALUE:
                 return object[NODE_VALUE];
             default: {
-                const scope = object[OBJECT_SCOPE]; // scopeCache.get(array) as IObservableScope<unknown[]>;
+                const scope = object[OBJECT_SCOPE];
                 const array = observableScope_1.ObservableScope.Value(scope);
                 const arrayValue = array[prop];
                 if (typeof prop === "symbol")
@@ -264,6 +294,10 @@ var ObservableNode;
         return UnwrapProxy(value);
     }
     ObservableNode.Unwrap = Unwrap;
+    function Clone(value) {
+        return CloneProxy(value);
+    }
+    ObservableNode.Clone = Clone;
     /**
      * Creates an observable node from a plain value.
      * Wraps the value in a proxy that tracks changes and enables reactive updates.
@@ -281,14 +315,14 @@ var ObservableNode;
      * @param value The observable node to touch.
      * @param prop Optional property name or index to touch a specific nested property.
      */
-    function Touch(value, prop = OBJECT_SCOPE) {
+    function Update(value, prop = OBJECT_SCOPE) {
         const wrapper = wrapperCache.get(value);
         if (wrapper) {
             const scope = wrapper[prop] ?? wrapper[OBJECT_SCOPE];
             observableScope_1.ObservableScope.Update(scope);
         }
     }
-    ObservableNode.Touch = Touch;
+    ObservableNode.Update = Update;
     function Apply(rootNode, update) {
         const root = rootNode[NODE_VALUE];
         const diff = (0, json_1.JsonDiff)(update, root);
@@ -313,7 +347,7 @@ var ObservableNode;
             switch (rootType) {
                 case "array": {
                     root.splice(0, root.length, ...rootPatch);
-                    ObservableNode.Touch(root);
+                    ObservableNode.Update(root);
                     break;
                 }
                 case "object": {
@@ -324,7 +358,7 @@ var ObservableNode;
                             delete root[keys[x]];
                     Object.assign(root, rootPatch);
                     for (let x = 0; x < keys.length; x++)
-                        ObservableNode.Touch(root, keys[x]);
+                        ObservableNode.Update(root, keys[x]);
                     break;
                 }
                 case "value":
@@ -352,7 +386,7 @@ var ObservableNode;
             }
             const assignValue = pathTuples[y][1];
             assignValue[path[y]] = value;
-            ObservableNode.Touch(assignValue, path[y]);
+            ObservableNode.Update(assignValue, path[y]);
         }
     }
     ObservableNode.ApplyDiff = ApplyDiff;

package/Store/Tree/observableScope.d.ts

@@ -117,14 +117,12 @@ export declare namespace ObservableScope {
      * Creates a new observable scope from a value function.
      * @template T The type of value returned by the function.
      * @param valueFunction Function that returns the scope's value. Can be async.
-     * @param greedy Whether updates should be batched via microtask queue. Defaults to false.
-     * @param force If true, always creates a dynamic scope even without dependencies. Defaults to false.
      * @returns A new observable scope.
      */
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
     }): IObservableScope<T>;
-    function Greedy<T>(valueFunction: {
+    function Gated<T>(valueFunction: {
         (): T | Promise<T>;
     }): IObservableScope<T>;
     function Basic<T>(valueFunction: {
@@ -161,7 +159,7 @@ export declare namespace ObservableScope {
      * @param scope The scope to watch for changes.
      * @param callback Function to invoke when the scope's value changes.
      */
-    function Watch<T>(scope: IObservableScope<T>, callback: (scope: IObservableScope<T>) => void): void;
+    function Watch<T>(scope: IObservableScope<T> | IBasicObservableScope<T>, callback: (scope: IObservableScope<T>) => void): void;
     /**
      * Unsubscribes from changes on a dynamic scope.
      * @template T The type of value stored in the scope.

package/Store/Tree/observableScope.js

@@ -284,7 +284,7 @@ function ExecuteScope(scope) {
 function ExecuteFunction(callback, greedy) {
     const async = (0, functions_1.IsAsync)(callback);
     const state = WatchFunction(callback, null, null, null);
-    if (async || state.emitters !== null) {
+    if (greedy || async || state.emitters !== null) {
         const scope = CreateDynamicScope(callback, greedy, async ? null : state.value);
         scope.scopes = state.nextScopes;
         scope.mappedScopes = state.nextMappedScopes;
@@ -539,18 +539,16 @@ var ObservableScope;
      * Creates a new observable scope from a value function.
      * @template T The type of value returned by the function.
      * @param valueFunction Function that returns the scope's value. Can be async.
-     * @param greedy Whether updates should be batched via microtask queue. Defaults to false.
-     * @param force If true, always creates a dynamic scope even without dependencies. Defaults to false.
      * @returns A new observable scope.
      */
     function Create(valueFunction) {
         return ExecuteFunction(valueFunction, false);
     }
     ObservableScope.Create = Create;
-    function Greedy(valueFunction) {
+    function Gated(valueFunction) {
         return ExecuteFunction(valueFunction, true);
     }
-    ObservableScope.Greedy = Greedy;
+    ObservableScope.Gated = Gated;
     function Basic(valueFunction) {
         return CreateBasicScope(valueFunction);
     }
@@ -646,7 +644,7 @@ var ObservableScope;
         if (!scope || scope.destroyed || scope.type === "static")
             return;
         if (scope.type === "basic") {
-            emitter_1.Emitter.Emit(scope.emitter, this);
+            emitter_1.Emitter.Emit(scope.emitter, scope);
             return;
         }
         scope.setCallback();

package/Utils/decorators.js

@@ -134,7 +134,10 @@ function GetDestroyArrayForPrototype(prototype, create = true) {
     return array;
 }
 function CreateComputedScope(getter, store, defaultValue) {
-    const getterScope = observableScope_1.ObservableScope.Greedy(getter);
+    const getterScope = observableScope_1.ObservableScope.Gated(function () {
+        const value = getter();
+        return observableNode_1.ObservableNode.Clone(value);
+    });
     observableScope_1.ObservableScope.Watch(getterScope, (scope) => {
         const data = observableScope_1.ObservableScope.Peek(scope);
         store.Write(data, "root");
@@ -814,7 +817,7 @@ function WatchDecorator(target, propertyKey, descriptor, scopeFunction) {
         function scopeFunctionWrapper() {
             return scopeFunction(instance);
         }
-        const scope = observableScope_1.ObservableScope.Greedy(scopeFunctionWrapper);
+        const scope = observableScope_1.ObservableScope.Gated(scopeFunctionWrapper);
         const propertyMap = GetScopeMapForInstance(this);
         propertyMap[propertyKey] = [scope, undefined];
         observableScope_1.ObservableScope.Watch(scope, function (scope) {

package/Utils/json.d.ts

@@ -16,7 +16,7 @@ export type JsonDiffFactoryResult = ReturnType<typeof JsonDiffFactory>;
 export declare function JsonDiffFactory(): {
     JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>;
     JsonType: (value: any) => "object" | "value" | "array";
-    JsonDeepClone: <T>(value: T) => T;
+    JsonDeepClone: <T>(value: T, type?: string) => T;
     JsonMerge: (source: unknown, patch: unknown) => unknown;
 };
-export declare const JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>, JsonType: (value: any) => "object" | "value" | "array", JsonDeepClone: <T>(value: T) => T, JsonMerge: (source: unknown, patch: unknown) => unknown;
+export declare const JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>, JsonType: (value: any) => "object" | "value" | "array", JsonDeepClone: <T>(value: T, type?: string) => T, JsonMerge: (source: unknown, patch: unknown) => unknown;

package/Utils/json.js

@@ -84,8 +84,7 @@ function JsonDiffFactory() {
      * @param value - The value to clone
      * @returns A deep clone of the value
      */
-    function JsonDeepClone(value) {
-        const type = JsonType(value);
+    function JsonDeepClone(value, type = JsonType(value)) {
         switch (type) {
             case "array": {
                 const typed = value;

package/package.json

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

package/Utils/distinctArray.d.ts

@@ -1,12 +0,0 @@
-export type DistinctArray<T> = {
-    id: (value: T) => unknown;
-    distinct: Set<unknown> | null;
-    array: T[];
-};
-export declare namespace DistinctArray {
-    function Create<T>(id?: (value: T) => unknown): DistinctArray<T>;
-    function Push<T>(distinctArr: DistinctArray<T>, value: T): void;
-    function Get<T>({ array }: DistinctArray<T>): T[];
-    function Size<T>(distinct: DistinctArray<T>): number;
-    function Clear<T>(distinct: DistinctArray<T>): void;
-}

package/Utils/distinctArray.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DistinctArray = void 0;
-var DistinctArray;
-(function (DistinctArray) {
-    function Create(id = (val) => val) {
-        return {
-            id,
-            distinct: null,
-            array: [],
-        };
-    }
-    DistinctArray.Create = Create;
-    function Push(distinctArr, value) {
-        switch (distinctArr.array.length) {
-            case 0:
-                distinctArr.array.push(value);
-                break;
-            case 1: {
-                if (distinctArr.distinct === null) {
-                    distinctArr.distinct = new Set([
-                        distinctArr.id(distinctArr.array[0]),
-                    ]);
-                }
-            }
-            default: {
-                const vId = distinctArr.id(value);
-                if (!distinctArr.distinct.has(vId)) {
-                    distinctArr.distinct.add(vId);
-                    distinctArr.array.push(value);
-                }
-            }
-        }
-    }
-    DistinctArray.Push = Push;
-    function Get({ array }) {
-        return array;
-    }
-    DistinctArray.Get = Get;
-    function Size(distinct) {
-        return distinct.distinct.size;
-    }
-    DistinctArray.Size = Size;
-    function Clear(distinct) {
-        distinct.array = [];
-        distinct.distinct?.clear();
-    }
-    DistinctArray.Clear = Clear;
-})(DistinctArray || (exports.DistinctArray = DistinctArray = {}));