j-templates 6.1.12 → 7.0.0

package/Node/boundNode.js

@@ -1,115 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BoundNode = void 0;
-const nodeConfig_1 = require("./nodeConfig");
-const observableScope_1 = require("../Store/Tree/observableScope");
-var BoundNode;
-(function (BoundNode) {
-    function WrapEventObject(node, events) {
-        const keys = Object.keys(events);
-        const ret = {};
-        for (let x = 0; x < keys.length; x++) {
-            const event = keys[x];
-            const eventFunc = events[event];
-            ret[event] = function (event) {
-                if (node.destroyed)
-                    return;
-                return eventFunc(event);
-            };
-        }
-        return ret;
-    }
-    function Init(boundNode) {
-        const nodeDef = boundNode.nodeDef;
-        if (nodeDef.props) {
-            boundNode.assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(boundNode.node);
-            if (typeof nodeDef.props === 'function') {
-                const scope = observableScope_1.ObservableScope.Create(nodeDef.props);
-                boundNode.scopes ??= [];
-                boundNode.scopes.push(scope);
-                observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetProperties(boundNode, scope); });
-                const next = observableScope_1.ObservableScope.Value(scope);
-                boundNode.assignProperties(next);
-            }
-            else {
-                boundNode.assignProperties(nodeDef.props);
-                boundNode.assignProperties = null;
-            }
-        }
-        if (nodeDef.attrs) {
-            if (typeof nodeDef.attrs === 'function') {
-                const scope = observableScope_1.ObservableScope.Create(nodeDef.attrs);
-                boundNode.scopes ??= [];
-                boundNode.scopes.push(scope);
-                observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetAttributes(boundNode, scope); });
-                SetAttributes(boundNode, observableScope_1.ObservableScope.Value(scope));
-            }
-            else
-                SetAttributes(boundNode, nodeDef.attrs);
-        }
-        if (nodeDef.on) {
-            boundNode.assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(boundNode.node);
-            if (typeof nodeDef.on === 'function') {
-                const scope = observableScope_1.ObservableScope.Create(nodeDef.on);
-                const eventScope = observableScope_1.ObservableScope.Create(function () {
-                    const events = observableScope_1.ObservableScope.Value(scope);
-                    return WrapEventObject(boundNode, events);
-                });
-                boundNode.scopes ??= [];
-                boundNode.scopes.push(scope, eventScope);
-                observableScope_1.ObservableScope.Watch(eventScope, function (scope) { ScheduleSetEvents(boundNode, scope); });
-                const next = observableScope_1.ObservableScope.Value(eventScope);
-                boundNode.assignEvents(next);
-            }
-            else {
-                boundNode.assignEvents(WrapEventObject(boundNode, nodeDef.on));
-                boundNode.assignEvents = null;
-            }
-        }
-    }
-    BoundNode.Init = Init;
-})(BoundNode || (exports.BoundNode = BoundNode = {}));
-function ScheduleSetProperties(node, scope) {
-    if (node.setProperties)
-        return;
-    node.setProperties = true;
-    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-        node.setProperties = false;
-        if (node.destroyed)
-            return;
-        const next = observableScope_1.ObservableScope.Value(scope);
-        node.assignProperties(next || null);
-    });
-}
-function ScheduleSetAttributes(node, scope) {
-    if (node.setAttributes)
-        return;
-    node.setAttributes = true;
-    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-        node.setAttributes = false;
-        if (node.destroyed)
-            return;
-        SetAttributes(node, observableScope_1.ObservableScope.Value(scope));
-    });
-}
-function SetAttributes(node, attributes) {
-    if (!attributes)
-        return;
-    for (var key in attributes) {
-        var val = nodeConfig_1.NodeConfig.getAttribute(node.node, key);
-        if (val !== attributes[key])
-            nodeConfig_1.NodeConfig.setAttribute(node.node, key, attributes[key]);
-    }
-}
-function ScheduleSetEvents(node, scope) {
-    if (node.setEvents)
-        return;
-    node.setEvents = true;
-    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-        node.setEvents = false;
-        if (node.destroyed)
-            return;
-        const next = observableScope_1.ObservableScope.Value(scope);
-        node.assignEvents(next);
-    });
-}

package/Node/boundNode.types.d.ts

