j-templates 7.0.90 → 7.0.92

package/DOM/createAssignment.d.ts

@@ -1,3 +1,6 @@
+export declare function Assignment(target: any, next: any, assignment: {
+    (target: any, key: string, value: any): void;
+}): void;
 export declare function CreateAssignment(target: any, createAssignment: {
     (target: any, key: string): (next: any) => void;
 }): (next: any) => void;

package/DOM/createAssignment.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assignment = Assignment;
 exports.CreateAssignment = CreateAssignment;
 const DEFAULT_ASSIGNMENT = {};
+function Assignment(target, next, assignment) {
+    for (const key in next) {
+        assignment(target, key, next[key]);
+    }
+}
 function CreateAssignment(target, createAssignment) {
     let last;
     let writeTo = {};

package/DOM/createAttributeAssignment.d.ts

@@ -1 +1,2 @@
+export declare function AttributeAssignment(target: HTMLElement, attribute: string, next: any): void;
 export declare function CreateAttributeAssignment(target: HTMLElement, attribute: string): (next: any) => void;

package/DOM/createAttributeAssignment.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttributeAssignment = AttributeAssignment;
 exports.CreateAttributeAssignment = CreateAttributeAssignment;
+function AttributeAssignment(target, attribute, next) {
+    target.setAttribute(attribute, next);
+}
 function CreateAttributeAssignment(target, attribute) {
     let lastValue;
     return function (next) {

package/DOM/createEventAssignment.d.ts

@@ -1 +1,2 @@
+export declare function EventAssignment(target: HTMLElement, event: string, next: any): void;
 export declare function CreateEventAssignment(target: HTMLElement, event: string): (next: any) => void;

package/DOM/createEventAssignment.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventAssignment = EventAssignment;
 exports.CreateEventAssignment = CreateEventAssignment;
+function EventAssignment(target, event, next) {
+    target.addEventListener(event, next);
+}
 function CreateEventAssignment(target, event) {
     let lastEvent;
     return function (next) {

package/DOM/createPropertyAssignment.d.ts

@@ -1 +1,2 @@
+export declare function PropertyAssignment(target: HTMLElement, property: string, next: any): void;
 export declare function CreateRootPropertyAssignment(target: HTMLElement, property: string): (next: any) => void;

package/DOM/createPropertyAssignment.js

@@ -1,8 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyAssignment = PropertyAssignment;
 exports.CreateRootPropertyAssignment = CreateRootPropertyAssignment;
 const json_1 = require("../Utils/json");
 const createAssignment_1 = require("./createAssignment");
+function PropertyAssignment(target, property, next) {
+    switch (property) {
+        case "nodeValue": {
+            AssignNodeValue(target, next);
+            break;
+        }
+        case "className": {
+            AssignClassName(target, next);
+            break;
+        }
+        case "value": {
+            AssignValue(target, next);
+            break;
+        }
+        default: {
+            const jsonType = (0, json_1.JsonType)(next);
+            switch (jsonType) {
+                case "value":
+                    target[property] = next;
+                    break;
+                default: {
+                    const childTarget = target[property];
+                    (0, createAssignment_1.Assignment)(childTarget, next, PropertyAssignment);
+                }
+            }
+        }
+    }
+}
 function CreatePropertyAssignment(target, property) {
     let lastValue;
     let jsonType;

package/DOM/domNodeConfig.js

@@ -119,12 +119,21 @@ exports.DOMNodeConfig = {
     setAttribute(target, attribute, value) {
         target.setAttribute(attribute, value);
     },
+    propertyAssignment(target, next) {
+        (0, createAssignment_1.Assignment)(target, next, createPropertyAssignment_1.PropertyAssignment);
+    },
     createPropertyAssignment(target) {
         return (0, createAssignment_1.CreateAssignment)(target, createPropertyAssignment_1.CreateRootPropertyAssignment);
     },
+    eventAssignment(target, next) {
+        (0, createAssignment_1.Assignment)(target, next, createEventAssignment_1.EventAssignment);
+    },
     createEventAssignment(target) {
         return (0, createAssignment_1.CreateAssignment)(target, createEventAssignment_1.CreateEventAssignment);
     },
+    attributeAssignment(target, next) {
+        (0, createAssignment_1.Assignment)(target, next, createAttributeAssignment_1.AttributeAssignment);
+    },
     createAttributeAssignment(target) {
         return (0, createAssignment_1.CreateAssignment)(target, createAttributeAssignment_1.CreateAttributeAssignment);
     },
@@ -145,6 +154,13 @@ exports.DOMNodeConfig = {
         target.replaceChildren(...children);
     },
     reconcileChildren(target, children) {
+        if (!target.hasChildNodes()) {
+            for (let x = 0; x < children.length; x++) {
+                const nextChild = getHTMLNode(children[x], null);
+                target.appendChild(nextChild);
+            }
+            return;
+        }
         let lastChild = null;
         switch (children.length) {
             case 0:
@@ -155,26 +171,30 @@ exports.DOMNodeConfig = {
                 if (target.firstChild !== lastChild)
                     target.insertBefore(lastChild, target.firstChild);
                 break;
-            default:
-                let actualChild = target.firstChild;
-                let nextChild = null;
-                let x = 0;
-                for (; x < children.length; x++) {
-                    nextChild = getHTMLNode(children[x], actualChild);
-                    while (actualChild && nextChild !== actualChild) {
-                        const nextSibling = actualChild.nextSibling;
-                        target.removeChild(actualChild);
-                        actualChild = nextSibling;
+            default: {
+                let currentChild = target.firstChild;
+                let inNextChildren = false;
+                for (let x = 0; x < children.length; x++) {
+                    const nextChild = (lastChild = getHTMLNode(children[x], currentChild));
+                    if (!currentChild)
+                        target.appendChild(nextChild);
+                    else if (nextChild !== currentChild) {
+                        while (currentChild && (!(inNextChildren = inNextChildren || children.indexOf(currentChild, x + 1) >= 0))) {
+                            const toRemove = currentChild;
+                            currentChild = currentChild.nextSibling;
+                            target.removeChild(toRemove);
+                        }
+                        nextChild !== currentChild &&
+                            target.insertBefore(nextChild, currentChild);
                     }
-                    if (actualChild)
-                        actualChild = actualChild.nextSibling;
                     else
-                        target.appendChild(nextChild);
+                        inNextChildren = false;
+                    currentChild = nextChild.nextSibling;
                 }
-                lastChild = nextChild;
                 break;
+            }
         }
         while (target.lastChild !== lastChild)
             target.removeChild(target.lastChild);
-    },
+    }
 };

package/Node/component.js

@@ -57,6 +57,8 @@ class Component {
             this.scope = {
                 type: "static",
                 value: data,
+                destroyed: false,
+                onDestroyed: null
             };
         this.componentEvents = on;
         this.templates = templates || {};

package/Node/nodeConfig.d.ts

@@ -21,14 +21,17 @@ export interface INodeConfig {
     removeChild(root: any, child: any): void;
     remove(target: any): void;
     fireEvent(target: any, event: string, data: any): void;
+    propertyAssignment(target: any, next: any): void;
     createPropertyAssignment(target: any): {
         (next: any): void;
     };
+    eventAssignment(target: any, next: any): void;
     createEventAssignment(target: any): {
         (next: {
             [event: string]: (event: Event) => void;
         }): void;
     };
+    attributeAssignment(target: any, next: any): void;
     createAttributeAssignment(target: any): {
         (next: {
             [attribute: string]: string;

package/Node/vNode.js

@@ -61,10 +61,7 @@ var vNode;
         vnode.component?.Destroy();
         Store_1.ObservableScope.DestroyAll(vnode.scopes);
         vnode.onDestroyed && emitter_1.Emitter.Emit(vnode.onDestroyed);
-        for (let x = 0; vnode.children && x < vnode.children.length; x++) {
-            DestroyAll(vnode.children[x][1]);
-            Store_1.ObservableScope.Destroy(vnode.children[x][2]);
-        }
+        vnode.children && DestroyAll(vnode.children);
     }
     vNode.Destroy = Destroy;
     function DestroyAll(vnodes) {
@@ -94,54 +91,54 @@ var vNode;
     }
     vNode.Attach = Attach;
 })(vNode || (exports.vNode = vNode = {}));
+function ComponentChildren() {
+    return this.Template();
+}
 function InitNode(vnode) {
     const { type, namespace, props, attrs, on, data, componentFactory, children, childrenArray, } = vnode.definition;
     const node = (vnode.node =
         vnode.definition.node ?? nodeConfig_1.NodeConfig.createNode(type, namespace));
     vnode.definition = null;
     if (props) {
-        const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
         if (typeof props === "function") {
+            const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
             const scope = Store_1.ObservableScope.Create(props);
             vnode.scopes.push(scope);
             Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
             assignProperties(Store_1.ObservableScope.Value(scope));
         }
         else
-            assignProperties(props);
+            nodeConfig_1.NodeConfig.propertyAssignment(node, props);
     }
     if (on) {
-        const assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
         if (typeof on === "function") {
+            const assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
             const scope = Store_1.ObservableScope.Create(on);
             vnode.scopes.push(scope);
             Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
             assignEvents(Store_1.ObservableScope.Value(scope));
         }
         else
-            assignEvents(on);
+            nodeConfig_1.NodeConfig.eventAssignment(node, on);
     }
     if (attrs) {
-        const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
         if (typeof attrs === "function") {
+            const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
             const scope = Store_1.ObservableScope.Create(attrs);
             vnode.scopes.push(scope);
             Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
             assignAttributes(Store_1.ObservableScope.Value(scope));
         }
         else
-            assignAttributes(attrs);
+            nodeConfig_1.NodeConfig.attributeAssignment(node, attrs);
     }
     if (componentFactory) {
         vnode.component = componentFactory(vnode);
         vnode.component.Bound();
-        function componentChildren() {
-            return vnode.component.Template();
-        }
-        Children(vnode, componentChildren, DefaultData);
+        Children(vnode, ComponentChildren.bind(vnode.component));
     }
     else if (childrenArray) {
-        vnode.children = [[undefined, childrenArray, null]];
+        vnode.children = childrenArray;
         vNode.InitAll(childrenArray);
     }
     else if (children) {
@@ -151,26 +148,22 @@ function InitNode(vnode) {
 }
 function Children(vnode, children, data) {
     const childrenScope = CreateChildrenScope(vnode, children, data);
-    if (childrenScope) {
-        vnode.scopes.push(childrenScope);
-        Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
-            if (vnode.destroyed)
-                return;
-            const startChildren = vnode.children;
-            const newChildren = Store_1.ObservableScope.Value(scope);
-            if (startChildren !== newChildren) {
-                vnode.children = newChildren;
-                UpdateChildren(vnode);
-            }
-        }));
-    }
+    vnode.scopes.push(childrenScope);
+    Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
+        if (vnode.destroyed)
+            return;
+        vnode.children = Store_1.ObservableScope.Value(scope);
+        UpdateChildren(vnode);
+    }));
     vnode.children = Store_1.ObservableScope.Value(childrenScope);
 }
-const DEFAULT_DATA = [undefined];
-function DefaultData() {
-    return DEFAULT_DATA;
-}
-function CreateChildrenScope(vnode, children, data = DefaultData) {
+function CreateChildrenScope(vnode, children, data) {
+    if (data === undefined) {
+        const scope = Store_1.ObservableScope.Create(GetNextNodesAsArray.bind(null, vnode.injector, children));
+        Store_1.ObservableScope.OnUpdated(scope, DestroyScopedVNodes);
+        Store_1.ObservableScope.OnDestroyed(scope, DestroyScopedVNodes);
+        return scope;
+    }
     if ((0, functions_1.IsAsync)(data)) {
         const asyncData = data;
         data = function () {
@@ -179,35 +172,27 @@ function CreateChildrenScope(vnode, children, data = DefaultData) {
             });
         };
     }
-    return Store_1.ObservableScope.Create(WrapChildren(vnode.injector, children, data));
+    return Store_1.ObservableScope.Create(DynamicChildrenFunction.bind(null, vnode.injector, children, data));
 }
-function WrapChildren(injector, children, data) {
-    let nodeArray;
-    return function () {
-        const nextData = data === DefaultData ? data() : ToArray(data());
-        switch (nextData.length) {
-            case 0: {
-                if (nodeArray !== undefined) {
-                    for (let x = 0; x < nodeArray.length; x++) {
-                        vNode.DestroyAll(nodeArray[x][1]);
-                        Store_1.ObservableScope.Destroy(nodeArray[x][2]);
-                    }
-                    nodeArray = [];
-                }
-                break;
-            }
-            default: {
-                if (nodeArray === undefined)
-                    nodeArray = InitializeNextNodes(injector, children, nextData);
-                else if (nodeArray.length < 11)
-                    nodeArray = EvaluateNextNodesSmall(injector, children, nextData, nodeArray);
-                else
-                    nodeArray = EvaluateNextNodesLarge(injector, children, nextData, nodeArray);
-                break;
-            }
-        }
-        return nodeArray;
-    };
+function GetNextNodes(injector, children, data) {
+    return ToVNodeType(injector_1.Injector.Scope(injector, children, data));
+}
+function GetNextNodesAsArray(injector, children, data) {
+    const nodes = GetNextNodes(injector, children, data);
+    return ToArray(nodes);
+}
+function DestroyScopedVNodes(value) {
+    Array.isArray(value) ? vNode.DestroyAll(value) : vNode.Destroy(value);
+}
+function DynamicChildrenFunction(injector, children, data) {
+    const nextData = ToArray(data());
+    const getNextNodes = GetNextNodes.bind(null, injector, children);
+    let results = new Array(nextData.length);
+    for (let x = 0; x < nextData.length; x++) {
+        const nodes = (0, observableScope_1.MappedScope)(nextData[x], getNextNodes, DestroyScopedVNodes, DestroyScopedVNodes);
+        results[x] = nodes;
+    }
+    return results.flat();
 }
 function ToArray(result) {
     if (!result)
@@ -216,124 +201,40 @@ function ToArray(result) {
         return result;
     return [result];
 }
-function GetNextNodeRow(data, injector, getNextChildren, scope) {
-    scope ??=
-        data === undefined
-            ? null
-            : Store_1.ObservableScope.Create(function () {
-                const children = injector_1.Injector.Scope(injector, getNextChildren, data);
-                return CreateNodeArray(children);
-            });
-    const children = scope === null
-        ? CreateNodeArray(injector_1.Injector.Scope(injector, getNextChildren, undefined))
-        : Store_1.ObservableScope.Value(scope);
-    return [data, children, scope];
-}
-function InitializeNextNodes(injector, getNextChildren, nextData) {
-    const nextNodes = new Array(nextData.length);
-    for (let x = 0; x < nextData.length; x++) {
-        const data = nextData[x];
-        nextNodes[x] = GetNextNodeRow(data, injector, getNextChildren);
-    }
-    return nextNodes;
-}
-function GetNextNodeRowSmall(injector, getNextChildren, nodeArray, data) {
-    let i = 0;
-    for (; i < nodeArray.length && (nodeArray[i] === null || nodeArray[i][0] !== data); i++) { }
-    if (i === nodeArray.length)
-        return GetNextNodeRow(data, injector, getNextChildren);
-    const nextNodeRow = GetNextNodeRow(data, injector, getNextChildren, nodeArray[i][2]);
-    if (nodeArray[i][1] !== nextNodeRow[1])
-        vNode.DestroyAll(nodeArray[i][1]);
-    nodeArray[i] = null;
-    return nextNodeRow;
-}
-function EvaluateNextNodesSmall(injector, getNextChildren, nextData, nodeArray) {
-    const nextNodes = new Array(nextData.length);
-    for (let x = 0; x < nextData.length; x++)
-        nextNodes[x] = GetNextNodeRowSmall(injector, getNextChildren, nodeArray, nextData[x]);
-    return nextNodes;
-}
-function GetNextNodeRowLarge(injector, getNextChildren, nodeRowMap, data) {
-    const currentChildren = nodeRowMap.get(data);
-    let currentChildIndex = currentChildren ? currentChildren.length - 1 : -1;
-    for (; currentChildIndex >= 0 && currentChildren[currentChildIndex] === null; currentChildIndex--) { }
-    if (currentChildIndex >= 0) {
-        const nodeRow = currentChildren[currentChildIndex];
-        if (currentChildIndex === 0)
-            nodeRowMap.delete(data);
-        else
-            currentChildren[currentChildIndex] = null;
-        const nextNodeRow = GetNextNodeRow(data, injector, getNextChildren, nodeRow[2]);
-        if (nodeRow[1] !== nextNodeRow[1])
-            vNode.DestroyAll(nodeRow[1]);
-        return nextNodeRow;
-    }
-    return GetNextNodeRow(data, injector, getNextChildren);
-}
-function EvaluateNextNodesLarge(injector, getNextChildren, nextData, nodeArray) {
-    const nextNodes = new Array(nextData.length);
-    const dataMap = new Map();
-    for (let x = 0; x < nodeArray.length; x++) {
-        const arr = dataMap.get(nodeArray[x][0]) ?? [];
-        arr.push(nodeArray[x]);
-        dataMap.set(nodeArray[x][0], arr);
-    }
-    for (let x = 0; x < nextData.length; x++) {
-        nextNodes[x] = GetNextNodeRowLarge(injector, getNextChildren, dataMap, nextData[x]);
-    }
-    for (const value of dataMap.values()) {
-        for (let x = 0; x < value.length; x++) {
-            const row = value[x];
-            row && vNode.DestroyAll(row[1]);
-            row && Store_1.ObservableScope.Destroy(row[2]);
-        }
-    }
-    return nextNodes;
+function ToVNodeType(children) {
+    return typeof children === "string" ? { type: "string", node: children } : children;
 }
-function CreateNodeArray(children) {
-    if (!Array.isArray(children)) {
-        return typeof children === "string"
-            ? [{ type: "string", node: children }]
-            : [children];
-    }
-    return children;
+function GetNode(vnode) {
+    return vnode.node;
 }
 function UpdateChildren(vnode, init = false, skipInit = false) {
     if (!vnode.children)
         return;
-    if (vnode.children.length === 1 &&
-        vnode.children[0][1].length === 1 &&
-        vnode.children[0][1][0].node) {
-        nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, vnode.children.flatMap((row) => row[1].map((vnode) => vnode.node)));
-        return;
-    }
     const children = vnode.children;
     (0, thread_1.Thread)(function () {
         if (vnode.destroyed || children !== vnode.children)
             return;
-        for (let x = 0; !skipInit && x < children.length; x++)
-            for (let y = 0; y < children[x][1].length; y++) {
-                const childNode = children[x][1][y];
-                if (!(0, vNode_types_1.isStringNode)(childNode) && childNode.definition) {
-                    (0, thread_1.Schedule)(function () {
-                        if (vnode.destroyed || children !== vnode.children)
-                            return;
-                        vNode.Init(childNode);
-                    });
-                }
+        for (let x = 0; !skipInit && x < children.length; x++) {
+            const childNode = children[x];
+            if (!(0, vNode_types_1.isStringNode)(childNode) && childNode.definition) {
+                (0, thread_1.Schedule)(function () {
+                    if (vnode.destroyed || children !== vnode.children)
+                        return;
+                    vNode.Init(childNode);
+                });
             }
+        }
         (0, thread_1.Thread)(function (async) {
             if (vnode.destroyed || children !== vnode.children)
                 return;
             if (init || !async) {
-                nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, vnode.children.flatMap((row) => row[1].map((vnode) => vnode.node)));
+                nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, vnode.children.map(GetNode));
             }
             else
                 nodeConfig_1.NodeConfig.scheduleUpdate(function () {
                     if (vnode.destroyed || children !== vnode.children)
                         return;
-                    nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, vnode.children.flatMap((row) => row[1].map((vnode) => vnode.node)));
+                    nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, vnode.children.map(GetNode));
                 });
         });
     });

package/Node/vNode.types.d.ts

@@ -23,11 +23,7 @@ export type vElementNode = {
     definition: vNodeDefinition<any, any, any>;
     injector: Injector;
     node: Node | null;
-    children: (readonly [
-        any,
-        vNode[],
-        IObservableScope<string | vNode | vNode[]> | null
-    ])[] | null;
+    children: vNode[];
     destroyed: boolean;
     onDestroyed: Emitter | null;
     scopes: IObservableScope<unknown>[];

package/Store/Store/store.js

@@ -26,7 +26,7 @@ class Store {
                 const rootObject = this.rootMap.get(key);
                 if (rootObject === undefined)
                     throw `No root object found for key: ${key}`;
-                const rootValue = rootObject[observableNode_1.GET_OBSERVABLE_VALUE];
+                const rootValue = observableNode_1.ObservableNode.Unwrap(rootObject); // rootObject[GET_OBSERVABLE_VALUE];
                 const alias = rootValue[key];
                 return alias;
             });

package/Store/Store/storeAsync.js

@@ -118,7 +118,7 @@ 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 = arr[observableNode_1.GET_OBSERVABLE_VALUE];
+            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);

package/Store/Store/storeSync.js

@@ -49,7 +49,7 @@ class StoreSync extends store_1.Store {
      * @throws Will throw an error if no key is provided for the data.
      */
     Write(data, key) {
-        data = (0, json_1.JsonDeepClone)(data);
+        // data = JsonDeepClone(data);
         key = key || this.keyFunc?.(data);
         if (!key)
             throw "No key provided for data";
@@ -66,7 +66,7 @@ class StoreSync extends store_1.Store {
         const value = this.Get(key);
         if (value === undefined)
             throw "Unable to patch undefined value";
-        const json = value.toJSON();
+        const json = observableNode_1.ObservableNode.Unwrap(value);
         const mergedJson = (0, json_1.JsonMerge)(json, patch);
         const diffResult = this.diff.DiffPath(key, mergedJson);
         this.UpdateRootMap(diffResult);
@@ -98,7 +98,7 @@ class StoreSync extends store_1.Store {
      */
     Splice(key, start, deleteCount, ...items) {
         const arr = this.Get(key);
-        const arrValue = arr[observableNode_1.GET_OBSERVABLE_VALUE];
+        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);

package/Store/Tree/observableNode.d.ts

@@ -1,19 +1,4 @@
 import { JsonDiffResult } from "../../Utils/json";
-/**
- * Symbol to identify observable nodes.
- * Used to check if a value is an observable node proxy.
- */
-export declare const IS_OBSERVABLE_NODE: unique symbol;
-/**
- * Symbol to get the raw underlying value from an observable node.
- * Returns the unwrapped, non-proxied value.
- */
-export declare const GET_OBSERVABLE_VALUE: unique symbol;
-/**
- * Symbol for the toJSON method on observable nodes.
- * Used to serialize observable nodes to plain JSON.
- */
-export declare const GET_TO_JSON: unique symbol;
 export declare namespace ObservableNode {
     /**
      * Unwraps an observable node to get the raw underlying value.
@@ -38,6 +23,7 @@ export declare namespace ObservableNode {
      * @param prop Optional property name or index to touch a specific nested property.
      */
     function Touch(value: unknown, prop?: string | number): void;
+    function Apply(rootNode: any, update: any): void;
     /**
      * 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.