j-templates 5.0.51 → 5.0.53

package/Node/nodeRef.js

@@ -6,6 +6,7 @@ const injector_1 = require("../Utils/injector");
 const boundNode_1 = require("./boundNode");
 const elementNode_1 = require("./elementNode");
 const componentNode_1 = require("./componentNode");
+const Store_1 = require("../Store");
 var NodeRefType;
 (function (NodeRefType) {
     NodeRefType[NodeRefType["NodeRef"] = 0] = "NodeRef";
@@ -33,12 +34,12 @@ var NodeRef;
                     injector: injector_1.Injector.Current() || new injector_1.Injector(),
                     parent: null,
                     childNodes: null,
-                    destroyed: false,
-                    destroyables: []
+                    destroyed: false
                 };
             case NodeRefType.BoundNode:
                 return {
                     node: null,
+                    nodeDef: null,
                     nodeType: nodeType,
                     nodeNamespace: namespace,
                     type: NodeRefType.BoundNode,
@@ -46,16 +47,18 @@ var NodeRef;
                     parent: null,
                     childNodes: null,
                     destroyed: false,
-                    destroyables: [],
-                    lastProperties: null,
                     lastEvents: null,
                     setProperties: false,
+                    assignProperties: null,
+                    assignEvents: null,
                     setAttributes: false,
-                    setEvents: false
+                    setEvents: false,
+                    scopes: null
                 };
             case NodeRefType.ElementNode:
                 return {
                     node: null,
+                    nodeDef: null,
                     nodeType: nodeType,
                     nodeNamespace: namespace,
                     type: NodeRefType.ElementNode,
@@ -63,19 +66,21 @@ var NodeRef;
                     parent: null,
                     childNodes: null,
                     destroyed: false,
-                    destroyables: [],
-                    lastProperties: null,
                     lastEvents: null,
                     setProperties: false,
+                    assignProperties: null,
+                    assignEvents: null,
                     setAttributes: false,
                     setEvents: false,
                     childrenFunc: null,
                     nodeList: null,
-                    setData: false
+                    setData: false,
+                    scopes: null
                 };
             case NodeRefType.ComponentNode:
                 return {
                     node: null,
+                    nodeDef: null,
                     nodeType: nodeType,
                     nodeNamespace: namespace,
                     type: NodeRefType.ComponentNode,
@@ -83,14 +88,14 @@ var NodeRef;
                     parent: null,
                     childNodes: null,
                     destroyed: false,
-                    destroyables: [],
-                    lastProperties: null,
-                    lastEvents: null,
                     setProperties: false,
+                    assignProperties: null,
+                    assignEvents: null,
                     setAttributes: false,
                     setEvents: false,
                     component: null,
-                    componentEvents: null
+                    componentEvents: null,
+                    scopes: null
                 };
         }
     }
@@ -98,8 +103,8 @@ var NodeRef;
     function Init(nodeRef) {
         if (nodeRef.node)
             return;
-        nodeRef.node = nodeConfig_1.NodeConfig.createNode(nodeRef.nodeType, nodeRef.nodeNamespace);
-        nodeRef.childNodes = new Set();
+        nodeRef.node = nodeRef.nodeType === 'text' ? nodeConfig_1.NodeConfig.createTextNode() : nodeConfig_1.NodeConfig.createNode(nodeRef.nodeType, nodeRef.nodeNamespace);
+        nodeRef.childNodes = nodeRef.nodeType !== 'text' ? [] : null;
         switch (nodeRef.type) {
             case NodeRefType.BoundNode:
                 boundNode_1.BoundNode.Init(nodeRef);
@@ -113,17 +118,23 @@ var NodeRef;
         }
     }
     NodeRef.Init = Init;
