j-templates 6.1.11 → 6.1.12

package/DOM/domNodeConfig.js

@@ -58,7 +58,7 @@ exports.DOMNodeConfig = {
         return window_1.wndw.document.createTextNode(value);
     },
     isTextNode(target) {
-        return target.nodeType === Node.TEXT_NODE;
+        return target?.nodeType === Node.TEXT_NODE;
     },
     scheduleUpdate,
     wrapPriorityUpdates,

package/Node/nodeRef.js

@@ -8,6 +8,7 @@ const elementNode_1 = require("./elementNode");
 const componentNode_1 = require("./componentNode");
 const list_1 = require("../Utils/list");
 const Store_1 = require("../Store");
+const domNodeConfig_1 = require("../DOM/domNodeConfig");
 var NodeRefType;
 (function (NodeRefType) {
     NodeRefType[NodeRefType["NodeRef"] = 0] = "NodeRef";
@@ -116,10 +117,10 @@ var NodeRef;
     }
     NodeRef.Create = Create;
     function Init(nodeRef) {
-        if (nodeRef.node || nodeRef.type === NodeRefType.TextNode)
+        if (nodeRef.type === NodeRefType.TextNode || nodeRef.node)
             return;
-        nodeRef.node = nodeRef.nodeType === 'text' ? nodeConfig_1.NodeConfig.createTextNode() : nodeConfig_1.NodeConfig.createNode(nodeRef.nodeType, nodeRef.nodeNamespace);
-        nodeRef.childNodes = nodeRef.nodeType !== 'text' ? [] : null;
+        nodeRef.node = nodeConfig_1.NodeConfig.createNode(nodeRef.nodeType, nodeRef.nodeNamespace);
+        nodeRef.childNodes = nodeRef.nodeType !== NodeRefType.TextNode ? [] : null;
         switch (nodeRef.type) {
             case NodeRefType.BoundNode:
                 boundNode_1.BoundNode.Init(nodeRef);
@@ -189,15 +190,15 @@ var NodeRef;
             for (let x = 0; x < curDataNode.data.nodes.length; x++) {
                 const virtualNode = curDataNode.data.nodes[x];
                 const actualNode = priorNode ? nodeConfig_1.NodeConfig.getNextSibling(priorNode) : nodeConfig_1.NodeConfig.getFirstChild(rootNode);
-                let expectedNode;
-                if (virtualNode.type === NodeRefType.TextNode && actualNode !== null && nodeConfig_1.NodeConfig.isTextNode(actualNode)) {
-                    nodeConfig_1.NodeConfig.setText(actualNode, virtualNode.value);
-                    virtualNode.node = expectedNode = actualNode;
+                if (virtualNode.type === NodeRefType.TextNode && virtualNode.node === null) {
+                    if (domNodeConfig_1.DOMNodeConfig.isTextNode(actualNode)) {
+                        domNodeConfig_1.DOMNodeConfig.setText(actualNode, virtualNode.value);
+                        virtualNode.node = actualNode;
+                    }
+                    else
+                        virtualNode.node = domNodeConfig_1.DOMNodeConfig.createTextNode(virtualNode.value);
                 }
-                else if (virtualNode.type === NodeRefType.TextNode)
-                    expectedNode = nodeConfig_1.NodeConfig.createTextNode(virtualNode.value);
-                else
-                    expectedNode = virtualNode.node;
+                const expectedNode = virtualNode.node;
                 if (actualNode !== expectedNode) {
                     nodeConfig_1.NodeConfig.addChildBefore(rootNode, actualNode, expectedNode);
                     !remove && insert && actualNode && nodeConfig_1.NodeConfig.removeChild(rootNode, actualNode);

package/Store/Tree/observableScope.d.ts

@@ -41,11 +41,9 @@ export interface IObservableScope<T> extends IDestroyable {
     dirty: boolean;
     emitter: Emitter;
     emitters: (Emitter | null)[];
-    calcFunctions: ICalcFunction<any>[] | null;
+    calcFunctions: ICalcFunction<any>[];
     onDestroyed: Emitter | null;
     destroyed: boolean;
-    watchEmitters: Emitter[] | null;
-    watchEmittersSet: Set<Emitter> | null;
 }
 export declare function CalcScope<T>(callback: () => T): T;
 export declare namespace ObservableScope {
@@ -55,7 +53,6 @@ export declare namespace ObservableScope {
     function Register(emitter: Emitter): void;
     function Init<T>(scope: IObservableScope<T>): void;
     function Value<T>(scope: IObservableScope<T>): T;
-    function Watching(): boolean;
     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;

package/Store/Tree/observableScope.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = exports.ObservableScopeWrapper = exports.ObservableScopeValue = void 0;
 exports.CalcScope = CalcScope;
 const array_1 = require("../../Utils/array");
+const avlTree_1 = require("../../Utils/avlTree");
 const emitter_1 = require("../../Utils/emitter");
-const list_1 = require("../../Utils/list");
 class ObservableScopeValue {
     get Value() {
         return ObservableScope.Value(this.scope);
@@ -48,28 +48,22 @@ class ObservableScope extends ObservableScopeWrapper {
     }
 }
 exports.ObservableScope = ObservableScope;
-let watchingScope = null;
-let currentlyWatching = false;
+let watchState = null;
 function WatchScope(scope) {
-    const parentScope = watchingScope;
-    const parentWatching = currentlyWatching;
-    watchingScope = scope;
-    currentlyWatching = true;
+    const parent = watchState;
+    watchState = [avlTree_1.AVL.Create(emitter_1.Emitter.Compare), []];
     const value = scope.getFunction();
-    watchingScope.watchEmittersSet = null;
-    watchingScope = parentScope;
-    currentlyWatching = parentWatching;
-    return value;
+    const result = [value, avlTree_1.AVL.ToArray(watchState[0]), watchState[1]];
+    watchState = parent;
+    return result;
 }
 function CalcScope(callback) {
     const value = callback();
-    if (currentlyWatching) {
-        watchingScope.calcFunctions ??= [];
-        watchingScope.calcFunctions.push({
+    if (watchState !== null)
+        watchState[1].push({
             getFunction: callback,
             value
         });
-    }
     return value;
 }
 (function (ObservableScope) {
@@ -82,11 +76,9 @@ function CalcScope(callback) {
             dirty: true,
             emitter: emitter_1.Emitter.Create(),
             emitters: [],
-            calcFunctions: null,
+            calcFunctions: [],
             onDestroyed: null,
             destroyed: false,
-            watchEmitters: null,
-            watchEmittersSet: null,
             setCallback: function () {
                 return OnSet(scope);
             },
@@ -95,35 +87,25 @@ function CalcScope(callback) {
     }
     ObservableScope.Create = Create;
     function Register(emitter) {
-        if (!currentlyWatching)
+        if (watchState === null)
             return;
-        watchingScope.watchEmitters ??= [];
-        if (watchingScope.watchEmitters.length === 10)
-            watchingScope.watchEmittersSet ??= new Set(watchingScope.watchEmitters);
-        if (watchingScope.watchEmittersSet === null ? !watchingScope.watchEmitters.includes(emitter) : !watchingScope.watchEmittersSet.has(emitter)) {
-            watchingScope.watchEmittersSet?.add(emitter);
-            watchingScope.watchEmitters.push(emitter);
-        }
+        avlTree_1.AVL.Insert(watchState[0], emitter);
     }
     ObservableScope.Register = Register;
     function Init(scope) {
         if (!scope)
             return;
-        UpdateScope(scope);
+        UpdateValue(scope);
     }
     ObservableScope.Init = Init;
     function Value(scope) {
         if (!scope)
             return undefined;
         Register(scope.emitter);
-        UpdateScope(scope);
+        UpdateValue(scope);
         return scope.value;
     }
     ObservableScope.Value = Value;
-    function Watching() {
-        return currentlyWatching;
-    }
-    ObservableScope.Watching = Watching;
     function Touch(scope) {
         if (!scope || !scope.emitter)
             return;
@@ -148,6 +130,8 @@ function CalcScope(callback) {
     }
     ObservableScope.OnDestroyed = OnDestroyed;
     function Update(scope) {
+        if (!scope || scope.dirty || scope.destroyed)
+            return;
         OnSet(scope);
     }
     ObservableScope.Update = Update;
@@ -156,25 +140,6 @@ function CalcScope(callback) {
     }
     ObservableScope.Destroy = Destroy;
 })(ObservableScope || (exports.ObservableScope = ObservableScope = {}));
-function UpdateScope(scope) {
-    const prePromise = scope.promise;
-    UpdateValue(scope);
-    scope.async && prePromise !== scope.promise && scope.promise.then(function () {
-        emitter_1.Emitter.Emit(scope.emitter, scope);
-    });
-}
-const updateScopeQueue = list_1.List.Create();
-function ProcessScopeUpdateQueue() {
-    const processList = list_1.List.Split(updateScopeQueue, 0);
-    for (let node = processList.head; node !== null; node = node.next)
-        UpdateScope(node.data);
-    list_1.List.Clear(processList);
-}
-function QueueScopeUpdate(scope) {
-    list_1.List.Add(updateScopeQueue, scope);
-    if (updateScopeQueue.size === 1)
-        queueMicrotask(ProcessScopeUpdateQueue);
-}
 function CalcChanged(calc) {
     const value = calc.getFunction();
     const changed = calc.value !== value;
@@ -182,35 +147,48 @@ function CalcChanged(calc) {
     return changed;
 }
 function DirtyScope(scope) {
-    scope.dirty = scope.calcFunctions === null || scope.calcFunctions.some(CalcChanged);
-    scope.dirty && (scope.async ? QueueScopeUpdate(scope) : emitter_1.Emitter.Emit(scope.emitter, scope));
+    if (scope.dirty || !scope.getFunction)
+        return;
+    scope.dirty = scope.calcFunctions.length === 0 || scope.calcFunctions.some(CalcChanged);
+    scope.dirty && emitter_1.Emitter.Emit(scope.emitter, scope);
+}
+const scopeQueue = new Set();
+function ProcessScopeQueue() {
+    const scopes = Array.from(scopeQueue);
+    scopeQueue.clear();
+    for (let x = 0; x < scopes.length; x++)
+        DirtyScope(scopes[x]);
 }
 function OnSet(scope) {
-    if (!scope || scope.dirty || scope.destroyed)
-        return scope?.destroyed;
+    if (scope.destroyed)
+        return true;
+    if (scope.async || scope.calcFunctions.length > 0) {
+        if (scopeQueue.size === 0)
+            queueMicrotask(ProcessScopeQueue);
+        scopeQueue.add(scope);
+        return;
+    }
     DirtyScope(scope);
-    return false;
 }
 function UpdateValue(scope) {
     if (!scope.dirty)
         return;
     scope.dirty = false;
-    scope.watchEmitters = null;
-    scope.calcFunctions = null;
-    const value = WatchScope(scope);
+    const [value, emitters, calcFunctions] = WatchScope(scope);
     if (scope.async) {
         scope.promise = value.then(function (result) {
             scope.value = result;
+            emitter_1.Emitter.Emit(scope.emitter, scope);
             return result;
         });
     }
     else
         scope.value = value;
-    UpdateEmitters(scope);
+    scope.calcFunctions = calcFunctions;
+    UpdateEmitters(scope, emitters);
 }
-function UpdateEmitters(scope) {
-    const right = scope.watchEmitters;
-    if (right === null) {
+function UpdateEmitters(scope, right) {
+    if (right.length === 0) {
         if (scope.emitters.length > 0) {
             for (let x = 0; x < scope.emitters.length; x++)
                 emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
@@ -218,7 +196,6 @@ function UpdateEmitters(scope) {
         }
         return;
     }
-    emitter_1.Emitter.Sort(right);
     (0, array_1.ReconcileSortedArrays)(scope.emitters, right, function (emitter) {
         emitter_1.Emitter.On(emitter, scope.setCallback);
     }, function (emitter) {

package/Utils/avlTree.d.ts

@@ -0,0 +1,15 @@
+type Compare<T> = (a: T, b: T) => number;
+export interface AvlTree<T> {
+    size: number;
+    root: AvlTreeNode<T> | null;
+    compare: Compare<T>;
+}
+export type AvlTreeNode<T> = [T, number, number, AvlTreeNode<T> | null, AvlTreeNode<T> | null];
+export declare namespace AVL {
+    function Create<T>(compare: Compare<T>): AvlTree<T>;
+    function Clear(tree: AvlTree<unknown>): void;
+    function Insert<T>(tree: AvlTree<T>, value: T): void;
+    function ForEach<T>(tree: AvlTree<T>, callback: (value: T) => void): void;
+    function ToArray<T>(tree: AvlTree<T>): T[];
+}
+export {};

package/Utils/avlTree.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AVL = void 0;
+const VALUE = 0;
+const BALANCE = 1;
+const HEIGHT = 2;
+const LEFT = 3;
+const RIGHT = 4;
+function Squash(x) {
+    return x ? x < 0 ? -1 : 1 : 0;
+}
+var AVL;
+(function (AVL) {
+    function Create(compare) {
+        return CreateTree(compare);
+    }
+    AVL.Create = Create;
+    function Clear(tree) {
+        tree.root = null;
+        tree.size = 0;
+    }
+    AVL.Clear = Clear;
+    function Insert(tree, value) {
+        if (tree.size === 0) {
+            tree.root = CreateNode(value);
+            tree.size = 1;
+            return;
+        }
+        InsertValue(tree, value);
+    }
+    AVL.Insert = Insert;
+    function ForEach(tree, callback) {
+        PreOrder(tree.root, callback);
+    }
+    AVL.ForEach = ForEach;
+    function ToArray(tree) {
+        const result = new Array(tree.size);
+        let index = 0;
+        ForEach(tree, function (value) {
+            result[index++] = value;
+        });
+        return result;
+    }
+    AVL.ToArray = ToArray;
+})(AVL || (exports.AVL = AVL = {}));
+function PreOrder(node, callback) {
+    if (node === null)
+        return;
+    PreOrder(node[LEFT], callback);
+    callback(node[VALUE]);
+    PreOrder(node[RIGHT], callback);
+}
+function CreateTree(compare) {
+    return {
+        size: 0,
+        compare,
+        root: null,
+    };
+}
+function CreateNode(value) {
+    return [value, 0, 1, null, null];
+}
+function InsertValue(tree, value) {
+    const startSize = tree.size;
+    let node = tree.root;
+    let comp = 0;
+    const path = [];
+    while (node !== null) {
+        comp = Squash(tree.compare(value, node[VALUE]));
+        path.push([comp, node]);
+        switch (comp) {
+            case 0:
+                node = null;
+                break;
+            case -1:
+                node = node[LEFT] ??= (tree.size++, CreateNode(value));
+                break;
+            case 1:
+                node = node[RIGHT] ??= (tree.size++, CreateNode(value));
+                break;
+        }
+    }
+    if (tree.size === startSize)
+        return;
+    for (let x = path.length - 2; x >= 0; x--) {
+        SetHeight(path[x][1]);
+        if (Math.abs(path[x][1][BALANCE]) === 2) {
+            const newRoot = BalanceNode(path[x][1]);
+            if (x === 0)
+                tree.root = newRoot;
+            else {
+                const [comp, parent] = path[x - 1];
+                switch (comp) {
+                    case -1:
+                        parent[LEFT] = newRoot;
+                        break;
+                    case 1:
+                        parent[RIGHT] = newRoot;
+                        break;
+                }
+            }
+        }
+    }
+}
+function BalanceNode(node) {
+    if (node[BALANCE] < 0) {
+        if (node[LEFT][BALANCE] > 0)
+            node[LEFT] = RotateLeft(node[LEFT]);
+        return RotateRight(node);
+    }
+    if (node[RIGHT][BALANCE] < 0)
+        node[RIGHT] = RotateRight(node[RIGHT]);
+    return RotateLeft(node);
+}
+function RotateLeft(node) {
+    const startRightLeft = node[RIGHT][LEFT];
+    const root = node[RIGHT];
+    root[LEFT] = node;
+    node[RIGHT] = startRightLeft;
+    SetHeight(node);
+    SetHeight(root);
+    return root;
+}
+function RotateRight(node) {
+    const startLeftRight = node[LEFT][RIGHT];
+    const root = node[LEFT];
+    root[RIGHT] = node;
+    node[LEFT] = startLeftRight;
+    SetHeight(node);
+    SetHeight(root);
+    return root;
+}
+function SetHeight(node) {
+    const leftHeight = node[LEFT]?.[HEIGHT] ?? 0;
+    const rightHeight = node[RIGHT]?.[HEIGHT] ?? 0;
+    const balance = rightHeight - leftHeight;
+    const height = leftHeight > rightHeight ? leftHeight : rightHeight;
+    node[HEIGHT] = height + 1;
+    node[BALANCE] = balance;
+}

package/Utils/distinctArray.d.ts

@@ -0,0 +1,10 @@
+export type DistinctArray<T> = {
+    id: (value: T) => number;
+    distinct: T[];
+    array: T[];
+};
+export declare namespace DistinctArray {
+    function Create<T>(id: (value: T) => number): DistinctArray<T>;
+    function Push<T>({ id, distinct, array }: DistinctArray<T>, value: T): void;
+    function Get<T>({ array }: DistinctArray<T>): T[];
+}

package/Utils/distinctArray.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistinctArray = void 0;
+var DistinctArray;
+(function (DistinctArray) {
+    function Create(id) {
+        return {
+            id,
+            distinct: [],
+            array: []
+        };
+    }
+    DistinctArray.Create = Create;
+    function Push({ id, distinct, array }, value) {
+        const vId = id(value);
+        if (distinct[vId] === undefined) {
+            distinct[vId] = value;
+            array.push(value);
+        }
+    }
+    DistinctArray.Push = Push;
+    function Get({ array }) {
+        return array;
+    }
+    DistinctArray.Get = Get;
+})(DistinctArray || (exports.DistinctArray = DistinctArray = {}));

package/Utils/emitter.d.ts

@@ -2,9 +2,11 @@ export type EmitterCallback<T extends readonly any[] = any[]> = (...args: T) =>
 export type Emitter = [number, ...EmitterCallback[]];
 export declare namespace Emitter {
     function Create(): Emitter;
+    function GetId(emitter: Emitter): number;
     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[];
+    function Compare(a: Emitter, b: Emitter): number;
 }

package/Utils/emitter.js

@@ -10,6 +10,10 @@ var Emitter;
         return emitter;
     }
     Emitter.Create = Create;
+    function GetId(emitter) {
+        return emitter[0];
+    }
+    Emitter.GetId = GetId;
     function On(emitter, callback) {
         emitter.push(callback);
     }
@@ -43,4 +47,5 @@ var Emitter;
     function Compare(a, b) {
         return a[0] - b[0];
     }
+    Emitter.Compare = Compare;
 })(Emitter || (exports.Emitter = Emitter = {}));

package/package.json

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