j-templates 5.0.46 → 5.0.47

package/Node/boundNode.js

@@ -1,94 +1,99 @@
-"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 Init(boundNode) {
-        const nodeDef = boundNode.nodeDef;
-        if (nodeDef.props) {
-            const scope = observableScope_1.ObservableScope.Create(nodeDef.props);
-            boundNode.destroyables.push(CreateScopeDestroyable(scope));
-            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetProperties(boundNode, scope); });
-            SetProperties(boundNode, observableScope_1.ObservableScope.Value(scope));
-        }
-        if (nodeDef.attrs) {
-            const scope = observableScope_1.ObservableScope.Create(nodeDef.attrs);
-            boundNode.destroyables.push(CreateScopeDestroyable(scope));
-            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetAttributes(boundNode, scope); });
-            SetAttributes(boundNode, observableScope_1.ObservableScope.Value(scope));
-        }
-        if (nodeDef.on) {
-            const scope = observableScope_1.ObservableScope.Create(nodeDef.on);
-            boundNode.destroyables.push(CreateScopeDestroyable(scope));
-            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetEvents(boundNode, scope); });
-            SetEvents(boundNode, observableScope_1.ObservableScope.Value(scope));
-        }
-    }
-    BoundNode.Init = Init;
-})(BoundNode = exports.BoundNode || (exports.BoundNode = {}));
-function CreateScopeDestroyable(scope) {
-    return {
-        Destroy() {
-            observableScope_1.ObservableScope.Destroy(scope);
-        }
-    };
-}
-function ScheduleSetProperties(node, scope) {
-    if (node.setProperties)
-        return;
-    node.setProperties = true;
-    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-        node.setProperties = false;
-        if (node.destroyed)
-            return;
-        SetProperties(node, observableScope_1.ObservableScope.Value(scope));
-    });
-}
-function SetProperties(node, properties) {
-    if (!properties)
-        return;
-    nodeConfig_1.NodeConfig.setProperties(node.node, node.lastProperties, properties);
-    node.lastProperties = properties;
-}
-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;
-        SetEvents(node, observableScope_1.ObservableScope.Value(scope));
-    });
-}
-function SetEvents(node, events) {
-    if (!events)
-        return;
-    for (var key in node.lastEvents)
-        nodeConfig_1.NodeConfig.removeListener(node.node, key, node.lastEvents[key]);
-    for (var key in events)
-        nodeConfig_1.NodeConfig.addListener(node.node, key, events[key]);
-    node.lastEvents = events;
-}
+"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 Init(boundNode) {
+        const nodeDef = boundNode.nodeDef;
+        if (nodeDef.props) {
+            const scope = observableScope_1.ObservableScope.Create(nodeDef.props);
+            boundNode.destroyables.push(CreateScopeDestroyable(scope));
+            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetProperties(boundNode, scope); });
+            SetProperties(boundNode, observableScope_1.ObservableScope.Value(scope));
+        }
+        if (nodeDef.attrs) {
+            const scope = observableScope_1.ObservableScope.Create(nodeDef.attrs);
+            boundNode.destroyables.push(CreateScopeDestroyable(scope));
+            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetAttributes(boundNode, scope); });
+            SetAttributes(boundNode, observableScope_1.ObservableScope.Value(scope));
+        }
+        if (nodeDef.on) {
+            const scope = observableScope_1.ObservableScope.Create(nodeDef.on);
+            boundNode.destroyables.push(CreateScopeDestroyable(scope));
+            boundNode.destroyables.push({
+                Destroy() {
+                    SetEvents(boundNode, {});
+                }
+            });
+            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetEvents(boundNode, scope); });
+            SetEvents(boundNode, observableScope_1.ObservableScope.Value(scope));
+        }
+    }
+    BoundNode.Init = Init;
+})(BoundNode || (exports.BoundNode = BoundNode = {}));
+function CreateScopeDestroyable(scope) {
+    return {
+        Destroy() {
+            observableScope_1.ObservableScope.Destroy(scope);
+        }
+    };
+}
+function ScheduleSetProperties(node, scope) {
+    if (node.setProperties)
+        return;
+    node.setProperties = true;
+    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
+        node.setProperties = false;
+        if (node.destroyed)
+            return;
+        SetProperties(node, observableScope_1.ObservableScope.Value(scope));
+    });
+}
+function SetProperties(node, properties) {
+    if (!properties)
+        return;
+    nodeConfig_1.NodeConfig.setProperties(node.node, node.lastProperties, properties);
+    node.lastProperties = properties;
+}
+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;
+        SetEvents(node, observableScope_1.ObservableScope.Value(scope));
+    });
+}
+function SetEvents(node, events) {
+    if (!events)
+        return;
+    for (var key in node.lastEvents)
+        nodeConfig_1.NodeConfig.removeListener(node.node, key, node.lastEvents[key]);
+    for (var key in events)
+        nodeConfig_1.NodeConfig.addListener(node.node, key, events[key]);
+    node.lastEvents = events;
+}