@@ -1,57 +0,0 @@
-import { IObservableScope } from "../Store/Tree/observableScope";
-import { RecursivePartial } from "../Utils/utils.types";
-import { NodeRefType } from "./nodeRef";
-import { AllNodeRefTypes, INodeRefBase } from "./nodeRef.types";
-export type FunctionOr<T> = {
-    (...args: Array<any>): T | Promise<T>;
-} | T;
-export type NodeRefEvents<E extends {
-    [event: string]: any;
-} = any> = {
-    [P in keyof E]?: {
-        (events: E[P]): void;
-    };
-};
-export interface NodeDefinition<T = any, E = any> {
-    type: any;
-    namespace: string;
-    props?: FunctionOr<{
-        [name: string]: unknown;
-    }>;
-    attrs?: FunctionOr<{
-        [name: string]: string;
-    }>;
-    on?: FunctionOr<NodeRefEvents<E>>;
-    text?: FunctionOr<string>;
-}
-export interface BoundNodeFunctionParam<P = HTMLElement, E = HTMLElementEventMap> {
-    props?: FunctionOr<RecursivePartial<P>>;
-    attrs?: FunctionOr<{
-        [name: string]: string;
-    }>;
-    on?: FunctionOr<NodeRefEvents<E>>;
-    text?: FunctionOr<string>;
-}
-export interface IBoundNodeBase extends INodeRefBase {
-    nodeDef: BoundNodeFunctionParam;
-    scopes: IObservableScope<unknown>[];
-    setProperties: boolean;
-    assignProperties: {
-        (next: any): void;
-    };
-    assignEvents: {
-        (next: {
-            [event: string]: (event: Event) => void;
-        }): void;
-    };
-    assignText: {
-        (next: string): void;
-    };
-    setAttributes: boolean;
-    setEvents: boolean;
-    setText: boolean;
-}
-export interface IBoundNode extends IBoundNodeBase {
-    type: NodeRefType.BoundNode;
-    childNodes: AllNodeRefTypes[];
-}

package/Node/componentNode.d.ts

@@ -1,7 +0,0 @@
-import { ComponentConstructor } from "./component";
-import { ComponentNodeFunction, IComponentNodeBase } from "./componentNode.types";
-export declare namespace ComponentNode {
-    function Fire<E, P extends keyof E>(event: P, data?: E[P]): void;
-    function ToFunction<D = void, T = void, E = void>(type: any, namespace: string, constructor: ComponentConstructor<D, T, E>): ComponentNodeFunction<D, T, E>;
-    function Init(componentNode: IComponentNodeBase<any, any, any>): void;
-}

