j-templates 7.0.89 → 7.0.91

package/Store/Tree/observableNode.js

@@ -1,76 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableNode = exports.GET_TO_JSON = exports.GET_OBSERVABLE_VALUE = exports.IS_OBSERVABLE_NODE = void 0;
+exports.ObservableNode = void 0;
 const json_1 = require("../../Utils/json");
 const json_2 = require("../../Utils/json");
 const observableScope_1 = require("./observableScope");
-/**
- * Symbol to identify observable nodes.
- * Used to check if a value is an observable node proxy.
- */
-exports.IS_OBSERVABLE_NODE = Symbol("isObservableNode");
-/**
- * Symbol to get the raw underlying value from an observable node.
- * Returns the unwrapped, non-proxied value.
- */
-exports.GET_OBSERVABLE_VALUE = Symbol("getObservableValue");
-/**
- * Symbol for the toJSON method on observable nodes.
- * Used to serialize observable nodes to plain JSON.
- */
-exports.GET_TO_JSON = Symbol("toJSON");
-const proxyCache = new WeakMap();
-const scopeCache = new WeakMap();
-const leafScopeCache = new WeakMap();
+const NODE_VALUE = Symbol("NODE_VALUE");
+const NODE_PROXY = Symbol("NODE_PROXY");
+const toJSON = "toJSON";
+const IS_NODE = Symbol("IS_NODE");
+const ARRAY_SCOPE = "ARRAY_SCOPE";
+function Identity(value) {
+    return value;
+}
+function Property(value, prop) {
+    return value[prop];
+}
+const wrapperCache = new WeakMap();
 function getOwnPropertyDescriptor(target, prop) {
-    const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+    const descriptor = Object.getOwnPropertyDescriptor(target[NODE_VALUE], prop);
     return {
         ...descriptor,
         configurable: true,
     };
 }
 function getOwnPropertyDescriptorArray(target, prop) {
-    const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+    const descriptor = Object.getOwnPropertyDescriptor(target[NODE_VALUE], prop);
     return {
         ...descriptor,
         configurable: true,
     };
 }
 function has(value, prop) {
-    return Object.hasOwn(value, prop);
+    return Object.hasOwn(value[NODE_VALUE], prop);
 }
 function hasArray(value, prop) {
-    return Object.hasOwn(value, prop);
+    return Object.hasOwn(value[NODE_VALUE], prop);
 }
 function ownKeys(value) {
-    return Object.keys(value);
+    return Object.keys(value[NODE_VALUE]);
 }
 function ownKeysArray(value) {
-    return Object.keys(value);
+    return Object.keys(value[NODE_VALUE]);
 }
 function UnwrapProxy(value, type = (0, json_2.JsonType)(value)) {
     if (type === "value")
         return value;
-    if (value[exports.IS_OBSERVABLE_NODE])
-        return value[exports.GET_OBSERVABLE_VALUE];
+    if (value[IS_NODE])
+        return value[NODE_VALUE];
     switch (type) {
         case "object": {
             const keys = Object.keys(value);
             for (let x = 0; x < keys.length; x++)
                 value[keys[x]] = UnwrapProxy(value[keys[x]]);
+            break;
         }
         case "array": {
             for (let x = 0; x < value.length; x++)
                 value[x] = UnwrapProxy(value[x]);
+            break;
         }
     }
     return value;
 }
 function CreateProxyFactory(alias) {
-    function CreateProxy(value) {
-        value = UnwrapProxy(value);
-        return CreateProxyFromValue(value);
-    }
     function ToJsonCopy(value) {
         const type = (0, json_2.JsonType)(value);
         switch (type) {
@@ -97,41 +89,42 @@ function CreateProxyFactory(alias) {
     }
     const ToJson = alias !== undefined ? ToJsonCopy : ToJsonDefault;
     const readOnly = alias !== undefined;
+    function SetObjectValue(object, prop, value) {
+        object[NODE_VALUE][prop] = value;
+        observableScope_1.ObservableScope.Update(object[prop]);
+    }
+    function SetArrayValue(object, prop, value) {
+        object[NODE_VALUE][prop] = value;
+        observableScope_1.ObservableScope.Update(object[ARRAY_SCOPE]);
+    }
+    function CreateProxy(value) {
+        value = UnwrapProxy(value);
+        return CreateProxyFromValue(value);
+    }
     function CreateArrayProxy(value) {
-        const scope = observableScope_1.ObservableScope.Create(() => value, false, true);
-        const proxy = new Proxy(value, {
+        const wrapper = {
+            [NODE_VALUE]: value,
+            [NODE_PROXY]: null,
+            [ARRAY_SCOPE]: observableScope_1.ObservableScope.Basic(Identity.bind(null, value))
+        };
+        const proxy = wrapper[NODE_PROXY] = new Proxy(wrapper, {
             get: ArrayProxyGetter,
             set: ArrayProxySetter,
             has: hasArray,
             ownKeys: ownKeysArray,
             getOwnPropertyDescriptor: getOwnPropertyDescriptorArray,
         });
-        scopeCache.set(value, scope);
-        proxyCache.set(value, proxy);
+        wrapperCache.set(value, wrapper);
         return proxy;
     }
-    function CreateObjectProxy(value) {
-        const proxy = new Proxy(value, {
-            get: ObjectProxyGetter,
-            set: ObjectProxySetter,
-            has,
-            ownKeys,
-            getOwnPropertyDescriptor,
-        });
-        leafScopeCache.set(value, {});
-        proxyCache.set(value, proxy);
-        return proxy;
-    }
-    function ArrayProxySetter(array, prop, value) {
+    function ArrayProxySetter(object, prop, value) {
         if (readOnly)
             throw `Object is readonly`;
         value = UnwrapProxy(value);
-        array[prop] = value;
-        const scope = scopeCache.get(array);
-        observableScope_1.ObservableScope.Update(scope);
+        SetArrayValue(object, prop, value);
         return true;
     }
-    function ArrayProxyGetter(array, prop) {
+    function ArrayProxyGetter(object, prop) {
         if (readOnly)
             switch (prop) {
                 case "push":
@@ -144,25 +137,23 @@ function CreateProxyFactory(alias) {
                     throw "Object is readonly";
             }
         switch (prop) {
-            case exports.IS_OBSERVABLE_NODE:
+            case IS_NODE:
                 return true;
-            case exports.GET_TO_JSON:
+            case toJSON:
                 return function () {
-                    return ToJson(array);
+                    return ToJson(object[NODE_VALUE]);
                 };
-            case exports.GET_OBSERVABLE_VALUE:
-                return array;
+            case NODE_VALUE:
+                return object[NODE_VALUE];
             default: {
-                const scope = scopeCache.get(array);
-                array = observableScope_1.ObservableScope.Value(scope);
+                const scope = object[ARRAY_SCOPE]; // scopeCache.get(array) as IObservableScope<unknown[]>;
+                const array = observableScope_1.ObservableScope.Value(scope);
                 const arrayValue = array[prop];
                 if (typeof prop === "symbol")
                     return arrayValue;
                 if (typeof arrayValue === "function")
                     return function ArrayFunction(...args) {
-                        const proxyArray = prop === "slice" ? array.slice(...args) : array.slice();
-                        for (let x = 0; x < proxyArray.length; x++)
-                            proxyArray[x] = CreateProxyFromValue(proxyArray[x]);
+                        const proxyArray = prop === "slice" ? array.slice(...args).map(CreateProxyFromValue) : array.map(CreateProxyFromValue);
                         let result = prop === "slice"
                             ? proxyArray
                             : proxyArray[prop](...args);
@@ -187,82 +178,77 @@ function CreateProxyFactory(alias) {
             }
         }
     }
-    function SetPropertyValue(object, prop, value) {
-        object[prop] = value;
-        const leafScopes = leafScopeCache.get(object);
-        observableScope_1.ObservableScope.Update((leafScopes && leafScopes[prop]) || scopeCache.get(object));
+    function CreateObjectProxy(value) {
+        const wrapper = {
+            [NODE_VALUE]: value,
+            [NODE_PROXY]: null
+        };
+        const proxy = wrapper[NODE_PROXY] = new Proxy(wrapper, {
+            get: ObjectProxyGetter,
+            set: ObjectProxySetter,
+            has,
+            ownKeys,
+            getOwnPropertyDescriptor,
+        });
+        wrapperCache.set(value, wrapper);
+        return proxy;
     }
     function ObjectProxySetter(object, prop, value) {
         if (readOnly)
             throw `Object is readonly`;
-        const jsonType = (0, json_2.JsonType)(value);
-        if (jsonType === "value") {
-            value !== object[prop] && SetPropertyValue(object, prop, value);
-        }
-        else {
-            value = UnwrapProxy(value, jsonType);
-            const diff = (0, json_1.JsonDiff)(value, object[prop]);
-            for (let x = 0; x < diff.length; x++) {
-                if (diff[x].path.length === 0) {
-                    SetPropertyValue(object, prop, diff[x].value);
-                }
-                else {
-                    const path = diff[x].path;
-                    let curr = object[prop];
-                    let y = 0;
-                    for (; y < path.length - 1; y++)
-                        curr = curr[path[y]];
-                    SetPropertyValue(curr, path[y], diff[x].value);
-                }
-            }
-        }
+        value = UnwrapProxy(value);
+        SetObjectValue(object, prop, value);
         return true;
     }
     function ObjectProxyGetter(object, prop) {
         switch (prop) {
-            case exports.IS_OBSERVABLE_NODE:
+            case IS_NODE:
                 return true;
-            case exports.GET_TO_JSON:
+            case toJSON:
                 return function () {
                     return ToJson(object);
                 };
-            case exports.GET_OBSERVABLE_VALUE:
-                return object;
+            case NODE_VALUE:
+                return object[NODE_VALUE];
             default: {
                 return GetAccessorValue(object, prop);
             }
         }
     }
-    function GetAccessorValue(parent, prop) {
-        const leafScopes = leafScopeCache.get(parent);
-        leafScopes[prop] ??= observableScope_1.ObservableScope.Create(function () {
-            const value = parent[prop];
-            return CreateProxyFromValue(value);
-        }, false, true);
-        return observableScope_1.ObservableScope.Value(leafScopes[prop]);
+    function GetAccessorValue(object, prop) {
+        const scope = object[prop] ??= observableScope_1.ObservableScope.Basic(Property.bind(null, object[NODE_VALUE], prop));
+        const value = observableScope_1.ObservableScope.Value(scope);
+        return CreateProxyFromValue(value);
     }
     function CreateProxyFromValue(value) {
         const type = (0, json_2.JsonType)(value);
         switch (type) {
             case "object": {
-                let proxy = proxyCache.get(value) ?? CreateObjectProxy(value);
+                const wrapper = wrapperCache.get(value);
+                let proxy = wrapper?.[NODE_PROXY] ?? CreateObjectProxy(value);
                 if (alias !== undefined) {
                     const aliasValue = alias(proxy);
-                    if (aliasValue !== undefined)
-                        proxy = proxyCache.get(aliasValue) ?? CreateObjectProxy(aliasValue);
+                    if (aliasValue !== undefined && aliasValue !== value) {
+                        const wrapper = wrapperCache.get(aliasValue);
+                        proxy = wrapper?.[NODE_PROXY] ?? CreateObjectProxy(aliasValue);
+                    }
                 }
                 return proxy;
             }
             case "array": {
-                const proxy = proxyCache.get(value) ?? CreateArrayProxy(value);
-                observableScope_1.ObservableScope.Touch(scopeCache.get(value));
+                const wrapper = wrapperCache.get(value);
+                const proxy = wrapper?.[NODE_PROXY] ?? CreateArrayProxy(value);
+                observableScope_1.ObservableScope.Touch(wrapper?.[ARRAY_SCOPE]);
                 return proxy;
             }
             default:
                 return value;
         }
     }
-    return CreateProxy;
+    return function CreateProxy(value) {
+        value = UnwrapProxy(value);
+        return CreateProxyFromValue(value);
+    };
 }
 const DefaultCreateProxy = CreateProxyFactory();
 var ObservableNode;
@@ -295,16 +281,20 @@ 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) {
-        let scope;
-        if (prop !== undefined) {
-            const leafScopes = leafScopeCache.get(value);
-            scope = leafScopes?.[prop];
+    function Touch(value, prop = ARRAY_SCOPE) {
+        const wrapper = wrapperCache.get(value);
+        if (wrapper) {
+            const scope = wrapper[prop] ?? wrapper[ARRAY_SCOPE];
+            observableScope_1.ObservableScope.Update(scope);
         }
-        scope ??= scopeCache.get(value);
-        observableScope_1.ObservableScope.Update(scope);
     }
     ObservableNode.Touch = Touch;
+    function Apply(rootNode, update) {
+        const root = rootNode[NODE_VALUE];
+        const diff = (0, json_1.JsonDiff)(update, root);
+        ApplyDiff(rootNode, diff);
+    }
+    ObservableNode.Apply = Apply;
     /**
      * 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.
@@ -312,7 +302,36 @@ var ObservableNode;
      * @param diffResult The diff result from JsonDiff containing path-value pairs of changes.
      */
     function ApplyDiff(rootNode, diffResult) {
-        const root = rootNode[exports.GET_OBSERVABLE_VALUE];
+        const root = rootNode[NODE_VALUE];
+        if (diffResult.length === 1 && diffResult[0].path.length === 0) {
+            // Replacing rootNode
+            const rootPatch = diffResult[0].value;
+            const rootType = (0, json_2.JsonType)(root);
+            const rootPatchType = (0, json_2.JsonType)(root);
+            if (rootType !== rootPatchType)
+                throw new Error("Unable to change type of Root ObservableNode: " + rootType);
+            switch (rootType) {
+                case "array": {
+                    root.splice(0, root.length, ...rootPatch);
+                    ObservableNode.Touch(root);
+                    break;
+                }
+                case "object": {
+                    const keys = Object.keys(root);
+                    const patchKeys = Object.keys(rootPatch);
+                    for (let x = 0; x < keys.length; x++)
+                        if (!patchKeys.includes(keys[x]))
+                            delete root[keys[x]];
+                    Object.assign(root, rootPatch);
+                    for (let x = 0; x < keys.length; x++)
+                        ObservableNode.Touch(root, keys[x]);
+                    break;
+                }
+                case "value":
+                    throw new Error("Unable to replace value type: " + root);
+            }
+            return;
+        }
         const pathTuples = [["", root]];
         for (let x = 0; x < diffResult.length; x++) {
             const { path, value } = diffResult[x];

package/Store/Tree/observableScope.d.ts

@@ -7,6 +7,14 @@ import { Emitter, EmitterCallback } from "../../Utils/emitter";
 interface IStaticObservableScope<T> {
     type: "static";
     value: T;
+    onDestroyed: Emitter | null;
+    destroyed: boolean;
+}
+export interface IBasicObservableScope<T> {
+    type: "basic";
+    emitter: Emitter;
+    getFunction: () => T;
+    destroyed: boolean;
 }
 /**
  * Represents a dynamic (reactive) observable scope.
@@ -17,6 +25,7 @@ interface IDynamicObservableScope<T> {
     type: "dynamic";
     /** Whether the scope's getter function is async */
     async: boolean;
+    pending: Promise<T> | null;
     /** Whether updates are batched (true) or immediate (false) */
     greedy: boolean;
     /** Whether the scope needs recomputation */
@@ -33,12 +42,12 @@ interface IDynamicObservableScope<T> {
     emitter: Emitter;
     /** Array of emitters this scope listens to for dependency changes */
     emitters: (Emitter | null)[];
+    onUpdated: Emitter | null;
     /** Emitter for notifying when the scope is destroyed */
     onDestroyed: Emitter | null;
+    scopes: [any, IObservableScope<any>][] | null;
     /** Map of nested scopes created during this scope's execution */
-    scopes: {
-        [id: string]: IObservableScope<unknown> | null;
-    } | null;
+    mappedScopes: Map<any, IObservableScope<unknown>[]> | null;
 }
 /**
  * A reactive or static scope containing a value.
@@ -62,6 +71,7 @@ export type IObservableScope<T> = IStaticObservableScope<T> | IDynamicObservable
  * @throws Error if called outside a watch context.
  */
 export declare function InlineScope<T>(callback: () => T | Promise<T>, idOverride?: string): T;
+export declare function MappedScope<D, T>(data: D, callback: (data: D) => T | Promise<T>, onUpdated?: (lastValue: T, scope: IObservableScope<T>) => void, onDestroyed?: (lastValue: T) => void): T;
 /**
  * Creates a gatekeeper scope that only emits when the value actually changes (===).
  * Prevents unnecessary downstream re-evaluations when the derived value stays the same.
@@ -113,7 +123,13 @@ export declare namespace ObservableScope {
      */
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
-    }, greedy?: boolean, force?: boolean): IObservableScope<T>;
+    }): IObservableScope<T>;
+    function Greedy<T>(valueFunction: {
+        (): T | Promise<T>;
+    }): IObservableScope<T>;
+    function Basic<T>(valueFunction: {
+        (): T;
+    }): IBasicObservableScope<T>;
     /**
      * Registers an emitter as a dependency for the current watch context.
      * @param emitter The emitter to register as a dependency.
@@ -125,51 +141,56 @@ export declare namespace ObservableScope {
      * @param scope The scope to peek at.
      * @returns The scope's current value.
      */
-    function Peek<T>(scope: IObservableScope<T>): T;
+    function Peek<T>(scope: IObservableScope<T> | IBasicObservableScope<T>): T;
     /**
      * Gets a scope's current value and registers as a dependency.
      * @template T The type of value stored in the scope.
      * @param scope The scope to get the value from.
      * @returns The scope's current value.
      */
-    function Value<T>(scope: IObservableScope<T>): T;
+    function Value<T>(scope: IObservableScope<T> | IBasicObservableScope<T>): T;
     /**
      * Registers a scope as a dependency without retrieving its value.
      * @template T The type of value stored in the scope.
      * @param scope The scope to register as a dependency.
      */
-    function Touch<T>(scope: IObservableScope<T>): void;
+    function Touch<T>(scope: IObservableScope<T> | IBasicObservableScope<T>): void;
     /**
      * Subscribes to changes on a dynamic scope.
      * @template T The type of value stored in the scope.
      * @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: EmitterCallback<[IObservableScope<T>]>): void;
+    function Watch<T>(scope: IObservableScope<T>, callback: (scope: IObservableScope<T>) => void): void;
     /**
      * Unsubscribes from changes on a dynamic scope.
      * @template T The type of value stored in the scope.
      * @param scope The scope to stop watching.
      * @param callback The callback function to remove.
      */
-    function Unwatch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
+    function Unwatch<T>(scope: IObservableScope<T>, callback: (scope: IObservableScope<T>) => void): void;
+    function OnUpdated<T>(scope: IObservableScope<T>, callback: {
+        (lastValue: T, scope: IObservableScope<T>): void;
+    }): void;
     /**
      * Registers a callback to be invoked when the scope is destroyed.
      * @param scope The scope to monitor for destruction.
      * @param callback Function to invoke when the scope is destroyed.
      */
-    function OnDestroyed(scope: IObservableScope<unknown>, callback: EmitterCallback): void;
+    function OnDestroyed<T>(scope: IObservableScope<T>, callback: {
+        (lastValue: T): void;
+    }): void;
     /**
      * Marks a scope as dirty, triggering recomputation on next access or batch.
      * @param scope The scope to mark for update.
      */
-    function Update(scope: IObservableScope<any>): void;
+    function Update(scope: IObservableScope<any> | IBasicObservableScope<any>): void;
     /**
      * Destroys a scope, cleaning up all resources and dependencies.
      * @template T The type of value stored in the scope.
      * @param scope The scope to destroy.
      */
-    function Destroy<T>(scope: IObservableScope<T>): void;
+    function Destroy<T>(scope: IObservableScope<T> | IBasicObservableScope<T>): void;
     /**
      * Destroys multiple scopes, cleaning up their resources.
      * @param scopes Array of scopes to destroy.