package/Node/boundNode.types.d.ts

@@ -1,43 +1,43 @@
-import { NodeRefType } from "./nodeRef";
-import { INodeRefBase } from "./nodeRef.types";
-export type FunctionOr<T> = {
-    (...args: Array<any>): T | Promise<T>;
-} | T;
-export type NodeRefEvents = {
-    [name: string]: {
-        (...args: Array<any>): void;
-    };
-};
-export interface NodeDefinition<T = any, E = any> {
-    type: any;
-    namespace: string;
-    props?: FunctionOr<{
-        [name: string]: any;
-    }>;
-    attrs?: FunctionOr<{
-        [name: string]: string;
-    }>;
-    on?: FunctionOr<NodeRefEvents>;
-}
-export interface BoundNodeFunctionParam {
-    props?: FunctionOr<{
-        [name: string]: any;
-    }>;
-    attrs?: FunctionOr<{
-        [name: string]: string;
-    }>;
-    on?: FunctionOr<NodeRefEvents>;
-}
-export interface IBoundNodeBase extends INodeRefBase {
-    nodeDef: BoundNodeFunctionParam;
-    lastProperties: any;
-    lastEvents: {
-        [name: string]: any;
-    };
-    setProperties: boolean;
-    setAttributes: boolean;
-    setEvents: boolean;
-}
-export interface IBoundNode extends IBoundNodeBase {
-    type: NodeRefType.BoundNode;
-}
+import { NodeRefType } from "./nodeRef";
+import { INodeRefBase } from "./nodeRef.types";
+export type FunctionOr<T> = {
+    (...args: Array<any>): T | Promise<T>;
+} | T;
+export type NodeRefEvents = {
+    [name: string]: {
+        (...args: Array<any>): void;
+    };
+};
+export interface NodeDefinition<T = any, E = any> {
+    type: any;
+    namespace: string;
+    props?: FunctionOr<{
+        [name: string]: any;
+    }>;
+    attrs?: FunctionOr<{
+        [name: string]: string;
+    }>;
+    on?: FunctionOr<NodeRefEvents>;
+}
+export interface BoundNodeFunctionParam {
+    props?: FunctionOr<{
+        [name: string]: any;
+    }>;
+    attrs?: FunctionOr<{
+        [name: string]: string;
+    }>;
+    on?: FunctionOr<NodeRefEvents>;
+}
+export interface IBoundNodeBase extends INodeRefBase {
+    nodeDef: BoundNodeFunctionParam;
+    lastProperties: any;
+    lastEvents: {
+        [name: string]: any;
+    };
+    setProperties: boolean;
+    setAttributes: boolean;
+    setEvents: boolean;
+}
+export interface IBoundNode extends IBoundNodeBase {
+    type: NodeRefType.BoundNode;
+}

package/Node/boundNode.types.js

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

package/Node/component.d.ts

