j-templates 7.0.56 → 7.0.58

package/Node/vNode.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.vNode = void 0;
 const Store_1 = require("../Store");
+const observableScope_1 = require("../Store/Tree/observableScope");
 const emitter_1 = require("../Utils/emitter");
+const functions_1 = require("../Utils/functions");
 const injector_1 = require("../Utils/injector");
 const thread_1 = require("../Utils/thread");
 const nodeConfig_1 = require("./nodeConfig");
@@ -58,8 +60,10 @@ 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++)
+        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.Destroy = Destroy;
     function DestroyAll(vnodes) {
@@ -97,10 +101,11 @@ function InitNode(vnode) {
     if (props) {
         const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
         if (typeof props === "function") {
-            const scope = Store_1.ObservableScope.Create(props);
-            vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
-            const value = Store_1.ObservableScope.Peek(scope);
+            const [value, scope] = Store_1.ObservableScope.CreateIf(props);
+            if (scope) {
+                vnode.scopes.push(scope);
+                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
+            }
             assignProperties(value);
         }
         else
@@ -109,27 +114,24 @@ function InitNode(vnode) {
     if (on) {
         const assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
         if (typeof on === "function") {
-            const scope = Store_1.ObservableScope.Create(on);
-            vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
-            const value = Store_1.ObservableScope.Peek(scope);
+            const [value, scope] = Store_1.ObservableScope.CreateIf(on);
+            if (scope) {
+                vnode.scopes.push(scope);
+                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
+            }
             assignEvents(value);
         }
         else
             assignEvents(on);
-        vnode.onDestroyed ??= emitter_1.Emitter.Create();
-        emitter_1.Emitter.On(vnode.onDestroyed, function () {
-            assignEvents(null);
-            return true;
-        });
     }
     if (attrs) {
         const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
         if (typeof attrs === "function") {
-            const scope = Store_1.ObservableScope.Create(attrs);
-            vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
-            const value = Store_1.ObservableScope.Peek(scope);
+            const [value, scope] = Store_1.ObservableScope.CreateIf(attrs);
+            if (scope) {
+                vnode.scopes.push(scope);
+                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
+            }
             assignAttributes(value);
         }
         else
@@ -144,7 +146,7 @@ function InitNode(vnode) {
         Children(vnode, componentChildren, DefaultData);
     }
     else if (childrenArray) {
-        vnode.children = [[undefined, childrenArray]];
+        vnode.children = [[undefined, childrenArray, null]];
         vNode.InitAll(childrenArray);
     }
     else if (children) {
@@ -153,55 +155,52 @@ function InitNode(vnode) {
     UpdateChildren(vnode, true, !!childrenArray);
 }
 function Children(vnode, children, data) {
-    const childrenScope = CreateChildrenScope(vnode, children, data);
-    vnode.scopes.push(childrenScope);
-    Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
-        if (vnode.destroyed)
-            return;
-        const startChildren = vnode.children;
-        AssignChildren(vnode, scope);
-        startChildren !== vnode.children && UpdateChildren(vnode);
-    }));
-    AssignChildren(vnode, childrenScope);
+    const [childNodes, 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.children = childNodes;
+}
+function AssignChildren(vnode, childrenScope) {
+    const children = Store_1.ObservableScope.Peek(childrenScope);
+    vnode.children = children;
 }
 const DEFAULT_DATA = [undefined];
 function DefaultData() {
     return DEFAULT_DATA;
 }
-function CreateChildrenScope(vnode, children, data) {
-    let dataScope;
-    if (data !== undefined) {
-        dataScope = Store_1.ObservableScope.Create(data);
+function CreateChildrenScope(vnode, children, data = DefaultData) {
+    if ((0, functions_1.IsAsync)(data)) {
+        const asyncData = data;
         data = function () {
-            const result = Store_1.ObservableScope.Value(dataScope);
-            if (!result)
-                return [];
-            if (Array.isArray(result))
-                return result;
-            return [result];
+            return (0, observableScope_1.CalcScope)(async function () {
+                return asyncData();
+            });
         };
     }
-    else
-        data = DefaultData;
-    const scope = Store_1.ObservableScope.Create(WrapChildren(vnode.injector, children, data));
-    dataScope &&
-        Store_1.ObservableScope.OnDestroyed(scope, function () {
-            Store_1.ObservableScope.Destroy(dataScope);
-            return true;
-        });
-    return scope;
+    return Store_1.ObservableScope.CreateIf(WrapChildren(vnode.injector, children, data));
 }
 function WrapChildren(injector, children, data) {
     let nodeArray = [];
     return function () {
-        const nextData = data();
+        const nextData = ToArray(data());
         switch (nextData.length) {
             case 0: {
                 for (let x = 0; x < nodeArray.length; x++) {
                     vNode.DestroyAll(nodeArray[x][1]);
+                    Store_1.ObservableScope.Destroy(nodeArray[x][2]);
                 }
                 nodeArray.splice(0);
-                return [];
             }
             default: {
                 if (nodeArray.length < 21)
@@ -213,31 +212,55 @@ function WrapChildren(injector, children, data) {
         return nodeArray;
     };
 }
+function ToArray(result) {
+    if (!result)
+        return [];
+    if (Array.isArray(result))
+        return result;
+    return [result];
+}
 function EvaluateNextNodesSmall(injector, getNextChildren, nextData, nodeArray) {
-    if (nextData.length === 1) {
+    if (nextData === DEFAULT_DATA) {
         const nextChildren = injector_1.Injector.Scope(injector, getNextChildren, nextData[0]);
         const children = CreateNodeArray(nextChildren, nodeArray[0]?.[1]);
-        for (let x = 0; x < nodeArray.length; x++)
+        for (let x = 0; x < nodeArray.length; x++) {
             vNode.DestroyAll(nodeArray[x][1]);
-        return [[undefined, children]];
+            Store_1.ObservableScope.Destroy(nodeArray[x][2]);
+        }
+        return [
+            [undefined, children, null],
+        ];
     }
-    let nodeArrayLength = nodeArray.length;
     const nextNodes = new Array(nextData.length);
     for (let x = 0; x < nextData.length; x++) {
         const data = nextData[x];
-        const nextChildren = injector_1.Injector.Scope(injector, getNextChildren, data);
         let i = 0;
-        for (; i < nodeArrayLength && nodeArray[i][0] !== data; i++) { }
-        if (i !== nodeArrayLength) {
+        for (; i < nodeArray.length &&
+            (nodeArray[i] === null || nodeArray[i][0] !== data); i++) { }
+        if (i !== nodeArray.length) {
+            if (nodeArray[i][2]) {
+                const scope = nodeArray[i][2];
+                const value = scope.value;
+                const updatedValue = Store_1.ObservableScope.Value(scope);
+                if (value !== updatedValue)
+                    nodeArray[i][1] = CreateNodeArray(updatedValue);
+            }
             nextNodes[x] = nodeArray[i];
-            nodeArray[i] = nodeArray[nodeArray.length - 1];
-            nodeArrayLength--;
+            nodeArray[i] = null;
+        }
+        else {
+            const [nextChildren, scope] = Store_1.ObservableScope.CreateIf(function () {
+                return injector_1.Injector.Scope(injector, getNextChildren, data);
+            });
+            nextNodes[x] = [data, CreateNodeArray(nextChildren), scope];
+        }
+    }
+    for (let x = 0; x < nodeArray.length; x++) {
+        if (nodeArray[x] !== null) {
+            vNode.DestroyAll(nodeArray[x][1]);
+            Store_1.ObservableScope.Destroy(nodeArray[x][2]);
         }
-        else
-            nextNodes[x] = [data, CreateNodeArray(nextChildren)];
     }
-    for (let x = 0; x < nodeArrayLength; x++)
-        vNode.DestroyAll(nodeArray[x][1]);
     return nextNodes;
 }
 function EvaluateNextNodesLarge(injector, getNextChildren, nextData, nodeArray) {
@@ -245,29 +268,44 @@ function EvaluateNextNodesLarge(injector, getNextChildren, nextData, nodeArray)
     const dataMap = new Map();
     for (let x = 0; x < nodeArray.length; x++) {
         const arr = dataMap.get(nodeArray[x][0]) ?? [];
-        arr.push(nodeArray[x][1]);
+        arr.push(nodeArray[x]);
         dataMap.set(nodeArray[x][0], arr);
     }
     for (let x = 0; x < nextData.length; x++) {
         const data = nextData[x];
-        const nextChildren = injector_1.Injector.Scope(injector, getNextChildren, data);
         const currentChildren = dataMap.get(data);
         let currentChildIndex = currentChildren ? currentChildren.length - 1 : -1;
         for (; currentChildIndex >= 0 && currentChildren[currentChildIndex] === null; currentChildIndex--) { }
         if (currentChildIndex !== -1) {
-            nextNodes[x] = [data, currentChildren[currentChildIndex]];
+            const currentChild = currentChildren[currentChildIndex];
+            if (currentChild[2]) {
+                const scope = currentChild[2];
+                const value = scope.value;
+                const updatedValue = Store_1.ObservableScope.Value(scope);
+                if (value !== updatedValue)
+                    currentChild[1] = CreateNodeArray(updatedValue);
+            }
+            if (currentChild[2]?.dirty) {
+                const nextChildren = Store_1.ObservableScope.Value(currentChild[2]);
+                currentChild[1] = CreateNodeArray(nextChildren);
+            }
+            nextNodes[x] = currentChild;
             currentChildren[currentChildIndex] = null;
             if (currentChildIndex === 0)
                 dataMap.delete(data);
         }
         else {
-            nextNodes[x] = [data, CreateNodeArray(nextChildren)];
+            const [nextChildren, scope] = Store_1.ObservableScope.CreateIf(function () {
+                return injector_1.Injector.Scope(injector, getNextChildren, data);
+            });
+            nextNodes[x] = [data, CreateNodeArray(nextChildren), scope];
         }
     }
     for (const value of dataMap.values()) {
         for (let x = 0; x < value.length; x++) {
-            for (let y = 0; y < value[x].length; y++)
-                value[x][y] && vNode.Destroy(value[x][y]);
+            const row = value[x];
+            row && vNode.DestroyAll(row[1]);
+            row && Store_1.ObservableScope.Destroy(row[2]);
         }
     }
     return nextNodes;
@@ -289,10 +327,6 @@ function CreateNodeArray(children, previousChildren) {
     }
     return [children];
 }
-function AssignChildren(vnode, childrenScope) {
-    const children = Store_1.ObservableScope.Peek(childrenScope);
-    vnode.children = children;
-}
 function UpdateChildren(vnode, init = false, skipInit = false) {
     if (!vnode.children)
         return;

package/Node/vNode.types.d.ts

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

package/Store/Tree/observableScope.d.ts

@@ -47,6 +47,9 @@ export declare namespace ObservableScope {
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
     }, calc?: boolean): IObservableScope<T>;
+    function CreateIf<T>(valueFunction: {
+        (): T | Promise<T>;
+    }): [T, IObservableScope<T> | null];
     function Register(emitter: Emitter): void;
     function Init<T>(scope: IObservableScope<T>): void;
     function Peek<T>(scope: IObservableScope<T>): T;

package/Store/Tree/observableScope.js

@@ -65,6 +65,21 @@ function WatchScope(scope) {
     watchState = parent;
     return value;
 }
+function WatchFunction(func) {
+    const parent = watchState;
+    watchState = [[], null, null];
+    const async = (0, functions_1.IsAsync)(func);
+    const result = func();
+    let scope = null;
+    if (watchState[0].length > 0 || async) {
+        scope = ObservableScope.Create(func);
+        UpdateEmitters(scope, watchState[0]);
+        scope.calcScopes = watchState[2];
+        UpdateValue(scope, result);
+    }
+    watchState = parent;
+    return [async ? null : result, scope];
+}
 function CalcScope(callback, idOverride) {
     if (watchState === null)
         return callback();
@@ -103,6 +118,10 @@ function CalcScope(callback, idOverride) {
         return scope;
     }
     ObservableScope.Create = Create;
+    function CreateIf(valueFunction) {
+        return WatchFunction(valueFunction);
+    }
+    ObservableScope.CreateIf = CreateIf;
     function Register(emitter) {
         if (watchState === null)
             return;
@@ -205,11 +224,11 @@ function OnSet(scope) {
     }
     DirtyScope(scope);
 }
-function UpdateValue(scope) {
+function UpdateValue(scope, valueOverride = undefined) {
     if (!scope.dirty)
         return;
     scope.dirty = false;
-    const value = WatchScope(scope);
+    const value = valueOverride === undefined ? WatchScope(scope) : valueOverride;
     if (scope.async) {
         scope.promise = value.then(function (result) {
             if (scope.destroyed)

package/package.json

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