package/Node/componentNode.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComponentNode = void 0;
-const boundNode_1 = require("./boundNode");
-const nodeRef_1 = require("./nodeRef");
-const nodeConfig_1 = require("./nodeConfig");
-const component_1 = require("./component");
-const injector_1 = require("../Utils/injector");
-const decorators_1 = require("../Utils/decorators");
-const thread_1 = require("../Utils/thread");
-const list_1 = require("../Utils/list");
-var ComponentNode;
-(function (ComponentNode) {
-    function Fire(event, data) {
-        var eventCallback = this.componentEvents && this.componentEvents[event];
-        eventCallback && eventCallback(data);
-    }
-    ComponentNode.Fire = Fire;
-    function ToFunction(type, namespace, constructor) {
-        return function (nodeDef, templates) {
-            return Create(type, namespace, nodeDef, constructor, templates);
-        };
-    }
-    ComponentNode.ToFunction = ToFunction;
-    function Init(componentNode) {
-        var nodeDef = componentNode.nodeDef;
-        var events = nodeDef.on;
-        nodeDef.on = null;
-        componentNode.component = new componentNode.constructor(nodeDef.data, componentNode.templates, componentNode, events);
-        SetChildren(componentNode);
-        boundNode_1.BoundNode.Init(componentNode);
-    }
-    ComponentNode.Init = Init;
-})(ComponentNode || (exports.ComponentNode = ComponentNode = {}));
-function Create(type, namespace, nodeDef, constructor, templates) {
-    var compNode = nodeRef_1.NodeRef.Create(type, namespace, nodeRef_1.NodeRefType.ComponentNode);
-    compNode.nodeDef = nodeDef;
-    compNode.constructor = constructor;
-    compNode.templates = templates;
-    return compNode;
-}
-function SetChildren(node) {
-    if (decorators_1.PreReq.Has(node.component)) {
-        AddPreReqTemplate(node).then(function () {
-            AddTemplate(node, false);
-        });
-    }
-    else
-        AddTemplate(node, true);
-}
-function AddPreReqTemplate(node) {
-    return new Promise(resolve => {
-        (0, thread_1.Thread)(function () {
-            const preNodes = injector_1.Injector.Scope(node.injector, decorators_1.PreReqTemplate.Get, node.component);
-            (0, thread_1.Schedule)(function () {
-                if (node.destroyed)
-                    return;
-                nodeRef_1.NodeRef.InitAll(node, preNodes);
-            });
-            (0, thread_1.Thread)(function () {
-                if (node.destroyed)
-                    return;
-                for (var x = 0; x < preNodes.length; x++)
-                    nodeRef_1.NodeRef.AddChild(node, preNodes[x]);
-                decorators_1.PreReq.All(node.component).then(function () {
-                    if (node.destroyed)
-                        return;
-                    for (var x = 0; x < preNodes.length; x++)
-                        nodeRef_1.NodeRef.Destroy(preNodes[x]);
-                    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-                        if (node.destroyed)
-                            return;
-                        for (var x = 0; x < preNodes.length; x++)
-                            nodeRef_1.NodeRef.DetachChild(node, preNodes[x]);
-                        resolve();
-                    });
-                });
-            });
-        });
-    });
-}
-function InvokeNodeTemplate(node) {
-    const nodes = node.component.Template();
-    if (!Array.isArray(nodes))
-        return [nodes];
-    return nodes;
-}
-function AddTemplate(node, init) {
-    (0, thread_1.Thread)(function () {
-        if (node.destroyed)
-            return;
-        const nodes = injector_1.Injector.Scope(node.injector, InvokeNodeTemplate, node);
-        (0, thread_1.Schedule)(function () {
-            nodeRef_1.NodeRef.InitAll(node, nodes);
-        });
-        (0, thread_1.Thread)(function () {
-            if (node.destroyed)
-                return;
-            const list = list_1.List.Create();
-            list_1.List.Add(list, {
-                value: undefined,
-                init: true,
-                scope: null,
-                nodes
-            });
-            if (init) {
-                nodeRef_1.NodeRef.ReconcileChildren(node, list);
-                list_1.List.Clear(list);
-            }
-            else
-                nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-                    if (node.destroyed)
-                        return;
-                    nodeRef_1.NodeRef.ReconcileChildren(node, list);
-                    list_1.List.Clear(list);
-                });
-        });
-        if (node.component.Bound !== component_1.Component.prototype.Bound)
-            (0, thread_1.After)(function () {
-                nodeConfig_1.NodeConfig.scheduleUpdate(() => setTimeout(() => node.component.Bound(), 0));
-            });
-    });
-}

package/Node/componentNode.types.d.ts

@@ -1,37 +0,0 @@
-import { BoundNodeFunctionParam, IBoundNodeBase, NodeDefinition } from "./boundNode.types";
-import { Component, ComponentConstructor } from "./component";
-import { NodeRefType } from "./nodeRef";
-import { AllNodeRefTypes } from "./nodeRef.types";
-export type ComponentNodeEvents<E = void> = {
-    [P in keyof E]?: {
-        (data: E[P]): void;
-    };
-};
-export interface ComponentNodeDefinition<D = void, E = void> extends NodeDefinition<D> {
-    on: ComponentNodeEvents<E>;
-    data?: {
-        (): D | Promise<D>;
-    };
-}
-export interface ComponentNodeFunctionParam<D = void, E = void, P = HTMLElement> extends BoundNodeFunctionParam<P> {
-    on?: ComponentNodeEvents<E>;
-    data?: {
-        (): D | Promise<D>;
-    };
-}
-export type ComponentNodeFunction<D = void, T = void, E = void> = (nodeDef: ComponentNodeFunctionParam<D, E>, templates?: T) => IComponentNode<D, T, E>;
-export interface IComponentNodeBase<D, T, E> extends IBoundNodeBase {
-    nodeDef: ComponentNodeFunctionParam<D, E>;
-    constructor: ComponentConstructor<D, T, E>;
-    component: Component<D, T, E>;
-    componentEvents: {
-        [name: string]: {
-            (...args: Array<any>): void;
-        };
-    };
-    templates: T;
-}
-export interface IComponentNode<D, T, E> extends IComponentNodeBase<D, T, E> {
-    type: NodeRefType.ComponentNode;
-    childNodes: AllNodeRefTypes[];
-}

package/Node/elementNode.d.ts

