j-templates 6.1.12 → 7.0.1

package/Node/nodeRef.d.ts

@@ -1,26 +0,0 @@
-import { INodeRef, ElementNodeRefTypes, AllNodeRefTypes } from "./nodeRef.types";
-import { IBoundNode } from "./boundNode.types";
-import { IElementDataNode, IElementNode } from "./elementNode.types";
-import { IComponentNode } from "./componentNode.types";
-import { IList } from "../Utils/list";
-import { ITextNode } from "./textNode.types";
-export declare enum NodeRefType {
-    NodeRef = 0,
-    BoundNode = 1,
-    ElementNode = 2,
-    ComponentNode = 3,
-    TextNode = 4
-}
-export declare namespace NodeRef {
-    function Wrap(node: any): INodeRef;
-    function Create(nodeType: any, namespace: string, type: NodeRefType): INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any> | ITextNode;
-    function Init(nodeRef: AllNodeRefTypes): void;
-    function InitAll(parentNode: ElementNodeRefTypes, nodeRefs: Array<AllNodeRefTypes>): void;
-    function AddChild(node: ElementNodeRefTypes, child: AllNodeRefTypes): void;
-    function AddChildAfter(node: ElementNodeRefTypes, currentChild: AllNodeRefTypes, newChild: AllNodeRefTypes): void;
-    function AddChildBefore(node: ElementNodeRefTypes, currentChild: AllNodeRefTypes, newChild: AllNodeRefTypes): void;
-    function ReconcileChildren(node: ElementNodeRefTypes, nextChildren: IList<IElementDataNode<unknown>>): void;
-    function DetachChild(node: ElementNodeRefTypes, child: AllNodeRefTypes): void;
-    function Destroy(node: AllNodeRefTypes): void;
-    function DestroyAll(nodes: Array<AllNodeRefTypes>): void;
-}

package/Node/nodeRef.js