+    function AddChildToNode(parentNode, child) {
+        if (Array.isArray(parentNode.childNodes))
+            parentNode.childNodes.push(child);
+        else
+            parentNode.childNodes.add(child);
+    }
     function InitAll(parentNode, nodeRefs) {
         for (var x = 0; x < nodeRefs.length; x++) {
             nodeRefs[x].parent = parentNode;
-            parentNode.childNodes.add(nodeRefs[x]);
+            AddChildToNode(parentNode, nodeRefs[x]);
             Init(nodeRefs[x]);
         }
     }
     NodeRef.InitAll = InitAll;
     function AddChild(node, child) {
         child.parent = node;
-        node.childNodes.add(child);
+        AddChildToNode(node, child);
         nodeConfig_1.NodeConfig.addChild(node.node, child.node);
     }
     NodeRef.AddChild = AddChild;
@@ -131,7 +142,7 @@ var NodeRef;
         if (currentChild && currentChild.parent !== node)
             throw "currentChild is not valid";
         newChild.parent = node;
-        node.childNodes.add(newChild);
+        AddChildToNode(node, newChild);
         nodeConfig_1.NodeConfig.addChildAfter(node.node, currentChild && currentChild.node, newChild.node);
     }
     NodeRef.AddChildAfter = AddChildAfter;
@@ -143,6 +154,8 @@ var NodeRef;
         }
         let priorNode;
         let curDataNode = nextChildren?.head;
+        let insert = false;
+        let remove = false;
         while (curDataNode) {
             for (let x = 0; x < curDataNode.data.nodes.length; x++) {
                 const actualNode = priorNode ? nodeConfig_1.NodeConfig.getNextSibling(priorNode) : nodeConfig_1.NodeConfig.getFirstChild(rootNode);
@@ -150,20 +163,27 @@ var NodeRef;
                 const expectedNode = virtualNode.node;
                 if (actualNode !== expectedNode) {
                     nodeConfig_1.NodeConfig.addChildBefore(rootNode, actualNode, expectedNode);
+                    !remove && insert && actualNode && nodeConfig_1.NodeConfig.removeChild(rootNode, actualNode);
+                    remove = insert;
+                    insert = true;
+                }
+                else {
+                    insert = false;
+                    remove = false;
                 }
                 priorNode = expectedNode;
             }
             curDataNode = curDataNode.next;
         }