@@ -1,5 +0,0 @@
-import { ElementChildrenFunctionParam, ElementNodeFunctionParam, IElementNode, IElementNodeBase } from "./elementNode.types";
-export declare namespace ElementNode {
-    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

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElementNode = void 0;
-const observableScope_1 = require("../Store/Tree/observableScope");
-const injector_1 = require("../Utils/injector");
-const list_1 = require("../Utils/list");
-const thread_1 = require("../Utils/thread");
-const boundNode_1 = require("./boundNode");
-const nodeConfig_1 = require("./nodeConfig");
-const nodeRef_1 = require("./nodeRef");
-const valueDefault = [];
-var ElementNode;
-(function (ElementNode) {
-    function Create(type, namespace, nodeDef, children) {
-        var elemNode = nodeRef_1.NodeRef.Create(type, namespace, nodeRef_1.NodeRefType.ElementNode);
-        elemNode.nodeDef = nodeDef;
-        if (Array.isArray(children))
-            elemNode.childrenArray = children;
-        else if (children !== undefined)
-            elemNode.children = children;
-        return elemNode;
-    }
-    ElementNode.Create = Create;
-    function CreateValueScopeCallback(dataScope) {
-        return function () {
-            const value = observableScope_1.ObservableScope.Value(dataScope);
-            if (!value)
-                return valueDefault;
-            if (!Array.isArray(value))
-                return [value];
-            return value;
-        };
-    }
-    function CreateNodeScopeCallback(elementNode, valueScope) {
-        let lastNodeList;
-        return function () {
-            const values = observableScope_1.ObservableScope.Value(valueScope);
-            const lastNodeMap = lastNodeList && list_1.List.ToNodeMap(lastNodeList, GetDataValue);
-            const nextNodeList = list_1.List.Create();
-            for (let x = 0; x < values.length; x++) {
-                let curNode = null;
-                if (lastNodeMap !== undefined) {
-                    const nodeArr = lastNodeMap.get(values[x]);
-                    if (nodeArr !== undefined) {
-                        let y = nodeArr.length - 1;
-                        for (; y >= 0 && nodeArr[y] === null; y--) { }
-                        curNode = nodeArr[y];
-                        nodeArr[y] = null;
-                    }
-                }
-                const value = values[x];
-                if (curNode !== null) {
-                    list_1.List.RemoveNode(lastNodeList, curNode);
-                    list_1.List.AddNode(nextNodeList, curNode);
-                    const nextNodes = observableScope_1.ObservableScope.Value(curNode.data.scope);
-                    if (curNode.data.nodes !== nextNodes) {
-                        list_1.List.Add(elementNode.destroyNodeList, {
-                            ...curNode.data,
-                            scope: null
-                        });
-                        curNode.data.init = false;
-                        curNode.data.nodes = nextNodes;
-                    }
-                }
-                else {
-                    const scope = observableScope_1.ObservableScope.Create(function () {
-                        return injector_1.Injector.Scope(elementNode.injector, CreateNodeArray, elementNode.children, value);
-                    });
-                    curNode = list_1.List.Add(nextNodeList, {
-                        value,
-                        init: false,
-                        scope,
-                        nodes: observableScope_1.ObservableScope.Value(scope),
-                    });
-                }
-            }
-            lastNodeList && list_1.List.Append(elementNode.destroyNodeList, lastNodeList);
-            lastNodeList = nextNodeList;
-            return nextNodeList;
-        };
-    }
-    function Init(elementNode) {
-        elementNode.childNodes = new Set();
-        if (elementNode.children !== null) {
-            const dataScope = elementNode.nodeDef.data ? observableScope_1.ObservableScope.Create(elementNode.nodeDef.data) : observableScope_1.ObservableScope.Create(function () {
-                return [true];
-            });
-            const valueScope = observableScope_1.ObservableScope.Create(CreateValueScopeCallback(dataScope));
-            const nodeScope = observableScope_1.ObservableScope.Create(CreateNodeScopeCallback(elementNode, valueScope));
-            elementNode.childNodes = new Set();
-            elementNode.scopes ??= [];
-            elementNode.scopes.push(dataScope, valueScope, nodeScope);
-            observableScope_1.ObservableScope.Watch(nodeScope, function (scope) {
-                ScheduleSetData(elementNode, scope);
-            });
-            UpdateNodes(elementNode, observableScope_1.ObservableScope.Value(nodeScope), true);
-        }
-        else if (elementNode.childrenArray !== null) {
-            SetDefaultData(elementNode);
-        }
-        boundNode_1.BoundNode.Init(elementNode);
-    }
-    ElementNode.Init = Init;
-})(ElementNode || (exports.ElementNode = ElementNode = {}));
-function ScheduleSetData(node, scope) {
-    if (node.setData)
-        return;
-    node.setData = true;
-    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-        node.setData = false;
-        if (node.destroyed)
-            return;
-        UpdateNodes(node, observableScope_1.ObservableScope.Value(scope));
-    });
-}
-function SetDefaultData(node) {
-    const nodes = node.childrenArray ||
-        injector_1.Injector.Scope(node.injector, CreateNodeArray, node.children, true);
-    node.childrenArray = null;
-    const defaultNodeList = list_1.List.Create();
-    list_1.List.Add(defaultNodeList, {
-        value: null,
-        init: false,
-        scope: null,
-        nodes
-    });
-    UpdateNodes(node, defaultNodeList, true);
-}
-function GetDataValue(data) {
-    return data.value;
-}
-function UpdateNodes(elementNode, nodeList, init = false) {
-    (0, thread_1.Synch)(function () {
-        let data;
-        while (data = list_1.List.Pop(elementNode.destroyNodeList)) {
-            observableScope_1.ObservableScope.Destroy(data.scope);
-            for (let x = 0; x < data.nodes.length; x++)
-                elementNode.childNodes.delete(data.nodes[x]);
-            nodeRef_1.NodeRef.DestroyAll(data.nodes);
-        }
-        for (let node = nodeList.head; node !== null; node = node.next) {
-            if (!node.data.init) {
-                const nodeData = node.data;
-                (0, thread_1.Schedule)(function () {
-                    if (elementNode.destroyed || nodeData.init)
-                        return;
-                    nodeRef_1.NodeRef.InitAll(elementNode, nodeData.nodes);
-                    nodeData.init = true;
-                });
-            }
-        }
-        const startSize = nodeList.size;
-        (0, thread_1.Thread)(function (async) {
-            if (elementNode.destroyed)
-                return;
-            if (init || !async)
-                nodeRef_1.NodeRef.ReconcileChildren(elementNode, nodeList);
-            else
-                nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-                    if (elementNode.destroyed || nodeList.size !== startSize)
-                        return;
-                    nodeRef_1.NodeRef.ReconcileChildren(elementNode, nodeList);
-                });
-        });
-    });
-}
-function CreateNodeArray(childrenFunc, value) {
-    const newNodes = childrenFunc(value);
-    if (typeof newNodes === "string" || !newNodes) {
-        const textNode = nodeRef_1.NodeRef.Create(newNodes, null, nodeRef_1.NodeRefType.TextNode);
-        return [textNode];
-    }
-    if (Array.isArray(newNodes))
-        return newNodes;
-    return [newNodes];
-}