@@ -1,34 +1,34 @@
-import { ComponentNodeEvents } from "./componentNode.types";
-import { ObservableScope } from "../Store/Tree/observableScope";
-import { INodeRefBase, NodeRefTypes } from "./nodeRef.types";
-export declare class Component<D = void, T = void, E = void> {
-    private nodeRef;
-    private componentEvents;
-    private scope;
-    private templates;
-    private decoratorMap;
-    get Injector(): import("../Utils/injector").Injector;
-    get Destroyed(): boolean;
-    get DecoratorMap(): Map<string, any>;
-    protected get Scope(): ObservableScope<D>;
-    protected get Data(): D;
-    protected get NodeRef(): INodeRefBase;
-    protected get Templates(): T;
-    constructor(data: D | {
-        (): D | Promise<D>;
-    }, templates: T, nodeRef: INodeRefBase, componentEvents: ComponentNodeEvents<E>);
-    Template(): NodeRefTypes | NodeRefTypes[];
-    Bound(): void;
-    Fire<P extends keyof E>(event: P, data?: E[P]): void;
-    Destroy(): void;
-}
-export declare namespace Component {
-    function ToFunction<D = void, T = void, E = void>(type: any, namespace: any, constructor: ComponentConstructor<D, T, E>): import("./componentNode.types").ComponentNodeFunction<D, T, E>;
-    function Register<D = void, T = void, E = void>(name: string, constructor: ComponentConstructor<D, T, E>): void;
-    function Attach(node: Node, nodeRef: NodeRefTypes): void;
-}
-export type ComponentConstructor<D, T, E> = {
-    new (data: {
-        (): D | Promise<D>;
-    }, templates: T, nodeRef: INodeRefBase, componentEvents: ComponentNodeEvents<E>): Component<D, T, E>;
-};
+import { ComponentNodeEvents } from "./componentNode.types";
+import { ObservableScope } from "../Store/Tree/observableScope";
+import { INodeRefBase, NodeRefTypes } from "./nodeRef.types";
+export declare class Component<D = void, T = void, E = void> {
+    private nodeRef;
+    private componentEvents;
+    private scope;
+    private templates;
+    private decoratorMap;
+    get Injector(): import("../Utils/injector").Injector;
+    get Destroyed(): boolean;
+    get DecoratorMap(): Map<string, any>;
+    protected get Scope(): ObservableScope<D>;
+    protected get Data(): D;
+    protected get NodeRef(): INodeRefBase;
+    protected get Templates(): T;
+    constructor(data: D | {
+        (): D | Promise<D>;
+    }, templates: T, nodeRef: INodeRefBase, componentEvents: ComponentNodeEvents<E>);
+    Template(): NodeRefTypes | NodeRefTypes[];
+    Bound(): void;
+    Fire<P extends keyof E>(event: P, data?: E[P]): void;
+    Destroy(): void;
+}
+export declare namespace Component {
+    function ToFunction<D = void, T = void, E = void>(type: any, namespace: any, constructor: ComponentConstructor<D, T, E>): import("./componentNode.types").ComponentNodeFunction<D, T, E>;
+    function Register<D = void, T = void, E = void>(name: string, constructor: ComponentConstructor<D, T, E>): void;
+    function Attach(node: Node, nodeRef: NodeRefTypes): void;
+}
+export type ComponentConstructor<D, T, E> = {
+    new (data: {
+        (): D | Promise<D>;
+    }, templates: T, nodeRef: INodeRefBase, componentEvents: ComponentNodeEvents<E>): Component<D, T, E>;
+};

package/Node/component.js

