j-templates 6.1.12 → 7.0.0

package/Node/vNode.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vNode = void 0;
+const Store_1 = require("../Store");
+const injector_1 = require("../Utils/injector");
+const list_1 = require("../Utils/list");
+const thread_1 = require("../Utils/thread");
+const nodeConfig_1 = require("./nodeConfig");
+var vNode;
+(function (vNode) {
+    function Create(definition) {
+        return {
+            definition,
+            injector: injector_1.Injector.Current() ?? new injector_1.Injector(),
+            node: null,
+            children: null,
+            destroyed: false,
+            assignProperties: null,
+            assignEvents: null,
+            assignAttributes: null,
+            component: null,
+            scopes: []
+        };
+    }
+    vNode.Create = Create;
+    function Init(vnode) {
+        if (vnode.node !== null)
+            return;
+        InitNode(vnode);
+    }
+    vNode.Init = Init;
+    function InitAll(vnodes) {
+        for (let x = 0; x < vnodes.length; x++)
+            Init(vnodes[x]);
+    }
+    vNode.InitAll = InitAll;
+    function Destroy(vnode) {
+        if (vnode.destroyed)
+            return;
+        vnode.destroyed = true;
+        vnode.assignEvents?.(null);
+        vnode.component?.Destroy();
+        Store_1.ObservableScope.DestroyAll(vnode.scopes);
+        vnode.children && DestroyAll(vnode.children);
+    }
+    vNode.Destroy = Destroy;
+    function DestroyAll(vnodes) {
+        for (let x = 0; x < vnodes.length; x++)
+            Destroy(vnodes[x]);
+    }
+    vNode.DestroyAll = DestroyAll;
+    function ToFunction(type, namespace) {
+        return function (config, children) {
+            const childrenConfig = children ? Array.isArray(children) ? { childrenArray: children } : { children } : undefined;
+            const definition = Object.assign({
+                type,
+                namespace: namespace ?? null
+            }, config, childrenConfig);
+            return Create(definition);
+        };
+    }
+    vNode.ToFunction = ToFunction;
+    function Attach(node, vnode) {
+        Init(vnode);
+        nodeConfig_1.NodeConfig.addChild(node, vnode.node);
+        return vnode;
+    }
+    vNode.Attach = Attach;
+})(vNode || (exports.vNode = vNode = {}));
+function InitNode(vnode) {
+    const { type, namespace, props, attrs, on, data, componentConstructor, children, childrenArray } = vnode.definition;
+    const node = nodeConfig_1.NodeConfig.createNode(type, namespace);
+    vnode.node = node;
+    if (props) {
+        vnode.assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
+        if (typeof props === 'function') {
+            const scope = Store_1.ObservableScope.Create(props);
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, CreateScheduledCallback(function () {
+                const value = Store_1.ObservableScope.Peek(scope);
+                vnode.assignProperties(value);
+            }));
+            const value = Store_1.ObservableScope.Peek(scope);
+            vnode.assignProperties(value);
+        }
+        else {
+            vnode.assignProperties(props);
+            vnode.assignProperties = null;
+        }
+    }
+    if (on) {
+        vnode.assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
+        if (typeof on === 'function') {
+            const scope = Store_1.ObservableScope.Create(on);
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, CreateScheduledCallback(function () {
+                const value = Store_1.ObservableScope.Peek(scope);
+                vnode.assignEvents(value);
+            }));
+            const value = Store_1.ObservableScope.Peek(scope);
+            vnode.assignEvents(value);
+        }
+        else
+            vnode.assignEvents(on);
+    }
+    if (attrs) {
+        vnode.assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
+        if (typeof attrs === 'function') {
+            const scope = Store_1.ObservableScope.Create(attrs);
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, CreateScheduledCallback(function () {
+                const value = Store_1.ObservableScope.Peek(scope);
+                vnode.assignAttributes(value);
+            }));
+            const value = Store_1.ObservableScope.Peek(scope);
+            vnode.assignAttributes(value);
+        }
+        else {
+            vnode.assignAttributes(attrs);
+            vnode.assignAttributes = null;
+        }
+    }
+    if (componentConstructor) {
+        vnode.component = new componentConstructor(vnode);
+        const componentScope = Store_1.ObservableScope.Create(function () {
+            let nodes = vnode.component.Template();
+            if (!Array.isArray(nodes))
+                nodes = [nodes];
+            return nodes;
+        });
+        vnode.scopes.push(componentScope);
+        Store_1.ObservableScope.Watch(componentScope, CreateScheduledCallback(function () {
+            const nodes = Store_1.ObservableScope.Peek(componentScope);
+            vNode.DestroyAll(vnode.children);
+            vnode.children = nodes;
+            UpdateChildren(vnode);
+        }));
+        const nodes = Store_1.ObservableScope.Peek(componentScope);
+        vnode.children = nodes;
+    }
+    else if (childrenArray) {
+        vnode.children = childrenArray;
+    }
+    else if (children) {
+        if (data) {
+            DynamicChildren(vnode, children, ToArray(data));
+        }
+        else
+            StaticChildren(vnode, children);
+    }
+    UpdateChildren(vnode, true);
+}
+function StaticChildren(vnode, children) {
+    const childrenScope = Store_1.ObservableScope.Create(WrapStaticChildren(vnode.injector, children));
+    const child = Store_1.ObservableScope.Peek(childrenScope);
+    if (typeof child === 'string') {
+        const node = vNode.Create({
+            type: 'text',
+            namespace: null,
+            props() {
+                return { nodeValue: Store_1.ObservableScope.Value(childrenScope) };
+            }
+        });
+        node.scopes.push(childrenScope);
+        vnode.children = [node];
+    }
+    else {
+        vnode.scopes.push(childrenScope);
+        Store_1.ObservableScope.Touch(childrenScope);
+        Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function () {
+            vNode.DestroyAll(vnode.children);
+            const nodes = Store_1.ObservableScope.Peek(childrenScope);
+            vnode.children = Array.isArray(nodes) ? nodes : [nodes];
+            UpdateChildren(vnode);
+        }));
+        vnode.children = Array.isArray(child) ? child : [child];
+    }
+}
+function WrapStaticChildren(injector, children) {
+    return function () {
+        return injector_1.Injector.Scope(injector, children, undefined);
+    };
+}
+function DestroyNodeList(nodeList) {
+    for (let node = nodeList.head; node !== null; node = node.next) {
+        vNode.DestroyAll(node.data.nodes);
+        Store_1.ObservableScope.Destroy(node.data.scope);
+    }
+}
+function DynamicChildren(vnode, children, data) {
+    const dataScope = Store_1.ObservableScope.Create(data);
+    vnode.scopes.push(dataScope);
+    const nodeList = list_1.List.Create();
+    const childrenScope = Store_1.ObservableScope.Create(WrapDynamicChildren(dataScope, nodeList, vnode.injector, children));
+    vnode.scopes.push(childrenScope);
+    Store_1.ObservableScope.OnDestroyed(dataScope, function () {
+        DestroyNodeList(nodeList);
+    });
+    Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function () {
+        vnode.children = Store_1.ObservableScope.Peek(childrenScope);
+        UpdateChildren(vnode);
+    }));
+    vnode.children = Store_1.ObservableScope.Value(childrenScope);
+}
+function WrapDynamicChildren(dataScope, nodeList, injector, children) {
+    return function () {
+        const nextData = Store_1.ObservableScope.Value(dataScope);
+        const nodeMap = list_1.List.ToNodeMap(nodeList, function (data) { return data.data; });
+        const nextNodeList = list_1.List.Create();
+        const nextNodeArray = [];
+        for (let x = 0; x < nextData.length; x++) {
+            const data = nextData[x];
+            const existingNodeArray = nodeMap.get(data);
+            let existingNode = null;
+            ;
+            for (let x = 0; existingNodeArray && x < existingNodeArray.length && existingNode === null; x++) {
+                existingNode = existingNodeArray[x];
+                existingNodeArray[x] = null;
+            }
+            if (existingNode !== null) {
+                list_1.List.RemoveNode(nodeList, existingNode);
+                list_1.List.AddNode(nextNodeList, existingNode);
+                if (existingNode.data.scope.dirty) {
+                    const newNodes = Store_1.ObservableScope.Value(existingNode.data.scope);
+                    vNode.DestroyAll(existingNode.data.nodes);
+                    existingNode.data.nodes = newNodes;
+                    existingNode.data.nodes = Store_1.ObservableScope.Value(existingNode.data.scope);
+                }
+            }
+            else {
+                const childrenScope = Store_1.ObservableScope.Create(function () {
+                    const childNodes = injector_1.Injector.Scope(injector, children, data);
+                    return Array.isArray(childNodes) ? childNodes : [childNodes];
+                });
+                list_1.List.Add(nextNodeList, {
+                    data,
+                    nodes: Store_1.ObservableScope.Value(childrenScope),
+                    scope: childrenScope
+                });
+            }
+            nextNodeArray.push(...nextNodeList.tail.data.nodes);
+        }
+        DestroyNodeList(nodeList);
+        list_1.List.Clear(nodeList);
+        list_1.List.Append(nodeList, nextNodeList);
+        return nextNodeArray;
+    };
+}
+function UpdateChildren(vnode, init = false) {
+    if (!vnode.children)
+        return;
+    const children = vnode.children;
+    (0, thread_1.Thread)(function () {
+        if (vnode.destroyed || children !== vnode.children)
+            return;
+        for (let x = 0; x < children.length; x++)
+            if (children[x].node === null) {
+                const childNode = children[x];
+                (0, thread_1.Schedule)(function () {
+                    if (vnode.destroyed || children !== vnode.children)
+                        return;
+                    vNode.Init(childNode);
+                });
+            }
+        (0, thread_1.Thread)(function (async) {
+            if (vnode.destroyed || children !== vnode.children)
+                return;
+            if (init || !async)
+                nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, vnode.children.map(vnode => vnode.node));
+            else
+                nodeConfig_1.NodeConfig.scheduleUpdate(function () {
+                    if (vnode.destroyed || children !== vnode.children)
+                        return;
+                    nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, vnode.children.map(vnode => vnode.node));
+                });
+        });
+    });
+}
+function ToArray(callback) {
+    return function (...args) {
+        const result = callback(...args);
+        if (Array.isArray(result))
+            return result;
+        if (!result)
+            return [];
+        return [result];
+    };
+}
+function CreateScheduledCallback(callback) {
+    let scheduled = false;
+    return function () {
+        if (scheduled)
+            return;
+        nodeConfig_1.NodeConfig.scheduleUpdate(callback);
+    };
+}

