j-templates 5.0.46 → 5.0.48

package/Node/nodeRef.js

@@ -1,157 +1,182 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeRef = exports.NodeRefType = void 0;
-const nodeConfig_1 = require("./nodeConfig");
-const injector_1 = require("../Utils/injector");
-const boundNode_1 = require("./boundNode");
-const elementNode_1 = require("./elementNode");
-const componentNode_1 = require("./componentNode");
-var NodeRefType;
-(function (NodeRefType) {
-    NodeRefType[NodeRefType["NodeRef"] = 0] = "NodeRef";
-    NodeRefType[NodeRefType["BoundNode"] = 1] = "BoundNode";
-    NodeRefType[NodeRefType["ElementNode"] = 2] = "ElementNode";
-    NodeRefType[NodeRefType["ComponentNode"] = 3] = "ComponentNode";
-})(NodeRefType = exports.NodeRefType || (exports.NodeRefType = {}));
-var NodeRef;
-(function (NodeRef) {
-    function Wrap(node) {
-        var nodeRef = Create(null, null, NodeRefType.NodeRef);
-        nodeRef.node = node;
-        nodeRef.childNodes = new Set();
-        return nodeRef;
-    }
-    NodeRef.Wrap = Wrap;
-    function Create(nodeType, namespace, type) {
-        switch (type) {
-            case NodeRefType.NodeRef:
-                return {
-                    node: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.NodeRef,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    destroyables: []
-                };
-            case NodeRefType.BoundNode:
-                return {
-                    node: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.BoundNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    destroyables: [],
-                    lastProperties: null,
-                    lastEvents: null,
-                    setProperties: false,
-                    setAttributes: false,
-                    setEvents: false
-                };
-            case NodeRefType.ElementNode:
-                return {
-                    node: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.ElementNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    destroyables: [],
-                    lastProperties: null,
-                    lastEvents: null,
-                    setProperties: false,
-                    setAttributes: false,
-                    setEvents: false,
-                    childrenFunc: null,
-                    nodesMap: null,
-                    setData: false
-                };
-            case NodeRefType.ComponentNode:
-                return {
-                    node: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.ComponentNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    destroyables: [],
-                    lastProperties: null,
-                    lastEvents: null,
-                    setProperties: false,
-                    setAttributes: false,
-                    setEvents: false,
-                    component: null,
-                    componentEvents: null
-                };
-        }
-    }
-    NodeRef.Create = Create;
-    function Init(nodeRef) {
-        if (nodeRef.node)
-            return;
-        nodeRef.node = nodeConfig_1.NodeConfig.createNode(nodeRef.nodeType, nodeRef.nodeNamespace);
-        nodeRef.childNodes = new Set();
-        switch (nodeRef.type) {
-            case NodeRefType.BoundNode:
-                boundNode_1.BoundNode.Init(nodeRef);
-                break;
-            case NodeRefType.ElementNode:
-                elementNode_1.ElementNode.Init(nodeRef);
-                break;
-            case NodeRefType.ComponentNode:
-                componentNode_1.ComponentNode.Init(nodeRef);
-                break;
-        }
-    }
-    NodeRef.Init = Init;
-    function InitAll(nodeRefs) {
-        for (var x = 0; x < nodeRefs.length; x++)
-            Init(nodeRefs[x]);
-    }
-    NodeRef.InitAll = InitAll;
-    function AddChild(node, child) {
-        child.parent = node;
-        node.childNodes.add(child);
-        nodeConfig_1.NodeConfig.addChild(node.node, child.node);
-    }
-    NodeRef.AddChild = AddChild;
-    function AddChildAfter(node, currentChild, newChild) {
-        if (currentChild && !node.childNodes.has(currentChild))
-            throw "currentChild is not valid";
-        newChild.parent = node;
-        node.childNodes.add(newChild);
-        nodeConfig_1.NodeConfig.addChildAfter(node.node, currentChild && currentChild.node, newChild.node);
-    }
-    NodeRef.AddChildAfter = AddChildAfter;
-    function DetachChild(node, child) {
-        if (node.childNodes.has(child)) {
-            node.childNodes.delete(child);
-            nodeConfig_1.NodeConfig.removeChild(node.node, child.node);
-            child.parent = null;
-        }
-    }
-    NodeRef.DetachChild = DetachChild;
-    function Destroy(node) {
-        if (node.destroyed)
-            return;
-        node.destroyed = true;
-        node.childNodes.forEach(Destroy);
-        for (let x = 0; x < node.destroyables.length; x++)
-            node.destroyables[x]?.Destroy();
-    }
-    NodeRef.Destroy = Destroy;
-    function DestroyAll(nodes) {
-        for (var x = 0; x < nodes.length; x++)
-            Destroy(nodes[x]);
-    }
-    NodeRef.DestroyAll = DestroyAll;
-})(NodeRef = exports.NodeRef || (exports.NodeRef = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeRef = exports.NodeRefType = void 0;
+const nodeConfig_1 = require("./nodeConfig");
+const injector_1 = require("../Utils/injector");
+const boundNode_1 = require("./boundNode");
+const elementNode_1 = require("./elementNode");
+const componentNode_1 = require("./componentNode");
+var NodeRefType;
+(function (NodeRefType) {
+    NodeRefType[NodeRefType["NodeRef"] = 0] = "NodeRef";
+    NodeRefType[NodeRefType["BoundNode"] = 1] = "BoundNode";
+    NodeRefType[NodeRefType["ElementNode"] = 2] = "ElementNode";
+    NodeRefType[NodeRefType["ComponentNode"] = 3] = "ComponentNode";
+})(NodeRefType || (exports.NodeRefType = NodeRefType = {}));
+var NodeRef;
+(function (NodeRef) {
+    function Wrap(node) {
+        var nodeRef = Create(null, null, NodeRefType.NodeRef);
+        nodeRef.node = node;
+        nodeRef.childNodes = new Set();
+        return nodeRef;
+    }
+    NodeRef.Wrap = Wrap;
+    function Create(nodeType, namespace, type) {
+        switch (type) {
+            case NodeRefType.NodeRef:
+                return {
+                    node: null,
+                    nodeType: nodeType,
+                    nodeNamespace: namespace,
+                    type: NodeRefType.NodeRef,
+                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
+                    parent: null,
+                    childNodes: null,
+                    destroyed: false,
+                    destroyables: []
+                };
+            case NodeRefType.BoundNode:
+                return {
+                    node: null,
+                    nodeType: nodeType,
+                    nodeNamespace: namespace,
+                    type: NodeRefType.BoundNode,
+                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
+                    parent: null,
+                    childNodes: null,
+                    destroyed: false,
+                    destroyables: [],
+                    lastProperties: null,
+                    lastEvents: null,
+                    setProperties: false,
+                    setAttributes: false,
+                    setEvents: false
+                };
+            case NodeRefType.ElementNode:
+                return {
+                    node: null,
+                    nodeType: nodeType,
+                    nodeNamespace: namespace,
+                    type: NodeRefType.ElementNode,
+                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
+                    parent: null,
+                    childNodes: null,
+                    destroyed: false,
+                    destroyables: [],
+                    lastProperties: null,
+                    lastEvents: null,
+                    setProperties: false,
+                    setAttributes: false,
+                    setEvents: false,
+                    childrenFunc: null,
+                    nodeList: null,
+                    setData: false
+                };
+            case NodeRefType.ComponentNode:
+                return {
+                    node: null,
+                    nodeType: nodeType,
+                    nodeNamespace: namespace,
+                    type: NodeRefType.ComponentNode,
+                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
+                    parent: null,
+                    childNodes: null,
+                    destroyed: false,
+                    destroyables: [],
+                    lastProperties: null,
+                    lastEvents: null,
+                    setProperties: false,
+                    setAttributes: false,
+                    setEvents: false,
+                    component: null,
+                    componentEvents: null
+                };
+        }
+    }
+    NodeRef.Create = Create;
+    function Init(nodeRef) {
+        if (nodeRef.node)
+            return;
+        nodeRef.node = nodeConfig_1.NodeConfig.createNode(nodeRef.nodeType, nodeRef.nodeNamespace);
+        nodeRef.childNodes = new Set();
+        switch (nodeRef.type) {
+            case NodeRefType.BoundNode:
+                boundNode_1.BoundNode.Init(nodeRef);
+                break;
+            case NodeRefType.ElementNode:
+                elementNode_1.ElementNode.Init(nodeRef);
+                break;
+            case NodeRefType.ComponentNode:
+                componentNode_1.ComponentNode.Init(nodeRef);
+                break;
+        }
+    }
+    NodeRef.Init = Init;
+    function InitAll(nodeRefs) {
+        for (var x = 0; x < nodeRefs.length; x++)
+            Init(nodeRefs[x]);
+    }
+    NodeRef.InitAll = InitAll;
+    function AddChild(node, child) {
+        child.parent = node;
+        node.childNodes.add(child);
+        nodeConfig_1.NodeConfig.addChild(node.node, child.node);
+    }
+    NodeRef.AddChild = AddChild;
+    function AddChildAfter(node, currentChild, newChild) {
+        if (currentChild && currentChild.parent !== node)
+            throw "currentChild is not valid";
+        newChild.parent = node;
+        node.childNodes.add(newChild);
+        nodeConfig_1.NodeConfig.addChildAfter(node.node, currentChild && currentChild.node, newChild.node);
+    }
+    NodeRef.AddChildAfter = AddChildAfter;
+    function ReconcileChildren(node, nextChildren) {
+        const rootNode = node.node;
+        if (nextChildren.size === 0) {
+            nodeConfig_1.NodeConfig.replaceChildren(rootNode, []);
+            return;
+        }
+        let priorNode;
+        let curDataNode = nextChildren?.head;
+        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);
+                const expectedNode = curDataNode.data.nodes[x].node;
+                if (actualNode !== expectedNode) {
+                    nodeConfig_1.NodeConfig.addChildBefore(rootNode, actualNode, expectedNode);
+                }
+                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);
+        }
+    }
+    NodeRef.ReconcileChildren = ReconcileChildren;
+    function DetachChild(node, child) {
+        if (node.childNodes.delete(child)) {
+            nodeConfig_1.NodeConfig.removeChild(node.node, child.node);
+            child.parent = null;
+        }
+    }
+    NodeRef.DetachChild = DetachChild;
+    function Destroy(node) {
+        if (node.destroyed)
+            return;
+        node.destroyed = true;
+        node.childNodes?.forEach(Destroy);
+        for (let x = 0; x < node.destroyables.length; x++)
+            node.destroyables[x]?.Destroy();
+    }
+    NodeRef.Destroy = Destroy;
+    function DestroyAll(nodes) {
+        for (var x = 0; x < nodes.length; x++)
+            Destroy(nodes[x]);
+    }
+    NodeRef.DestroyAll = DestroyAll;
+})(NodeRef || (exports.NodeRef = NodeRef = {}));