-        let remainingSibling = priorNode && nodeConfig_1.NodeConfig.getNextSibling(priorNode);
-        while (remainingSibling) {
-            nodeConfig_1.NodeConfig.removeChild(rootNode, remainingSibling);
-            remainingSibling = nodeConfig_1.NodeConfig.getNextSibling(priorNode);
+        let lastChild = nodeConfig_1.NodeConfig.getLastChild(rootNode);
+        while (priorNode && priorNode !== lastChild) {
+            nodeConfig_1.NodeConfig.removeChild(rootNode, lastChild);
+            lastChild = nodeConfig_1.NodeConfig.getLastChild(rootNode);
         }
     }
     NodeRef.ReconcileChildren = ReconcileChildren;
     function DetachChild(node, child) {
-        if (node.childNodes.delete(child)) {
+        if (!Array.isArray(node.childNodes) && node.childNodes.delete(child)) {
             nodeConfig_1.NodeConfig.removeChild(node.node, child.node);
             child.parent = null;
         }
@@ -173,13 +193,25 @@ var NodeRef;
         if (node.destroyed)
             return;
         node.destroyed = true;
-        node.childNodes?.forEach(Destroy);
-        for (let x = 0; x < node.destroyables.length; x++)
-            node.destroyables[x]?.Destroy();
+        if (Array.isArray(node.childNodes))
+            for (let x = 0; x < node.childNodes.length; x++)
+                Destroy(node.childNodes[x]);
+        else
+            node.childNodes?.forEach(Destroy);
+        switch (node.type) {
+            case NodeRefType.ComponentNode:
+                node.component?.Destroy();
+            case NodeRefType.ElementNode:
+                node.assignEvents?.(null);
+            case NodeRefType.BoundNode:
+                for (let x = 0; node.scopes && x < node.scopes.length; x++)
+                    Store_1.ObservableScope.Destroy(node.scopes[x]);
+        }
+        node.node = null;
     }
     NodeRef.Destroy = Destroy;
     function DestroyAll(nodes) {
-        for (var x = 0; x < nodes.length; x++)
+        for (let x = 0; x < nodes.length; x++)
             Destroy(nodes[x]);
     }
     NodeRef.DestroyAll = DestroyAll;

package/Node/nodeRef.types.d.ts

@@ -1,5 +1,4 @@
 import { Injector } from "../Utils/injector";
-import { IDestroyable } from "../Utils/utils.types";
 import { IBoundNode } from "./boundNode.types";
 import { IComponentNode } from "./componentNode.types";
 import { IElementNode } from "./elementNode.types";
@@ -11,11 +10,10 @@ export interface INodeRefBase {
     nodeNamespace: string;
     injector: Injector;
     parent: INodeRefBase;
-    childNodes: Set<INodeRefBase>;
+    childNodes: INodeRefBase[] | Set<INodeRefBase>;
     destroyed: boolean;
-    destroyables: IDestroyable[];
 }
 export interface INodeRef extends INodeRefBase {
     type: NodeRefType.NodeRef;
 }
-export type NodeRefTypes = INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any>;
+export type NodeRefTypes = INodeRef | IBoundNode | IElementNode<unknown> | IComponentNode<unknown, unknown, unknown>;

package/Store/Diff/diffTree.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffTreeScope = void 0;
+exports.DiffTreeScope = DiffTreeScope;
 function DiffTreeScope(worker) {
     const ctx = this;
     if (ctx && worker) {
@@ -229,4 +229,3 @@ function DiffTreeScope(worker) {
     }
     return DiffTree;
 }
-exports.DiffTreeScope = DiffTreeScope;

package/Store/Tree/observableComputed.d.ts

@@ -0,0 +1,4 @@
+import { IObservableScope } from "./observableScope";
+export declare namespace ObservableComputed {
+    function Create<T>(compute: () => T): IObservableScope<any>;
+}

package/Store/Tree/observableComputed.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableComputed = void 0;
+const json_1 = require("../../Utils/json");
+const list_1 = require("../../Utils/list");
+const observableNode_1 = require("./observableNode");
+const observableScope_1 = require("./observableScope");
+const scheduleNodes = new Set();
+const computedQueue = list_1.List.Create();
+function updateNode({ node, scope }) {
+    const value = observableScope_1.ObservableScope.Value(scope);
+    node.data = (0, json_1.JsonDeepClone)(value);
+}
+let computing = false;
+function scheduleComputed(node, scope) {
+    if (scheduleNodes.has(node))
+        return;
+    scheduleNodes.add(node);
+    list_1.List.Add(computedQueue, { node, scope });
+    if (!computing) {
+        computing = true;
+        queueMicrotask(function () {
+            computing = false;
+            scheduleNodes.clear();
+            list_1.List.ForEach(computedQueue, updateNode);
+            list_1.List.Clear(computedQueue);
+        });
+    }
+}
+function CreateComputed(compute) {
+    const scope = observableScope_1.ObservableScope.Create(compute);
+    const node = observableNode_1.ObservableNode.Create({ data: null });
+    observableScope_1.ObservableScope.Watch(scope, function (scope) {
+        scheduleComputed(node, scope);
+    });
+    node.data = observableScope_1.ObservableScope.Value(scope);
+    return observableScope_1.ObservableScope.Create(function () { return node.data; }, [scope]);
+}
+var ObservableComputed;
+(function (ObservableComputed) {
+    function Create(compute) {
+        return CreateComputed(compute);
+    }
+    ObservableComputed.Create = Create;
+})(ObservableComputed || (exports.ObservableComputed = ObservableComputed = {}));

package/Store/Tree/observableNode.d.ts

@@ -0,0 +1,3 @@
+export declare namespace ObservableNode {
+    function Create<T>(value: T): T;
+}

package/Store/Tree/observableNode.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableNode = void 0;
+const json_1 = require("../../Utils/json");
+const observableScope_1 = require("./observableScope");
+const proxyCache = new WeakMap();
+const scopeCache = new WeakMap();
+function getOwnPropertyDescriptor(target, prop) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+    return {
+        ...descriptor,
+        configurable: true
+    };
+}
+function getOwnPropertyDescriptorArray(target, prop) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+    return {
+        ...descriptor,
+        configurable: true
+    };
+}
+function has(value, prop) {
+    return Object.hasOwn(value, prop);
+}
+function hasArray(value, prop) {
+    return Object.hasOwn(value, prop);
+}
+function ownKeys(value) {
+    return Object.keys(value);
+}
+function ownKeysArray(value) {
+    return Object.keys(value);
+}
+function UnwrapProxy(value) {
+    if (!value)
+        return value;
+    if (value.toJSON && typeof value.toJSON === 'function')
+        return value.toJSON();
+    const type = (0, json_1.JsonType)(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]]);
+        }
+        case 'array': {
+            for (let x = 0; x < value.length; x++)
+                value[x] = UnwrapProxy(value[x]);
+        }
+    }
+    return value;
+}
+function CreateArrayProxy(value) {
+    const scope = observableScope_1.ObservableScope.Create(() => value);
+    const proxy = new Proxy(value, {
+        get: ArrayProxyGetter,
+        set: ArrayProxySetter,
+        has: hasArray,
+        ownKeys: ownKeysArray,
+        getOwnPropertyDescriptor: getOwnPropertyDescriptorArray
+    });
+    scopeCache.set(value, scope);
+    proxyCache.set(value, proxy);
+    return proxy;
+}
+function CreateObjectProxy(value) {
+    const scope = observableScope_1.ObservableScope.Create(() => value);
+    const proxy = new Proxy(value, {
+        get: ObjectProxyGetter,
+        set: ObjectProxySetter,
+        has,
+        ownKeys,
+        getOwnPropertyDescriptor
+    });
+    scopeCache.set(value, scope);
+    proxyCache.set(value, proxy);
+    return proxy;
+}
+function ArrayProxySetter(array, prop, value) {
+    value = UnwrapProxy(value);
+    array[prop] = value;
+    const scope = scopeCache.get(array);
+    observableScope_1.ObservableScope.Update(scope);
+    return true;
+}
+function ArrayProxyGetter(array, prop) {
+    const scope = scopeCache.get(array);
+    array = observableScope_1.ObservableScope.Value(scope);
+    switch (prop) {
+        case "toJSON":
+            return function () {
+                return array;
+            };
+        default: {
+            const arrayValue = array[prop];
+            if (typeof prop === 'symbol')
+                return arrayValue;
+            if (typeof arrayValue === 'function')
+                return function ArrayFunction(...args) {
+                    const proxyArray = array.slice();
+                    for (let x = 0; x < proxyArray.length; x++)
+                        proxyArray[x] = proxyCache.get(proxyArray[x]) ?? CreateProxy(proxyArray[x]);
+                    let result = proxyArray[prop](...args);
+                    switch (prop) {
+                        case 'push':
+                        case 'unshift':
+                        case 'splice':
+                        case 'pop':
+                        case 'shift':
+                        case 'sort':
+                        case 'reverse':
+                            array.length = proxyArray.length;
+                            for (let x = 0; x < proxyArray.length; x++)
+                                array[x] = UnwrapProxy(proxyArray[x]);
+                            observableScope_1.ObservableScope.Update(scope);
+                            break;
+                    }
+                    return result;
+                };
+            const proxy = CreateProxy(arrayValue);
+            return proxy;
+        }
+    }
+}
+let applyingDiff = false;
+function ObjectProxySetter(object, prop, value) {
+    const scope = scopeCache.get(object);
+    value = UnwrapProxy(value);
+    if (applyingDiff) {
+        object[prop] = value;
+        observableScope_1.ObservableScope.Update(scope);
+    }
+    else {
+        applyingDiff = true;
+        const proxy = proxyCache.get(object);
+        const json = proxy.toJSON();
+        const diff = (0, json_1.JsonDiff)(value, json[prop]);
+        for (let x = 0; x < diff.length; x++) {
+            if (diff[x].path.length === 0) {
+                proxy[prop] = diff[x].value;
+            }
+            else {
+                const path = diff[x].path;
+                let curr = proxy[prop];
+                let y = 0;
+                for (; y < path.length - 1; y++)
+                    curr = curr[path[y]];
+                curr[path[y]] = diff[x].value;
+            }
+        }
+        applyingDiff = false;
+    }
+    return true;
+}
+function ObjectProxyGetter(object, prop) {
+    const scope = scopeCache.get(object);
+    object = observableScope_1.ObservableScope.Value(scope);
+    switch (prop) {
+        case "toJSON":
+            return function () {
+                return object;
+            };
+        default: {
+            const proxyValue = object[prop];
+            if (typeof prop === 'symbol')
+                return proxyValue;
+            const proxy = CreateProxy(proxyValue);
+            return proxy;
+        }
+    }
+}
+function CreateProxy(value) {
+    const type = (0, json_1.JsonType)(value);
+    switch (type) {
+        case 'object': {
+            const proxy = proxyCache.get(value) ?? CreateObjectProxy(value);
+            return proxy;
+        }
+        case 'array': {
+            const proxy = proxyCache.get(value) ?? CreateArrayProxy(value);
+            observableScope_1.ObservableScope.Touch(scopeCache.get(value));
+            return proxy;
+        }
+        default:
+            return value;
+    }
+}
+var ObservableNode;
+(function (ObservableNode) {
+    function Create(value) {
+        value = UnwrapProxy(value);
+        return CreateProxy(value);
+    }
+    ObservableNode.Create = Create;
+})(ObservableNode || (exports.ObservableNode = ObservableNode = {}));