package/Node/vNode.types.d.ts

@@ -0,0 +1,45 @@
+import { Component } from "./component";
+import { IObservableScope } from "../Store/Tree/observableScope";
+import { Injector } from "../Utils/injector";
+import { RecursivePartial } from "../Utils/utils.types";
+export type FunctionOr<T> = {
+    (): T | Promise<T>;
+} | T;
+export type vNodeEvents<E extends {
+    [event: string]: any;
+} = any> = {
+    [P in keyof E]?: {
+        (events: E[P]): void;
+    };
+};
+export type vNode = {
+    definition: vNodeDefinition<any, any, any>;
+    injector: Injector;
+    node: Node | null;
+    children: vNode[] | null;
+    destroyed: boolean;
+    assignProperties: (next: any) => void;
+    assignEvents: (next: {
+        [event: string]: (event: Event) => void;
+    }) => void;
+    assignAttributes: (next: {
+        [attr: string]: string;
+    }) => void;
+    scopes: IObservableScope<unknown>[];
+    component: Component;
+};
+export type vNodeDefinition<P = HTMLElement, E = HTMLElementEventMap, T = never> = {
+    type: string;
+    namespace: string | null;
+    props?: FunctionOr<RecursivePartial<P>>;
+    attrs?: FunctionOr<{
+        [name: string]: string;
+    }>;
+    on?: FunctionOr<vNodeEvents<E>>;
+    data?: () => T | Array<T> | Promise<Array<T>> | Promise<T>;
+    children?: (data: T) => string | vNode | vNode[];
+    childrenArray?: vNode[];
+    componentConstructor?: {
+        new (vnode: vNode): Component<any, any, any>;
+    };
+};