package/Node/nodeRef.types.d.ts

@@ -1,21 +1,21 @@
-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";
-import { NodeRefType } from "./nodeRef";
-export interface INodeRefBase {
-    type: NodeRefType;
-    node: any;
-    nodeType: any;
-    nodeNamespace: string;
-    injector: Injector;
-    parent: INodeRefBase;
-    childNodes: 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>;
+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";
+import { NodeRefType } from "./nodeRef";
+export interface INodeRefBase {
+    type: NodeRefType;
+    node: any;
+    nodeType: any;
+    nodeNamespace: string;
+    injector: Injector;
+    parent: INodeRefBase;
+    childNodes: 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>;

package/Node/nodeRef.types.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/Store/Diff/diffAsync.d.ts

@@ -1,17 +1,17 @@
-import { IDiffResponse } from "./diffTree";
-export declare class DiffAsync {
-    private workerQueue;
-    constructor(keyFunc?: {
-        (val: any): string;
-    });
-    static GetKeyRef(key: string): string;
-    static ReadKeyRef(ref: string): string;
-    DiffPath(path: string, value: any): Promise<IDiffResponse>;
-    DiffBatch(data: Array<{
-        path: string;
-        value: any;
-    }>): Promise<IDiffResponse>;
-    UpdatePath(path: string, value: any): Promise<void>;
-    GetPath(path: string): Promise<any>;
-    Destroy(): void;
-}
+import { IDiffResponse } from "./diffTree";
+export declare class DiffAsync {
+    private workerQueue;
+    constructor(keyFunc?: {
+        (val: any): string;
+    });
+    static GetKeyRef(key: string): string;
+    static ReadKeyRef(ref: string): string;
+    DiffPath(path: string, value: any): Promise<IDiffResponse>;
+    DiffBatch(data: Array<{
+        path: string;
+        value: any;
+    }>): Promise<IDiffResponse>;
+    UpdatePath(path: string, value: any): Promise<void>;
+    GetPath(path: string): Promise<any>;
+    Destroy(): void;
+}

package/Store/Diff/diffAsync.js

@@ -1,36 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffAsync = void 0;
-const diffTree_1 = require("./diffTree");
-const workerQueue_1 = require("./workerQueue");
-const diffWorker_1 = require("./diffWorker");
-const diffCnstr = (0, diffTree_1.DiffTreeScope)();
-class DiffAsync {
-    workerQueue;
-    constructor(keyFunc) {
-        this.workerQueue = new workerQueue_1.WorkerQueue(diffWorker_1.DiffWorker.Create());
-        this.workerQueue.Push({ method: "create", arguments: [keyFunc.toString()] });
-    }
-    static GetKeyRef(key) {
-        return diffCnstr.GetKeyRef(key);
-    }
-    static ReadKeyRef(ref) {
-        return diffCnstr.ReadKeyRef(ref);
-    }
-    async DiffPath(path, value) {
-        return await this.workerQueue.Push({ method: "diffpath", arguments: [path, value] });
-    }
-    async DiffBatch(data) {
-        return await this.workerQueue.Push({ method: "diffbatch", arguments: [data] });
-    }
-    async UpdatePath(path, value) {
-        await this.workerQueue.Push({ method: "updatepath", arguments: [path, value] });
-    }
-    async GetPath(path) {
-        return await this.workerQueue.Push({ method: "getpath", arguments: [path] });
-    }
-    Destroy() {
-        this.workerQueue.Destroy();
-    }
-}
-exports.DiffAsync = DiffAsync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffAsync = void 0;
+const diffTree_1 = require("./diffTree");
+const workerQueue_1 = require("./workerQueue");
+const diffWorker_1 = require("./diffWorker");
+const diffCnstr = (0, diffTree_1.DiffTreeScope)();
+class DiffAsync {
+    workerQueue;
+    constructor(keyFunc) {
+        this.workerQueue = new workerQueue_1.WorkerQueue(diffWorker_1.DiffWorker.Create());
+        this.workerQueue.Push({ method: "create", arguments: [keyFunc.toString()] });
+    }
+    static GetKeyRef(key) {
+        return diffCnstr.GetKeyRef(key);
+    }
+    static ReadKeyRef(ref) {
+        return diffCnstr.ReadKeyRef(ref);
+    }
+    async DiffPath(path, value) {
+        return await this.workerQueue.Push({ method: "diffpath", arguments: [path, value] });
+    }
+    async DiffBatch(data) {
+        return await this.workerQueue.Push({ method: "diffbatch", arguments: [data] });
+    }
+    async UpdatePath(path, value) {
+        await this.workerQueue.Push({ method: "updatepath", arguments: [path, value] });
+    }
+    async GetPath(path) {
+        return await this.workerQueue.Push({ method: "getpath", arguments: [path] });
+    }
+    Destroy() {
+        this.workerQueue.Destroy();
+    }
+}
+exports.DiffAsync = DiffAsync;

package/Store/Diff/diffSync.d.ts

@@ -1,14 +1,14 @@
-export declare class DiffSync {
-    private diffTree;
-    constructor(keyFunc?: {
-        (val: any): string;
-    });
-    static GetKeyRef(key: string): string;
-    static ReadKeyRef(ref: string): string;
-    DiffPath(path: string, value: any): import("./diffTree").IDiffResponse;
-    DiffBatch(data: Array<{
-        path: string;
-        value: any;
-    }>): import("./diffTree").IDiffResponse;
-    UpdatePath(path: string, value: any): void;
-}
+export declare class DiffSync {
+    private diffTree;
+    constructor(keyFunc?: {
+        (val: any): string;
+    });
+    static GetKeyRef(key: string): string;
+    static ReadKeyRef(ref: string): string;
+    DiffPath(path: string, value: any): import("./diffTree").IDiffResponse;
+    DiffBatch(data: Array<{
+        path: string;
+        value: any;
+    }>): import("./diffTree").IDiffResponse;
+    UpdatePath(path: string, value: any): void;
+}

package/Store/Diff/diffSync.js

@@ -1,27 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffSync = void 0;
-const diffTree_1 = require("./diffTree");
-const diffCnstr = (0, diffTree_1.DiffTreeScope)();
-class DiffSync {
-    diffTree;
-    constructor(keyFunc) {
-        this.diffTree = new diffCnstr(keyFunc);
-    }
-    static GetKeyRef(key) {
-        return diffCnstr.GetKeyRef(key);
-    }
-    static ReadKeyRef(ref) {
-        return diffCnstr.ReadKeyRef(ref);
-    }
-    DiffPath(path, value) {
-        return this.diffTree.DiffPath(path, value);
-    }
-    DiffBatch(data) {
-        return this.diffTree.DiffBatch(data);
-    }
-    UpdatePath(path, value) {
-        this.diffTree.UpdatePath(path, value);
-    }
-}
-exports.DiffSync = DiffSync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffSync = void 0;
+const diffTree_1 = require("./diffTree");
+const diffCnstr = (0, diffTree_1.DiffTreeScope)();
+class DiffSync {
+    diffTree;
+    constructor(keyFunc) {
+        this.diffTree = new diffCnstr(keyFunc);
+    }
+    static GetKeyRef(key) {
+        return diffCnstr.GetKeyRef(key);
+    }
+    static ReadKeyRef(ref) {
+        return diffCnstr.ReadKeyRef(ref);
+    }
+    DiffPath(path, value) {
+        return this.diffTree.DiffPath(path, value);
+    }
+    DiffBatch(data) {
+        return this.diffTree.DiffBatch(data);
+    }
+    UpdatePath(path, value) {
+        this.diffTree.UpdatePath(path, value);
+    }
+}
+exports.DiffSync = DiffSync;

package/Store/Diff/diffTree.d.ts

@@ -1,24 +1,24 @@
-export interface IDiffMethod {
-    method: "create" | "diffpath" | "diffbatch" | "updatepath" | "getpath";
-    arguments: Array<any>;
-}
-export type IDiffResponse = {
-    path: string;
-    value: any;
-}[];
-export interface IDiffTree {
-    DiffBatch(data: Array<{
-        path: string;
-        value: any;
-    }>): IDiffResponse;
-    DiffPath(path: string, value: any): IDiffResponse;
-    UpdatePath(path: string, value: any): void;
-}
-export interface IDiffTreeConstructor {
-    new (keyFunc?: {
-        (val: any): string;
-    }): IDiffTree;
-    GetKeyRef(key: string): string;
-    ReadKeyRef(ref: string): string;
-}
-export declare function DiffTreeScope(worker?: boolean): IDiffTreeConstructor;
+export interface IDiffMethod {
+    method: "create" | "diffpath" | "diffbatch" | "updatepath" | "getpath";
+    arguments: Array<any>;
+}
+export type IDiffResponse = {
+    path: string;
+    value: any;
+}[];
+export interface IDiffTree {
+    DiffBatch(data: Array<{
+        path: string;
+        value: any;
+    }>): IDiffResponse;
+    DiffPath(path: string, value: any): IDiffResponse;
+    UpdatePath(path: string, value: any): void;
+}
+export interface IDiffTreeConstructor {
+    new (keyFunc?: {
+        (val: any): string;
+    }): IDiffTree;
+    GetKeyRef(key: string): string;
+    ReadKeyRef(ref: string): string;
+}
+export declare function DiffTreeScope(worker?: boolean): IDiffTreeConstructor;