j-templates 6.1.11 → 7.0.0

package/Utils/avlTree.js

@@ -0,0 +1,139 @@
+"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) {
+        InOrder(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 InOrder(node, callback) {
+    if (node === null)
+        return;
+    InOrder(node[LEFT], callback);
+    callback(node[VALUE]);
+    InOrder(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;
+    const path = [];
+    while (node !== null) {
+        const 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/decorators.d.ts

@@ -1,34 +1,13 @@
-import { Component } from "../Node/component";
 import { IDestroyable } from "./utils.types";
-import { ElementNodeRefTypes } from "../Node/nodeRef.types";
-export declare function Computed<T extends Component<any, any, any>, K extends keyof T, V extends T[K]>(defaultValue: V): (target: T, propertyKey: K, descriptor: PropertyDescriptor) => PropertyDescriptor;
-export declare function ComputedAsync<T extends Component<any, any, any>, K extends keyof T, V extends T[K]>(defaultValue: V): (target: T, propertyKey: K, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function Computed<T extends WeakKey, K extends keyof T, V extends T[K]>(defaultValue: V): (target: T, propertyKey: K, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ComputedAsync<T extends WeakKey, K extends keyof T, V extends T[K]>(defaultValue: V): (target: T, propertyKey: K, descriptor: PropertyDescriptor) => PropertyDescriptor;
 export declare function State(): any;
 export declare function Value(): any;
 export declare function Scope(): typeof ScopeDecorator;
-declare function ScopeDecorator<T extends Component<any, any, any>, K extends string>(target: T, propertyKey: K, descriptor: PropertyDescriptor): PropertyDescriptor;
-export declare function Inject<I>(type: {
-    new (...args: Array<any>): I;
-}): <F extends I, T extends Component<any, any, any> & Record<K, F>, K extends string>(target: T, propertyKey: K, descriptor?: PropertyDescriptor) => any;
+declare function ScopeDecorator<T, K extends string>(target: T, propertyKey: K, descriptor: PropertyDescriptor): PropertyDescriptor;
 export declare function Destroy(): typeof DestroyDecorator;
 export declare namespace Destroy {
     function All<T extends WeakKey, K>(value: T): void;
 }
-declare function DestroyDecorator<T extends Component<any, any, any> & Record<K, IDestroyable>, K extends string>(target: T, propertyKey: K): any;
-export declare function PreReqTemplate(template: {
-    (): ElementNodeRefTypes | ElementNodeRefTypes[];
-}): <T extends Component<any, any, any>>(target: {
-    new (...args: Array<any>): T;
-}) => any;
-export declare namespace PreReqTemplate {
-    function Get(value: any): ElementNodeRefTypes[];
-}
-export declare function PreReq(): typeof PreReqDecorator;
-export declare namespace PreReq {
-    function All(value: any): Promise<void[]>;
-    function Has(value: any): boolean;
-}
-declare function PreReqDecorator<T extends Record<K, {
-    Init: Promise<void>;
-}>, K extends string>(target: T, propertyKey: K): any;
+declare function DestroyDecorator<T extends Record<K, IDestroyable>, K extends string>(target: T, propertyKey: K): any;
 export {};

package/Utils/decorators.js

@@ -5,10 +5,7 @@ exports.ComputedAsync = ComputedAsync;
 exports.State = State;
 exports.Value = Value;
 exports.Scope = Scope;
-exports.Inject = Inject;
 exports.Destroy = Destroy;
-exports.PreReqTemplate = PreReqTemplate;
-exports.PreReq = PreReq;
 const observableScope_1 = require("../Store/Tree/observableScope");
 const observableNode_1 = require("../Store/Tree/observableNode");
 const Store_1 = require("../Store");
@@ -170,21 +167,6 @@ function ScopeDecorator(target, propertyKey, descriptor) {
         },
     };
 }
-function Inject(type) {
-    return InjectorDecorator.bind(null, type);
-}
-function InjectorDecorator(type, target, propertyKey, descriptor) {
-    return {
-        configurable: false,
-        enumerable: true,
-        get: function () {
-            return this.Injector.Get(type);
-        },
-        set: function (val) {
-            this.Injector.Set(type, val);
-        },
-    };
-}
 function Destroy() {
     return DestroyDecorator;
 }
@@ -192,9 +174,9 @@ function Destroy() {
     function All(value) {
         const scopeMap = scopeInstanceMap.get(value);
         if (scopeMap !== undefined) {
-            const keys = Object.keys(scopeMap);
-            for (let x = 0; x < keys.length; x++)
-                observableScope_1.ObservableScope.Destroy(scopeMap[keys[x]][0]);
+            const values = Object.values(scopeMap);
+            for (let x = 0; x < values.length; x++)
+                observableScope_1.ObservableScope.Destroy(values[x][0]);
         }
         const array = GetDestroyArrayForPrototype(Object.getPrototypeOf(value));
         for (let x = 0; x < array.length; x++)
@@ -206,43 +188,3 @@ function DestroyDecorator(target, propertyKey) {
     const array = GetDestroyArrayForPrototype(target);
     array.push(propertyKey);
 }
-function PreReqTemplate(template) {
-    return PreReqTemplateDecorator.bind(null, template);
-}
-(function (PreReqTemplate) {
-    function Get(value) {
-        var func = value && value.PreReqTemplateDecorator_Template;
-        var ret = func ? func() : [];
-        if (!Array.isArray(ret))
-            ret = [ret];
-        return ret;
-    }
-    PreReqTemplate.Get = Get;
-})(PreReqTemplate || (exports.PreReqTemplate = PreReqTemplate = {}));
-function PreReqTemplateDecorator(template, target) {
-    var proto = target.prototype;
-    proto.PreReqTemplateDecorator_Template = template;
-}
-function PreReq() {
-    return PreReqDecorator;
-}
-(function (PreReq) {
-    function Get(value) {
-        return (value && value.PreReqDecorator_PreReqs) || [];
-    }
-    function All(value) {
-        var arr = Get(value).map((prop) => (value[prop] && value[prop].Init) ||
-            Promise.resolve());
-        return Promise.all(arr);
-    }
-    PreReq.All = All;
-    function Has(value) {
-        return Get(value).length > 0;
-    }
-    PreReq.Has = Has;
-})(PreReq || (exports.PreReq = PreReq = {}));
-function PreReqDecorator(target, propertyKey) {
-    var proto = target;
-    proto.PreReqDecorator_PreReqs = proto.PreReqDecorator_PreReqs || [];
-    proto.PreReqDecorator_PreReqs.push(propertyKey);
-}

package/Utils/distinctArray.d.ts

@@ -0,0 +1,10 @@
+export type DistinctArray<T> = {
+    id: (value: T) => number;
+    distinct: boolean[];
+    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]) {
+            distinct[vId] = true;
+            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/index.d.ts

@@ -1,3 +1,2 @@
-export { AllNodeRefTypes as NodeRefTypes } from "./Node/nodeRef.types";
-export { Component } from "./Node/component";
+export { Component } from './Node/component';
 export { CalcScope as calc } from './Store/Tree/observableScope';

package/package.json

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

package/Node/boundNode.d.ts

@@ -1,4 +0,0 @@
-import { IBoundNodeBase } from "./boundNode.types";
-export declare namespace BoundNode {
-    function Init(boundNode: IBoundNodeBase): void;
-}

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