package/Store/Tree/observableScope.d.ts

@@ -1,4 +1,4 @@
-import { Emitter } from "../../Utils/emitter";
+import { Emitter, EmitterCallback } from "../../Utils/emitter";
 import { IDestroyable } from "../../Utils/utils.types";
 export declare class ObservableScopeValue<T> {
     protected scope: IObservableScope<T>;
@@ -33,25 +33,20 @@ export interface IObservableScope<T> extends IDestroyable {
     dirty: boolean;
     emitter: Emitter;
     emitters: Set<Emitter>;
-    setCallback: {
-        (): void;
-    };
+    setCallback: EmitterCallback;
     destroyed: boolean;
+    dependencies?: IObservableScope<unknown>[];
 }
 export declare namespace ObservableScope {
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
-    } | T): IObservableScope<T>;
+    } | T, dependencies?: IObservableScope<unknown>[]): IObservableScope<T>;
     function Register(emitter: Emitter): void;
     function Value<T>(scope: IObservableScope<T>): T;
     function Watching(): boolean;
-    function Watch<T>(scope: IObservableScope<T>, callback: {
-        (scope: IObservableScope<T>): void;
-    }): void;
-    function Unwatch<T>(scope: IObservableScope<T>, callback: {
-        (scope: IObservableScope<T> | ObservableScopeValue<T>): void;
-    }): void;
+    function Touch<T>(scope: IObservableScope<T>): void;
+    function Watch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
+    function Unwatch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T> | ObservableScopeValue<T>]>): void;
     function Update(scope: IObservableScope<any>): void;