package/Store/Tree/observableNode.js

@@ -131,8 +131,7 @@ function CreateProxyFactory(alias) {
                 case "shift":
                 case "sort":
                 case "reverse":
-                    if (readOnly)
-                        throw `Object is readonly`;
+                    throw "Object is readonly";
             }
         switch (prop) {
             case exports.IS_OBSERVABLE_NODE:

package/Store/Tree/observableScope.d.ts

@@ -52,6 +52,7 @@ export declare namespace ObservableScope {
     }): IObservableScope<T>;
     function Register(emitter: Emitter): void;
     function Init<T>(scope: IObservableScope<T>): void;
+    function Peek<T>(scope: IObservableScope<T>): T;
     function Value<T>(scope: IObservableScope<T>): T;
     function Touch<T>(scope: IObservableScope<T>): void;
     function Watch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
@@ -59,5 +60,6 @@ export declare namespace ObservableScope {
     function OnDestroyed(scope: IObservableScope<unknown>, callback: () => void): void;
     function Update(scope: IObservableScope<any>): void;
     function Destroy<T>(scope: IObservableScope<T>): void;
+    function DestroyAll(scopes: IObservableScope<unknown>[]): void;
 }
 export {};

package/Store/Tree/observableScope.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = exports.ObservableScopeWrapper = exports.ObservableScopeValue = void 0;
 exports.CalcScope = CalcScope;
 const array_1 = require("../../Utils/array");
