j-templates 5.0.46 → 5.0.48

package/Node/componentNode.js

@@ -1,115 +1,115 @@
-"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");
-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);
-        componentNode.destroyables.push(componentNode.component);
-        boundNode_1.BoundNode.Init(componentNode);
-    }
-    ComponentNode.Init = Init;
-})(ComponentNode = exports.ComponentNode || (exports.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(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(nodes);
-        });
-        (0, thread_1.Thread)(function () {
-            if (node.destroyed)
-                return;
-            if (init)
-                for (var x = 0; x < nodes.length; x++)
-                    nodeRef_1.NodeRef.AddChild(node, nodes[x]);
-            else
-                nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-                    if (node.destroyed)
-                        return;
-                    for (var x = 0; x < nodes.length; x++)
-                        nodeRef_1.NodeRef.AddChild(node, nodes[x]);
-                });
-        });
-        if (node.component.Bound !== component_1.Component.prototype.Bound)
-            (0, thread_1.After)(function () {
-                nodeConfig_1.NodeConfig.scheduleUpdate(() => setTimeout(() => node.component.Bound(), 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");
+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);
+        componentNode.destroyables.push(componentNode.component);
+        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(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(nodes);
+        });
+        (0, thread_1.Thread)(function () {
+            if (node.destroyed)
+                return;
+            if (init)
+                for (var x = 0; x < nodes.length; x++)
+                    nodeRef_1.NodeRef.AddChild(node, nodes[x]);
+            else
+                nodeConfig_1.NodeConfig.scheduleUpdate(function () {
+                    if (node.destroyed)
+                        return;
+                    for (var x = 0; x < nodes.length; x++)
+                        nodeRef_1.NodeRef.AddChild(node, nodes[x]);
+                });
+        });
+        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,35 +1,35 @@
-import { BoundNodeFunctionParam, IBoundNodeBase, NodeDefinition } from "./boundNode.types";
-import { Component, ComponentConstructor } from "./component";
-import { NodeRefType } from "./nodeRef";
-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> extends BoundNodeFunctionParam {
-    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;
-}
+import { BoundNodeFunctionParam, IBoundNodeBase, NodeDefinition } from "./boundNode.types";
+import { Component, ComponentConstructor } from "./component";
+import { NodeRefType } from "./nodeRef";
+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> extends BoundNodeFunctionParam {
+    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;
+}

package/Node/componentNode.types.js

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

package/Node/elementNode.d.ts

@@ -1,5 +1,5 @@
-import { ElementNodeFunctionParam, ElementChildrenFunction, IElementNode, IElementNodeBase } from "./elementNode.types";
-export declare namespace ElementNode {
-    function Create<T>(type: any, namespace: string, nodeDef: ElementNodeFunctionParam<T>, children: ElementChildrenFunction<T>): IElementNode<T>;
-    function Init<T>(elementNode: IElementNodeBase<T>): void;
-}
+import { ElementChildrenFunction, ElementNodeFunctionParam, IElementNode, IElementNodeBase } from "./elementNode.types";
+export declare namespace ElementNode {
+    function Create<T>(type: any, namespace: string, nodeDef: ElementNodeFunctionParam<T>, children: ElementChildrenFunction<T>): IElementNode<T>;
+    function Init<T>(elementNode: IElementNodeBase<T>): void;
+}