@@ -1,253 +0,0 @@
-"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");
-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";
-    NodeRefType[NodeRefType["BoundNode"] = 1] = "BoundNode";
-    NodeRefType[NodeRefType["ElementNode"] = 2] = "ElementNode";
-    NodeRefType[NodeRefType["ComponentNode"] = 3] = "ComponentNode";
-    NodeRefType[NodeRefType["TextNode"] = 4] = "TextNode";
-})(NodeRefType || (exports.NodeRefType = NodeRefType = {}));
-var NodeRef;
-(function (NodeRef) {
-    function Wrap(node) {
-        const nodeRef = Create(null, null, NodeRefType.BoundNode);
-        nodeRef.node = node;
-        nodeRef.childNodes = [];
-        return nodeRef;
-    }
-    NodeRef.Wrap = Wrap;
-    function Create(nodeType, namespace, type) {
-        switch (type) {
-            case NodeRefType.TextNode:
-                return {
-                    type: NodeRefType.TextNode,
-                    parent: null,
-                    node: null,
-                    value: nodeType
-                };
-            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
-                };
-            case NodeRefType.BoundNode:
-                return {
-                    node: null,
-                    nodeDef: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.BoundNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    lastEvents: null,
-                    setProperties: false,
-                    assignProperties: null,
-                    assignEvents: null,
-                    assignText: null,
-                    setAttributes: false,
-                    setEvents: false,
-                    setText: false,
-                    scopes: null
-                };
-            case NodeRefType.ElementNode:
-                return {
-                    node: null,
-                    nodeDef: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.ElementNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    lastEvents: null,
-                    setProperties: false,
-                    assignProperties: null,
-                    assignEvents: null,
-                    assignText: null,
-                    setAttributes: false,
-                    setEvents: false,
-                    children: null,
-                    childrenArray: null,
-                    nodeList: null,
-                    setData: false,
-                    setText: false,
-                    scopes: null,
-                    destroyNodeList: list_1.List.Create()
-                };
-            case NodeRefType.ComponentNode:
-                return {
-                    node: null,
-                    nodeDef: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.ComponentNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    setProperties: false,
-                    assignProperties: null,
-                    assignEvents: null,
-                    setAttributes: false,
-                    setEvents: false,
-                    component: null,
-                    componentEvents: null,
-                    scopes: null
-                };
-        }
-    }
-    NodeRef.Create = Create;
-    function Init(nodeRef) {
-        if (nodeRef.type === NodeRefType.TextNode || nodeRef.node)
-            return;
-        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);
-                break;
-            case NodeRefType.ElementNode:
-                elementNode_1.ElementNode.Init(nodeRef);
-                break;
-            case NodeRefType.ComponentNode:
-                componentNode_1.ComponentNode.Init(nodeRef);
-                break;
-        }
-    }
-    NodeRef.Init = Init;
-    function AddChildToNode(parentNode, child) {
-        switch (parentNode.type) {
-            case NodeRefType.ElementNode:
-                parentNode.childNodes.add(child);
-                break;
-            case NodeRefType.ComponentNode:
-            case NodeRefType.BoundNode:
-                parentNode.childNodes.push(child);
-                break;
-            default:
-                throw "Unable to add child node to node";
-        }
-    }
-    function InitAll(parentNode, nodeRefs) {
-        for (var x = 0; x < nodeRefs.length; x++) {
-            nodeRefs[x].parent = parentNode;
-            AddChildToNode(parentNode, nodeRefs[x]);
-            Init(nodeRefs[x]);
-        }
-    }
-    NodeRef.InitAll = InitAll;
-    function AddChild(node, child) {
-        child.parent = node;
-        AddChildToNode(node, 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;
-        AddChildToNode(node, newChild);
-        nodeConfig_1.NodeConfig.addChildAfter(node.node, currentChild && currentChild.node, newChild.node);
-    }
-    NodeRef.AddChildAfter = AddChildAfter;
-    function AddChildBefore(node, currentChild, newChild) {
-        if (currentChild && currentChild.parent !== node)
-            throw "currentChild is not valid";
-        newChild.parent = node;
-        AddChildToNode(node, newChild);
-        nodeConfig_1.NodeConfig.addChildBefore(node.node, currentChild && currentChild.node, newChild.node);
-    }
-    NodeRef.AddChildBefore = AddChildBefore;
-    function ReconcileChildren(node, nextChildren) {
-        const rootNode = node.node;
-        if (nextChildren.size === 0) {
-            nodeConfig_1.NodeConfig.replaceChildren(rootNode, []);
-            return;
-        }
-        let priorNode;
-        let insert = false;
-        let remove = false;
-        for (let curDataNode = nextChildren.head; curDataNode !== null; curDataNode = curDataNode.next) {
-            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);
-                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);
-                }
-                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;
-            }
-        }
-        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.type === NodeRefType.ElementNode && node.childNodes.delete(child))
-            child.parent = null;
-    }
-    NodeRef.DetachChild = DetachChild;
-    function Destroy(node) {
-        if (node.type === NodeRefType.TextNode || node.destroyed)
-            return;
-        node.destroyed = true;
-        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.BoundNode:
-                node.assignEvents?.(null);
-            case NodeRefType.ElementNode:
-                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 (let x = 0; x < nodes.length; x++)
-            Destroy(nodes[x]);
-    }
-    NodeRef.DestroyAll = DestroyAll;
-})(NodeRef || (exports.NodeRef = NodeRef = {}));

package/Node/nodeRef.types.d.ts

@@ -1,21 +0,0 @@
-import { Injector } from "../Utils/injector";
-import { IBoundNode } from "./boundNode.types";
-import { IComponentNode } from "./componentNode.types";
-import { IElementNode } from "./elementNode.types";
-import { NodeRefType } from "./nodeRef";
-import { ITextNode } from "./textNode.types";
-export interface INodeRefBase {
-    type: NodeRefType;
-    node: any;
-    nodeType: any;
-    nodeNamespace: string;
-    injector: Injector;
-    parent: INodeRefBase;
-    childNodes: AllNodeRefTypes[] | Set<AllNodeRefTypes>;
-    destroyed: boolean;
-}
-export interface INodeRef extends INodeRefBase {
-    type: NodeRefType.NodeRef;
-}
-export type ElementNodeRefTypes = INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any>;
-export type AllNodeRefTypes = ElementNodeRefTypes | ITextNode;

package/Node/nodeRef.types.js

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

package/Node/textNode.types.d.ts

@@ -1,7 +0,0 @@
-import { NodeRefType } from "./nodeRef";
-export interface ITextNode {
-    type: NodeRefType.TextNode;
-    parent: any;
-    node: any;
-    value: string;
-}

package/Node/textNode.types.js

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