-    function Emit(scope: IObservableScope<any>): void;
     function Destroy<T>(scope: IObservableScope<T>): void;
 }

package/Store/Tree/observableScope.js

@@ -47,38 +47,34 @@ class ObservableScope extends ObservableScopeWrapper {
     }
 }
 exports.ObservableScope = ObservableScope;
-var currentSet = null;
-var watching = false;
+let currentSet = null;
+let watching = false;
 function WatchAction(action) {
-    var parentSet = currentSet;
+    const parentSet = currentSet;
     currentSet = null;
-    var parentWatching = watching;
+    const parentWatching = watching;
     watching = true;
     action();
-    var lastSet = currentSet;
+    const lastSet = currentSet;
     currentSet = parentSet;
     watching = parentWatching;
     return lastSet;
 }
 (function (ObservableScope) {
-    function Create(valueFunction) {
-        if (typeof valueFunction !== 'function')
-            return {
-                value: valueFunction,
-                dirty: false,
-                destroyed: false
-            };
-        var scope = {
-            getFunction: valueFunction,
-            async: valueFunction[Symbol.toStringTag] === 'AsyncFunction',
-            value: null,
-            dirty: true,
-            emitter: emitter_1.Emitter.Create(),
+    function Create(valueFunction, dependencies) {
+        const hasFunction = typeof valueFunction === 'function';
+        const scope = {
+            getFunction: hasFunction ? valueFunction : null,
+            value: hasFunction ? null : valueFunction,
+            async: hasFunction ? valueFunction[Symbol.toStringTag] === 'AsyncFunction' : false,
+            dirty: hasFunction,
+            emitter: hasFunction ? emitter_1.Emitter.Create() : null,
             emitters: null,
             destroyed: false,
-            setCallback: function () {
-                OnSet(scope);
-            }
+            setCallback: hasFunction ? function () {
+                return OnSet(scope);
+            } : null,
+            dependencies
         };
         return scope;
     }
@@ -86,7 +82,7 @@ function WatchAction(action) {
     function Register(emitter) {
         if (!watching || !emitter)
             return;
-        currentSet = currentSet || new Set();
+        currentSet ??= new Set();
         currentSet.add(emitter);
     }
     ObservableScope.Register = Register;
@@ -102,6 +98,12 @@ function WatchAction(action) {
         return watching;
     }
     ObservableScope.Watching = Watching;
+    function Touch(scope) {
+        if (!scope || !scope.emitter)
+            return;
+        Register(scope.emitter);
+    }
+    ObservableScope.Touch = Touch;
     function Watch(scope, callback) {
         if (!scope || !scope.emitter)
             return;
@@ -118,27 +120,24 @@ function WatchAction(action) {
         OnSet(scope);
     }
     ObservableScope.Update = Update;
-    function Emit(scope) {
-        emitter_1.Emitter.Emit(scope.emitter);
-    }
-    ObservableScope.Emit = Emit;
     function Destroy(scope) {
         DestroyScope(scope);
     }
     ObservableScope.Destroy = Destroy;
 })(ObservableScope || (exports.ObservableScope = ObservableScope = {}));
 function OnSet(scope) {
-    if (!scope || scope.dirty)
-        return;
-    scope.dirty = true;
+    if (!scope || scope.dirty || scope.destroyed)
+        return scope.destroyed;
+    scope.dirty = !!scope.getFunction;
     emitter_1.Emitter.Emit(scope.emitter, scope);
+    return false;
 }
 function UpdateValue(scope) {
     if (!scope.dirty)
         return;
     scope.dirty = false;
-    var value = null;
-    var emitters = scope.getFunction && WatchAction(() => value = scope.getFunction());
+    let value = null;
+    const emitters = scope.getFunction && WatchAction(() => value = scope.getFunction());
     if (scope.async)
         Promise.resolve(value).then(val => {
             scope.value = val;
@@ -151,17 +150,22 @@ function UpdateValue(scope) {
 function DestroyScope(scope) {
     if (!scope)
         return;
-    scope.emitters && scope.emitters.forEach(e => emitter_1.Emitter.Remove(e, scope.setCallback));
+    if (scope.dependencies !== undefined)
+        for (let x = 0; x < scope.dependencies.length; x++)
+            DestroyScope(scope.dependencies[x]);
     scope.emitters && scope.emitters.clear();
     scope.emitter && scope.emitter.clear();
+    scope.getFunction = null;
+    scope.setCallback = null;
     scope.destroyed = true;
 }
 function UpdateEmitters(scope, newEmitters) {
-    if (newEmitters)
+    if (newEmitters) {
         newEmitters.forEach(e => {
-            if (!scope.emitters || !scope.emitters.delete(e))
+            if (!scope.emitters?.delete(e))
                 emitter_1.Emitter.On(e, scope.setCallback);
         });
+    }
     if (scope.emitters)
         scope.emitters.forEach(e => emitter_1.Emitter.Remove(e, scope.setCallback));
     scope.emitters = newEmitters;

package/Store/index.d.ts

@@ -2,3 +2,5 @@ export { Store } from "./Store/store";
 export { StoreSync } from "./Store/storeSync";
 export { StoreAsync } from "./Store/storeAsync";
 export { ObservableScope } from "./Tree/observableScope";
+export { ObservableNode } from "./Tree/observableNode";
+export { ObservableComputed } from './Tree/observableComputed';