j-templates 6.0.33 → 6.0.35

package/DOM/createPropertyAssignment.js

@@ -58,6 +58,7 @@ function CreatePropertyAssignment(target) {
             last[index][2](target, value);
         }
         else if (last[index][1] !== value) {
+            last[index][1] = value;
             last[index][2](target, value);
         }
     }

package/DOM/elements.d.ts

@@ -1,26 +1,26 @@
-import { ElementNodeFunctionParam, ElementChildrenFunction } from "../Node/elementNode.types";
-export declare function div<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function a<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function ul<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function li<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
+import { ElementNodeFunctionParam, ElementChildrenFunctionParam } from "../Node/elementNode.types";
+export declare function div<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function a<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function ul<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function li<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
 export declare function br<T>(nodeDef: ElementNodeFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function b<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function span<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function b<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function span<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
 export declare function img<T>(nodeDef: ElementNodeFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function video<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function video<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
 export declare function source<T>(nodeDef: ElementNodeFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
 export declare function input<T>(nodeDef: ElementNodeFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
 export declare function textarea<T>(nodeDef: ElementNodeFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function select<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function option<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function h1<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function h2<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function h3<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function p<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function style<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function button<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function table<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function tbody<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function th<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function tr<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
-export declare function td<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function select<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function option<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function h1<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function h2<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function h3<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function p<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function style<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function button<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function table<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function tbody<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function th<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function tr<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;
+export declare function td<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): import("../Node/elementNode.types").IElementNode<T>;

package/Node/elementNode.d.ts

@@ -1,5 +1,5 @@
-import { ElementChildrenFunction, ElementNodeFunctionParam, IElementNode, IElementNodeBase } from "./elementNode.types";
+import { ElementChildrenFunctionParam, ElementNodeFunctionParam, IElementNode, IElementNodeBase } from "./elementNode.types";
 export declare namespace ElementNode {
-    function Create<T>(type: any, namespace: string, nodeDef: ElementNodeFunctionParam<T>, children: ElementChildrenFunction<T>): IElementNode<T>;
+    function Create<T>(type: any, namespace: string, nodeDef: ElementNodeFunctionParam<T>, children: ElementChildrenFunctionParam<T>): IElementNode<T>;
     function Init<T>(elementNode: IElementNodeBase<T>): void;
 }

package/Node/elementNode.js

@@ -14,33 +14,35 @@ var ElementNode;
     function Create(type, namespace, nodeDef, children) {
         var elemNode = nodeRef_1.NodeRef.Create(type, namespace, nodeRef_1.NodeRefType.ElementNode);
         elemNode.nodeDef = nodeDef;
-        elemNode.childrenFunc = children;
+        if (Array.isArray(children))
+            elemNode.childrenArray = children;
+        else if (children !== undefined)
+            elemNode.children = children;
         return elemNode;
     }
     ElementNode.Create = Create;
     function Init(elementNode) {
-        if (elementNode.childrenFunc) {
-            var nodeDef = elementNode.nodeDef;
-            if (nodeDef.data) {
-                const dataScope = observableScope_1.ObservableScope.Create(nodeDef.data);
-                const valueScope = observableScope_1.ObservableScope.Create(function () {
-                    const value = observableScope_1.ObservableScope.Value(dataScope);
-                    if (!value)
-                        return valueDefault;
-                    if (!Array.isArray(value))
-                        return [value];
-                    return value;
-                });
-                elementNode.childNodes = new Set();
-                elementNode.scopes ??= [];
-                elementNode.scopes.push(dataScope, valueScope);
-                observableScope_1.ObservableScope.Watch(valueScope, function () {
-                    ScheduleSetData(elementNode, valueScope);
-                });
-                SetData(elementNode, observableScope_1.ObservableScope.Value(valueScope), true);
-            }
-            else
-                SetDefaultData(elementNode);
+        const nodeDef = elementNode.nodeDef;
+        if (elementNode.childrenArray !== null || (elementNode.children !== null && !nodeDef.data)) {
+            SetDefaultData(elementNode);
+        }
+        else if (elementNode.children !== null) {
+            const dataScope = observableScope_1.ObservableScope.Create(nodeDef.data);
+            const valueScope = observableScope_1.ObservableScope.Create(function () {
+                const value = observableScope_1.ObservableScope.Value(dataScope);
+                if (!value)
+                    return valueDefault;
+                if (!Array.isArray(value))
+                    return [value];
+                return value;
+            });
+            elementNode.childNodes = new Set();
+            elementNode.scopes ??= [];
+            elementNode.scopes.push(dataScope, valueScope);
+            observableScope_1.ObservableScope.Watch(valueScope, function () {
+                ScheduleSetData(elementNode, valueScope);
+            });
+            SetData(elementNode, observableScope_1.ObservableScope.Value(valueScope), true);
         }
         boundNode_1.BoundNode.Init(elementNode);
     }
@@ -59,9 +61,14 @@ function ScheduleSetData(node, scope) {
 }
 function SetDefaultData(node) {
     (0, thread_1.Synch)(function () {
-        const nodes = injector_1.Injector.Scope(node.injector, CreateNodeArray, node.childrenFunc, true);
+        const nodes = node.childrenArray || injector_1.Injector.Scope(node.injector, CreateNodeArray, node.children, true);
+        node.childrenArray = null;
         if (nodes.length > 0) {
-            nodeRef_1.NodeRef.InitAll(node, nodes);
+            (0, thread_1.Schedule)(function () {
+                if (node.destroyed)
+                    return;
+                nodeRef_1.NodeRef.InitAll(node, nodes);
+            });
             (0, thread_1.Thread)(function () {
                 if (node.destroyed)
                     return;
@@ -104,7 +111,7 @@ function ReconcileNodeData(node, values) {
             curNode = list_1.List.Add(nextNodeList, {
                 value: values[x],
                 init: false,
-                nodes: injector_1.Injector.Scope(node.injector, CreateNodeArray, node.childrenFunc, values[x])
+                nodes: injector_1.Injector.Scope(node.injector, CreateNodeArray, node.children, values[x])
             });
         }
     }

package/Node/elementNode.types.d.ts

@@ -2,25 +2,24 @@ import { IList } from "../Utils/list";
 import { NodeDefinition, BoundNodeFunctionParam, IBoundNodeBase } from "./boundNode.types";
 import { NodeRefType } from "./nodeRef";
 import { INodeRefBase, NodeRefTypes } from "./nodeRef.types";
+export type ElementChildrenFunction<T> = {
+    (data: T): string | NodeRefTypes | NodeRefTypes[];
+};
+export type ElementChildrenFunctionParam<T> = ElementChildrenFunction<T> | NodeRefTypes[];
+export type ElementNodeFunction<T> = {
+    (nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): INodeRefBase;
+};
 export interface ElementNodeDefinition<T> extends NodeDefinition<T> {
     data?: {
         (): T | Array<T> | Promise<Array<T>> | Promise<T>;
     };
-    children?: {
-        (data?: T): string | NodeRefTypes | NodeRefTypes[];
-    };
+    children?: ElementChildrenFunction<T>;
 }
 export interface ElementNodeFunctionParam<T> extends BoundNodeFunctionParam {
     data?: {
         (): T | Array<T> | Promise<Array<T>> | Promise<T>;
     };
 }
-export type ElementChildrenFunction<T> = {
-    (data: T): string | NodeRefTypes | NodeRefTypes[];
-};
-export type ElementNodeFunction<T> = {
-    (nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): INodeRefBase;
-};
 export interface IElementDataNode<T> {
     value: T;
     init: boolean;
@@ -28,9 +27,8 @@ export interface IElementDataNode<T> {
 }
 export interface IElementNodeBase<T> extends IBoundNodeBase {
     nodeDef: ElementNodeFunctionParam<T>;
-    childrenFunc: {
-        (data: T): string | NodeRefTypes | NodeRefTypes[];
-    };
+    children: ElementChildrenFunction<T>;
+    childrenArray: NodeRefTypes[];
     nodeList: IList<IElementDataNode<T>> | null;
     setData: boolean;
 }

package/Node/nodeRef.js

@@ -75,7 +75,8 @@ var NodeRef;
                     assignText: null,
                     setAttributes: false,
                     setEvents: false,
-                    childrenFunc: null,
+                    children: null,
+                    childrenArray: null,
                     nodeList: null,
                     setData: false,
                     setText: false,
@@ -157,10 +158,9 @@ var NodeRef;
             return;
         }
         let priorNode;
-        let curDataNode = nextChildren?.head;
         let insert = false;
         let remove = false;
-        while (curDataNode) {
+        for (let curDataNode = nextChildren.head; curDataNode !== null; curDataNode = curDataNode.next) {
             for (let x = 0; x < curDataNode.data.nodes.length; x++) {
                 const actualNode = priorNode ? nodeConfig_1.NodeConfig.getNextSibling(priorNode) : nodeConfig_1.NodeConfig.getFirstChild(rootNode);
                 const virtualNode = curDataNode.data.nodes[x];
@@ -177,7 +177,6 @@ var NodeRef;
                 }
                 priorNode = expectedNode;
             }
-            curDataNode = curDataNode.next;
         }
         let lastChild = nodeConfig_1.NodeConfig.getLastChild(rootNode);
         while (priorNode && priorNode !== lastChild) {

package/Store/Tree/observableNode.js

@@ -106,6 +106,7 @@ function CreateProxyFactory(alias) {
             ownKeys,
             getOwnPropertyDescriptor,
         });
+        leafScopeCache.set(value, {});
         proxyCache.set(value, proxy);
         return proxy;
     }
@@ -121,8 +122,6 @@ function CreateProxyFactory(alias) {
         return true;
     }
     function ArrayProxyGetter(array, prop) {
-        if (prop === exports.IS_OBSERVABLE_NODE)
-            return true;
         if (readOnly)
             switch (prop) {
                 case "push":
@@ -136,6 +135,8 @@ function CreateProxyFactory(alias) {
                         throw `Object is readonly`;
             }
         switch (prop) {
+            case exports.IS_OBSERVABLE_NODE:
+                return true;
             case exports.GET_TO_JSON:
                 return function () {
                     return ToJson(array);
@@ -211,9 +212,9 @@ function CreateProxyFactory(alias) {
         return true;
     }
     function ObjectProxyGetter(object, prop) {
-        if (prop === exports.IS_OBSERVABLE_NODE)
-            return true;
         switch (prop) {
+            case exports.IS_OBSERVABLE_NODE:
+                return true;
             case exports.GET_TO_JSON:
                 return function () {
                     return ToJson(object);
@@ -226,11 +227,7 @@ function CreateProxyFactory(alias) {
         }
     }
     function GetAccessorValue(parent, prop) {
-        let leafScopes = leafScopeCache.get(parent);
-        if (leafScopes === undefined) {
-            leafScopes = {};
-            leafScopeCache.set(parent, leafScopes);
-        }
+        const leafScopes = leafScopeCache.get(parent);
         leafScopes[prop] ??= observableScope_1.ObservableScope.Create(function () {
             const value = parent[prop];
             return CreateProxyFromValue(value);

package/Store/Tree/observableScope.d.ts

@@ -24,6 +24,12 @@ export declare class ObservableScope<T> extends ObservableScopeWrapper<T> {
         (): T | Promise<T>;
     });
 }
+interface ICalcFunction<T> {
+    getFunction: {
+        (): T;
+    };
+    value: T;
+}
 export interface IObservableScope<T> extends IDestroyable {
     getFunction: {
         (): T;
@@ -37,7 +43,10 @@ export interface IObservableScope<T> extends IDestroyable {
     setCallback: EmitterCallback;
     destroyed: boolean;
     watchEmitters: Emitter[] | null;
+    watchEmittersSet: Set<Emitter> | null;
+    calcFunctions: ICalcFunction<any>[] | null;
 }
+export declare function CalcScope<T>(callback: () => T): T;
 export declare namespace ObservableScope {
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
@@ -51,3 +60,4 @@ export declare namespace ObservableScope {
     function Update(scope: IObservableScope<any>): void;
     function Destroy<T>(scope: IObservableScope<T>): void;
 }
+export {};

package/Store/Tree/observableScope.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = exports.ObservableScopeWrapper = exports.ObservableScopeValue = void 0;
+exports.CalcScope = CalcScope;
 const emitter_1 = require("../../Utils/emitter");
 const list_1 = require("../../Utils/list");
 class ObservableScopeValue {
@@ -54,10 +55,22 @@ function WatchScope(scope) {
     watchingScope = scope;
     currentlyWatching = true;
     const value = scope.getFunction();
+    watchingScope.watchEmittersSet = null;
     watchingScope = parentScope;
     currentlyWatching = parentWatching;
     return value;
 }
+function CalcScope(callback) {
+    const value = callback();
+    if (currentlyWatching) {
+        watchingScope.calcFunctions ??= [];
+        watchingScope.calcFunctions.push({
+            getFunction: callback,
+            value
+        });
+    }
+    return value;
+}
 (function (ObservableScope) {
     function Create(valueFunction) {
         const scope = {
@@ -70,6 +83,8 @@ function WatchScope(scope) {
             emitters: [],
             destroyed: false,
             watchEmitters: null,
+            watchEmittersSet: null,
+            calcFunctions: null,
             setCallback: function () {
                 return OnSet(scope);
             },
@@ -81,7 +96,12 @@ function WatchScope(scope) {
         if (!currentlyWatching)
             return;
         watchingScope.watchEmitters ??= [];
-        watchingScope.watchEmitters.push(emitter);
+        if (watchingScope.watchEmitters.length === 10)
+            watchingScope.watchEmittersSet = new Set(watchingScope.watchEmitters);
+        if ((watchingScope.watchEmittersSet === null && !watchingScope.watchEmitters.includes(emitter)) || (watchingScope.watchEmittersSet !== null && !watchingScope.watchEmittersSet.has(emitter))) {
+            watchingScope.watchEmittersSet?.add(emitter);
+            watchingScope.watchEmitters.push(emitter);
+        }
     }
     ObservableScope.Register = Register;
     function Value(scope) {
@@ -142,9 +162,15 @@ function QueueScopeUpdate(scope) {
     if (updateScopeQueue.size === 1)
         queueMicrotask(ProcessScopeUpdateQueue);
 }
+function CalcChanged(calc) {
+    const value = calc.getFunction();
+    const changed = calc.value !== value;
+    calc.value = value;
+    return changed;
+}
 function DirtyScope(scope) {
-    scope.dirty = true;
-    scope.async ? QueueScopeUpdate(scope) : emitter_1.Emitter.Emit(scope.emitter, scope);
+    scope.dirty = scope.calcFunctions === null || scope.calcFunctions.some(CalcChanged);
+    scope.dirty && (scope.async ? QueueScopeUpdate(scope) : emitter_1.Emitter.Emit(scope.emitter, scope));
 }
 function OnSet(scope) {
     if (!scope || scope.dirty || scope.destroyed)
@@ -157,6 +183,7 @@ function UpdateValue(scope) {
         return;
     scope.dirty = false;
     scope.watchEmitters = null;
+    scope.calcFunctions = null;
     const value = WatchScope(scope);
     if (scope.async) {
         scope.promise = value.then(function (result) {
@@ -169,27 +196,45 @@ function UpdateValue(scope) {
     UpdateEmitters(scope);
 }
 function UpdateEmitters(scope) {
-    const newEmitters = scope.watchEmitters;
-    if (newEmitters === null) {
-        for (let x = 0; x < scope.emitters.length; x++)
-            emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
-        scope.emitters = [];
+    const right = scope.watchEmitters;
+    if (right === null) {
+        if (scope.emitters.length > 0) {
+            for (let x = 0; x < scope.emitters.length; x++)
+                emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+            scope.emitters = [];
+        }
         return;
     }
-    let x = 0;
-    for (; x < scope.emitters.length && x < newEmitters.length && scope.emitters[x] === newEmitters[x]; x++) { }
-    for (let y = x; y < scope.emitters.length; y++)
-        emitter_1.Emitter.Remove(scope.emitters[y], scope.setCallback);
-    for (let y = x; y < newEmitters.length; y++)
-        emitter_1.Emitter.On(newEmitters[y], scope.setCallback);
-    scope.emitters = newEmitters;
+    emitter_1.Emitter.Sort(right);
+    const left = scope.emitters;
+    let leftIndex = 0;
+    let rightIndex = 0;
+    for (; leftIndex < left.length; leftIndex++) {
+        let y = rightIndex;
+        for (; y < right.length && left[leftIndex] !== right[y]; y++)
+            emitter_1.Emitter.On(right[rightIndex], scope.setCallback);
+        if (y === right.length)
+            emitter_1.Emitter.Remove(left[leftIndex], scope.setCallback);
+        else {
+            for (let x = rightIndex; x < y; x++)
+                emitter_1.Emitter.On(right[x], scope.setCallback);
+            rightIndex = y + 1;
+        }
+    }
+    for (; rightIndex < right.length; rightIndex++)
+        emitter_1.Emitter.On(right[rightIndex], scope.setCallback);
+    scope.emitters = right;
 }
 function DestroyScope(scope) {
     if (!scope)
         return;
+    const emitters = scope.emitters;
     scope.emitters = null;
     scope.emitter = null;
     scope.getFunction = null;
     scope.setCallback = null;
+    scope.calcFunctions = null;
     scope.destroyed = true;
+    for (let x = 0; x < emitters.length; x++)
+        emitter_1.Emitter.Remove(emitters[x], scope.setCallback);
 }

package/Utils/emitter.d.ts

@@ -1,9 +1,12 @@
 export type EmitterCallback<T extends readonly any[] = any[]> = (...args: T) => boolean | void;
-export type Emitter = Array<EmitterCallback | null>;
+export type Emitter = Array<EmitterCallback | null> & {
+    _id: number;
+};
 export declare namespace Emitter {
     function Create(): Emitter;
     function On(emitter: Emitter, callback: EmitterCallback): void;
     function Emit(emitter: Emitter, ...args: any[]): void;
     function Remove(emitter: Emitter, callback: EmitterCallback): void;
     function Clear(emitter: Emitter): void;
+    function Sort(emitters: Emitter[]): Emitter[];
 }

package/Utils/emitter.js

@@ -4,8 +4,11 @@ exports.Emitter = void 0;
 const array_1 = require("./array");
 var Emitter;
 (function (Emitter) {
+    let globalId = 0;
     function Create() {
-        return [];
+        const emitter = [];
+        emitter._id = globalId++;
+        return emitter;
     }
     Emitter.Create = Create;
     function On(emitter, callback) {
@@ -34,4 +37,11 @@ var Emitter;
         emitter.splice(0);
     }
     Emitter.Clear = Clear;
+    function Sort(emitters) {
+        return emitters.sort(Compare);
+    }
+    Emitter.Sort = Sort;
+    function Compare(a, b) {
+        return a._id - b._id;
+    }
 })(Emitter || (exports.Emitter = Emitter = {}));

package/Utils/list.js

@@ -5,13 +5,25 @@ var List;
 (function (List) {
     let maxTempListSize = 0;
     let trimScheduled = false;
-    let idleCallback;
     const tempList = Create();
     function CreateNode(data) {
         const node = PopNode(tempList) ?? { previous: null, next: null, data: null };
         node.data = data;
         return node;
     }
+    function TrimTempList() {
+        trimScheduled = false;
+        if (maxTempListSize < tempList.size)
+            maxTempListSize = tempList.size;
+        const trimSize = Math.floor(maxTempListSize / 10);
+        Split(tempList, trimSize);
+    }
+    function ScheduleTrimTempList() {
+        if (!trimScheduled) {
+            trimScheduled = true;
+            requestIdleCallback(TrimTempList);
+        }
+    }
     function ReturnNode(node) {
         if (!node)
             return;
@@ -21,22 +33,6 @@ var List;
         AddNode(tempList, node);
         ScheduleTrimTempList();
     }
-    function ScheduleTrimTempList() {
-        if (!trimScheduled) {
-            trimScheduled = true;
-            setTimeout(function () {
-                trimScheduled = false;
-                cancelIdleCallback(idleCallback);
-                idleCallback = requestIdleCallback(TrimTempList);
-            });
-        }
-    }
-    function TrimTempList() {
-        if (maxTempListSize < tempList.size)
-            maxTempListSize = tempList.size;
-        const trimSize = Math.floor(maxTempListSize / 10);
-        Split(tempList, trimSize);
-    }
     function Create() {
         return {
             head: null,
@@ -235,15 +231,13 @@ var List;
     List.Append = Append;
     function ToNodeMap(list, keyCallback) {
         const map = new Map();
-        let node = list.head;
-        while (node) {
+        for (let node = list.head; node !== null; node = node.next) {
             const key = keyCallback(node.data);
-            const nodes = map.get(key) || [node];
-            if (nodes[0] !== node)
-                nodes.push(node);
+            const nodes = map.get(key);
+            if (nodes === undefined)
+                map.set(key, [node]);
             else
-                map.set(key, nodes);
-            node = node.next;
+                nodes[nodes.length] = node;
         }
         return map;
     }

package/index.d.ts

@@ -1,2 +1,3 @@
 export { NodeRefTypes } from "./Node/nodeRef.types";
 export { Component } from "./Node/component";
+export { CalcScope as calc } from './Store/Tree/observableScope';

package/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Component = void 0;
+exports.calc = exports.Component = void 0;
 var component_1 = require("./Node/component");
 Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return component_1.Component; } });
+var observableScope_1 = require("./Store/Tree/observableScope");
+Object.defineProperty(exports, "calc", { enumerable: true, get: function () { return observableScope_1.CalcScope; } });