package/Node/elementNode.types.d.ts

@@ -1,40 +0,0 @@
-import { IObservableScope } from "../Store/Tree/observableScope";
-import { IList } from "../Utils/list";
-import { NodeDefinition, BoundNodeFunctionParam, IBoundNodeBase } from "./boundNode.types";
-import { NodeRefType } from "./nodeRef";
-import { INodeRefBase, ElementNodeRefTypes, AllNodeRefTypes } from "./nodeRef.types";
-export type ElementChildrenFunction<T> = {
-    (data: T): string | ElementNodeRefTypes | ElementNodeRefTypes[];
-};
-export type ElementChildrenFunctionParam<T> = ElementChildrenFunction<T> | ElementNodeRefTypes[];
-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?: ElementChildrenFunction<T>;
-}
-export interface ElementNodeFunctionParam<T, P = HTMLElement, E = HTMLElementEventMap> extends BoundNodeFunctionParam<P, E> {
-    data?: {
-        (): T | Array<T> | Promise<Array<T>> | Promise<T>;
-    };
-}
-export interface IElementDataNode<T> {
-    value: T;
-    init: boolean;
-    scope: IObservableScope<AllNodeRefTypes[] | null>;
-    nodes: AllNodeRefTypes[] | null;
-}
-export interface IElementNodeBase<T> extends IBoundNodeBase {
-    nodeDef: ElementNodeFunctionParam<T>;
-    children: ElementChildrenFunction<T>;
-    childrenArray: ElementNodeRefTypes[];
-    destroyNodeList: IList<IElementDataNode<T>>;
-    setData: boolean;
-}
-export interface IElementNode<T> extends IElementNodeBase<T> {
-    type: NodeRefType.ElementNode;
-    childNodes: Set<AllNodeRefTypes>;
-}

package/Node/elementNode.types.js

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

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;
-}