@@ -1,80 +1,80 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Component = void 0;
-const nodeRef_1 = require("./nodeRef");
-const componentNode_1 = require("./componentNode");
-const decorators_1 = require("../Utils/decorators");
-const observableScope_1 = require("../Store/Tree/observableScope");
-class Component {
-    nodeRef;
-    componentEvents;
-    scope;
-    templates;
-    decoratorMap;
-    get Injector() {
-        return this.nodeRef.injector;
-    }
-    get Destroyed() {
-        return this.nodeRef.destroyed;
-    }
-    get DecoratorMap() {
-        return this.decoratorMap;
-    }
-    get Scope() {
-        return this.scope;
-    }
-    get Data() {
-        return this.scope.Value;
-    }
-    get NodeRef() {
-        return this.nodeRef;
-    }
-    get Templates() {
-        return this.templates;
-    }
-    constructor(data, templates, nodeRef, componentEvents) {
-        this.nodeRef = nodeRef;
-        this.componentEvents = componentEvents;
-        this.scope = new observableScope_1.ObservableScope(data);
-        this.templates = templates || {};
-        this.decoratorMap = new Map();
-    }
-    Template() {
-        return [];
-    }
-    Bound() {
-    }
-    Fire(event, data) {
-        var eventCallback = this.componentEvents && this.componentEvents[event];
-        eventCallback && eventCallback(data);
-    }
-    Destroy() {
-        decorators_1.Destroy.All(this);
-    }
-}
-exports.Component = Component;
-(function (Component) {
-    function ToFunction(type, namespace, constructor) {
-        return componentNode_1.ComponentNode.ToFunction(type, namespace, constructor);
-    }
-    Component.ToFunction = ToFunction;
-    function Register(name, constructor) {
-        const componentFunction = ToFunction(`${name}-component`, undefined, constructor);
-        class WebComponent extends HTMLElement {
-            constructor() {
-                super();
-                const shadowRoot = this.attachShadow({ mode: 'open' });
-                const node = componentFunction({});
-                Attach(shadowRoot, node);
-            }
-        }
-        customElements.define(name, WebComponent);
-    }
-    Component.Register = Register;
-    function Attach(node, nodeRef) {
-        nodeRef_1.NodeRef.Init(nodeRef);
-        var rootRef = nodeRef_1.NodeRef.Wrap(node);
-        nodeRef_1.NodeRef.AddChild(rootRef, nodeRef);
-    }
-    Component.Attach = Attach;
-})(Component = exports.Component || (exports.Component = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Component = void 0;
+const nodeRef_1 = require("./nodeRef");
+const componentNode_1 = require("./componentNode");
+const decorators_1 = require("../Utils/decorators");
+const observableScope_1 = require("../Store/Tree/observableScope");
+class Component {
+    nodeRef;
+    componentEvents;
+    scope;
+    templates;
+    decoratorMap;
+    get Injector() {
+        return this.nodeRef.injector;
+    }
+    get Destroyed() {
+        return this.nodeRef.destroyed;
+    }
+    get DecoratorMap() {
+        return this.decoratorMap;
+    }
+    get Scope() {
+        return this.scope;
+    }
+    get Data() {
+        return this.scope.Value;
+    }
+    get NodeRef() {
+        return this.nodeRef;
+    }
+    get Templates() {
+        return this.templates;
+    }
+    constructor(data, templates, nodeRef, componentEvents) {
+        this.nodeRef = nodeRef;
+        this.componentEvents = componentEvents;
+        this.scope = new observableScope_1.ObservableScope(data);
+        this.templates = templates || {};
+        this.decoratorMap = new Map();
+    }
+    Template() {
+        return [];
+    }
+    Bound() {
+    }
+    Fire(event, data) {
+        var eventCallback = this.componentEvents && this.componentEvents[event];
+        eventCallback && eventCallback(data);
+    }
+    Destroy() {
+        decorators_1.Destroy.All(this);
+    }
+}
+exports.Component = Component;
+(function (Component) {
+    function ToFunction(type, namespace, constructor) {
+        return componentNode_1.ComponentNode.ToFunction(type, namespace, constructor);
+    }
+    Component.ToFunction = ToFunction;
+    function Register(name, constructor) {
+        const componentFunction = ToFunction(`${name}-component`, undefined, constructor);
+        class WebComponent extends HTMLElement {
+            constructor() {
+                super();
+                const shadowRoot = this.attachShadow({ mode: 'open' });
+                const node = componentFunction({});
+                Attach(shadowRoot, node);
+            }
+        }
+        customElements.define(name, WebComponent);
+    }
+    Component.Register = Register;
+    function Attach(node, nodeRef) {
+        nodeRef_1.NodeRef.Init(nodeRef);
+        var rootRef = nodeRef_1.NodeRef.Wrap(node);
+        nodeRef_1.NodeRef.AddChild(rootRef, nodeRef);
+    }
+    Component.Attach = Attach;
+})(Component || (exports.Component = Component = {}));

package/Node/componentNode.d.ts

@@ -1,7 +1,7 @@
-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;
-}
+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;
+}