-const avlTree_1 = require("../../Utils/avlTree");
+const distinctArray_1 = require("../../Utils/distinctArray");
 const emitter_1 = require("../../Utils/emitter");
 class ObservableScopeValue {
     get Value() {
@@ -51,9 +51,11 @@ exports.ObservableScope = ObservableScope;
 let watchState = null;
 function WatchScope(scope) {
     const parent = watchState;
-    watchState = [avlTree_1.AVL.Create(emitter_1.Emitter.Compare), []];
+    watchState = [distinctArray_1.DistinctArray.Create(emitter_1.Emitter.GetId), []];
     const value = scope.getFunction();
-    const result = [value, avlTree_1.AVL.ToArray(watchState[0]), watchState[1]];
+    const emitters = distinctArray_1.DistinctArray.Get(watchState[0]);
+    emitters.sort(emitter_1.Emitter.Compare);
+    const result = [value, emitters, watchState[1]];
     watchState = parent;
     return result;
 }
@@ -89,7 +91,7 @@ function CalcScope(callback) {
     function Register(emitter) {
         if (watchState === null)
             return;
-        avlTree_1.AVL.Insert(watchState[0], emitter);
+        distinctArray_1.DistinctArray.Push(watchState[0], emitter);
     }
     ObservableScope.Register = Register;
     function Init(scope) {
@@ -98,13 +100,19 @@ function CalcScope(callback) {
         UpdateValue(scope);
     }
     ObservableScope.Init = Init;
-    function Value(scope) {
+    function Peek(scope) {
         if (!scope)
             return undefined;
-        Register(scope.emitter);
         UpdateValue(scope);
         return scope.value;
     }
+    ObservableScope.Peek = Peek;
+    function Value(scope) {
+        if (!scope)
+            return undefined;
+        Touch(scope);
+        return Peek(scope);
+    }
     ObservableScope.Value = Value;
     function Touch(scope) {
         if (!scope || !scope.emitter)
@@ -139,6 +147,11 @@ function CalcScope(callback) {
         DestroyScope(scope);
     }
     ObservableScope.Destroy = Destroy;
+    function DestroyAll(scopes) {
+        for (let x = 0; x < scopes.length; x++)
+            Destroy(scopes[x]);
+    }
+    ObservableScope.DestroyAll = DestroyAll;
 })(ObservableScope || (exports.ObservableScope = ObservableScope = {}));
 function CalcChanged(calc) {
     const value = calc.getFunction();
@@ -150,7 +163,16 @@ function DirtyScope(scope) {
     if (scope.dirty || !scope.getFunction)
         return;
     scope.dirty = scope.calcFunctions.length === 0 || scope.calcFunctions.some(CalcChanged);
-    scope.dirty && emitter_1.Emitter.Emit(scope.emitter, scope);
+    if (!scope.dirty)
+        return;
+    if (scope.async) {
+        UpdateValue(scope);
+        scope.promise.then(function () {
+            emitter_1.Emitter.Emit(scope.emitter, scope);
+        });
+    }
+    else
+        emitter_1.Emitter.Emit(scope.emitter, scope);
 }
 const scopeQueue = new Set();
 function ProcessScopeQueue() {
@@ -178,7 +200,6 @@ function UpdateValue(scope) {
     if (scope.async) {
         scope.promise = value.then(function (result) {
             scope.value = result;
-            emitter_1.Emitter.Emit(scope.emitter, scope);
             return result;
         });
     }

package/Utils/avlTree.js

@@ -30,7 +30,7 @@ var AVL;
     }
     AVL.Insert = Insert;
     function ForEach(tree, callback) {
-        PreOrder(tree.root, callback);
+        InOrder(tree.root, callback);
     }
     AVL.ForEach = ForEach;
     function ToArray(tree) {
@@ -43,12 +43,12 @@ var AVL;
     }
     AVL.ToArray = ToArray;
 })(AVL || (exports.AVL = AVL = {}));
-function PreOrder(node, callback) {
+function InOrder(node, callback) {
     if (node === null)
         return;
-    PreOrder(node[LEFT], callback);
+    InOrder(node[LEFT], callback);
     callback(node[VALUE]);
-    PreOrder(node[RIGHT], callback);
+    InOrder(node[RIGHT], callback);
 }
 function CreateTree(compare) {
     return {
@@ -63,10 +63,9 @@ function CreateNode(value) {
 function InsertValue(tree, value) {
     const startSize = tree.size;
     let node = tree.root;
-    let comp = 0;
     const path = [];
     while (node !== null) {
-        comp = Squash(tree.compare(value, node[VALUE]));
+        const comp = Squash(tree.compare(value, node[VALUE]));
         path.push([comp, node]);
         switch (comp) {
             case 0:

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

@@ -1,6 +1,6 @@
 export type DistinctArray<T> = {
     id: (value: T) => number;
-    distinct: T[];
+    distinct: boolean[];
     array: T[];
 };
 export declare namespace DistinctArray {

package/Utils/distinctArray.js

@@ -13,8 +13,8 @@ var DistinctArray;
     DistinctArray.Create = Create;
     function Push({ id, distinct, array }, value) {
         const vId = id(value);
-        if (distinct[vId] === undefined) {
-            distinct[vId] = value;
+        if (!distinct[vId]) {
+            distinct[vId] = true;
             array.push(value);
         }
     }

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.12",
+  "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;
-}