j-templates 7.0.51 → 7.0.53

package/DOM/domNodeConfig.d.ts

@@ -1,2 +1,2 @@
-import { INodeConfig } from '../Node/nodeConfig';
+import { INodeConfig } from "../Node/nodeConfig";
 export declare const DOMNodeConfig: INodeConfig;

package/DOM/domNodeConfig.js

@@ -51,13 +51,13 @@ function wrapPriorityUpdates(callback) {
 }
 exports.DOMNodeConfig = {
     createNode(type, namespace) {
-        if (type === 'text')
-            return window_1.wndw.document.createTextNode('');
-        return namespace ?
-            window_1.wndw.document.createElementNS(namespace, type) :
-            window_1.wndw.document.createElement(type);
+        if (type === "text")
+            return window_1.wndw.document.createTextNode("");
+        return namespace
+            ? window_1.wndw.document.createElementNS(namespace, type)
+            : window_1.wndw.document.createElement(type);
     },
-    createTextNode(value = '') {
+    createTextNode(value = "") {
         return window_1.wndw.document.createTextNode(value);
     },
     isTextNode(target) {
@@ -143,8 +143,15 @@ exports.DOMNodeConfig = {
     },
     reconcileChildren(target, children) {
         if (!target.firstChild) {
-            for (let x = 0; x < children.length; x++)
-                target.appendChild(children[x]);
+            if (children.length > 10) {
+                const fragment = new DocumentFragment();
+                for (let x = 0; x < children.length; x++)
+                    fragment.appendChild(children[x]);
+                target.appendChild(fragment);
+            }
+            else
+                for (let x = 0; x < children.length; x++)
+                    target.appendChild(children[x]);
             return;
         }
         if (children.length === 0) {
@@ -172,7 +179,14 @@ exports.DOMNodeConfig = {
         }
         while (target.lastChild !== children[x - 1])
             target.removeChild(target.lastChild);
-        for (; x < children.length; x++)
-            target.appendChild(children[x]);
-    }
+        if (children.length - x > 10) {
+            const fragment = new DocumentFragment();
+            for (; x < children.length; x++)
+                fragment.appendChild(children[x]);
+            target.appendChild(fragment);
+        }
+        else
+            for (; x < children.length; x++)
+                target.appendChild(children[x]);
+    },
 };

package/Node/vNode.d.ts

@@ -10,6 +10,7 @@ type vNodeConfig<P = HTMLElement, E = HTMLElementEventMap, T = never> = {
 };
 export declare namespace vNode {
     function Create<P = HTMLElement, E = HTMLElementEventMap, T = never>(definition: vNodeDefinition<P, E, T>): vNodeType;
+    function CreateText(text: string): vNodeType;
     function Init(vnode: vNodeType): void;
     function InitAll(vnodes: vNodeType[]): void;
     function Destroy(vnode: vNodeType): void;

package/Node/vNode.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.vNode = void 0;
 const Store_1 = require("../Store");
+const emitter_1 = require("../Utils/emitter");
 const injector_1 = require("../Utils/injector");
 const list_1 = require("../Utils/list");
 const thread_1 = require("../Utils/thread");
@@ -16,11 +17,26 @@ var vNode;
             node: definition.node ?? null,
             children: null,
             destroyed: false,
+            onDestroyed: null,
             component: null,
             scopes: [],
         };
     }
     vNode.Create = Create;
+    function CreateText(text) {
+        return {
+            definition: null,
+            type: "text",
+            injector: null,
+            node: nodeConfig_1.NodeConfig.createTextNode(text),
+            children: null,
+            destroyed: false,
+            onDestroyed: null,
+            component: null,
+            scopes: [],
+        };
+    }
+    vNode.CreateText = CreateText;
     function Init(vnode) {
         if (vnode.definition === null)
             return;
@@ -38,6 +54,7 @@ var vNode;
         vnode.destroyed = true;
         vnode.component?.Destroy();
         Store_1.ObservableScope.DestroyAll(vnode.scopes);
+        vnode.onDestroyed && emitter_1.Emitter.Emit(vnode.onDestroyed);
         vnode.children && DestroyAll(vnode.children);
     }
     vNode.Destroy = Destroy;
@@ -70,7 +87,8 @@ var vNode;
 })(vNode || (exports.vNode = vNode = {}));
 function InitNode(vnode) {
     const { type, namespace, props, attrs, on, data, componentConstructor, children, childrenArray, } = vnode.definition;
-    const node = (vnode.node = vnode.definition.node ?? nodeConfig_1.NodeConfig.createNode(type, namespace));
+    const node = (vnode.node =
+        vnode.definition.node ?? nodeConfig_1.NodeConfig.createNode(type, namespace));
     vnode.definition = null;
     if (props) {
         const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
@@ -95,6 +113,11 @@ function InitNode(vnode) {
         }
         else
             assignEvents(on);
+        vnode.onDestroyed ??= emitter_1.Emitter.Create();
+        emitter_1.Emitter.On(vnode.onDestroyed, function () {
+            assignEvents(null);
+            return true;
+        });
     }
     if (attrs) {
         const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
@@ -112,7 +135,9 @@ function InitNode(vnode) {
         vnode.component = new componentConstructor(vnode);
         vnode.component.Bound();
         const componentScope = Store_1.ObservableScope.Create(function () {
-            let nodes = injector_1.Injector.Scope(vnode.injector, function () { return vnode.component.Template(); });
+            let nodes = injector_1.Injector.Scope(vnode.injector, function () {
+                return vnode.component.Template();
+            });
             if (!Array.isArray(nodes))
                 nodes = [nodes];
             return nodes;
@@ -144,8 +169,9 @@ function Children(vnode, children, data) {
     Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
         if (vnode.destroyed)
             return;
+        const startChildren = vnode.children;
         AssignChildren(vnode, scope);
-        UpdateChildren(vnode);
+        startChildren !== vnode.children && UpdateChildren(vnode);
     }));
     AssignChildren(vnode, childrenScope);
 }
@@ -166,6 +192,7 @@ function CreateChildrenScope(vnode, children, data) {
     Store_1.ObservableScope.OnDestroyed(scope, function () {
         DestroyNodeList(nodeList);
         Store_1.ObservableScope.Destroy(dataScope);
+        return true;
     });
     return scope;
 }
@@ -209,7 +236,7 @@ function WrapChildren(injector, children, data, nodeList) {
                         list_1.List.Add(nextNodeList, {
                             data,
                             nodes: Store_1.ObservableScope.Value(childrenScope),
-                            scope: childrenScope
+                            scope: childrenScope,
                         });
                     }
                     nextNodeArray.push(...nextNodeList.tail.data.nodes);
@@ -225,14 +252,21 @@ function WrapChildren(injector, children, data, nodeList) {
 function CreateNodeArray(children, previousChildren) {
     if (Array.isArray(children))
         return children;
-    return typeof children === 'string' ? [vNode.Create({
-            type: 'text',
-            namespace: null,
-            node: previousChildren?.[0]?.type === 'text' && previousChildren[0].node || undefined,
-            props: {
-                nodeValue: children
-            }
-        })] : [children];
+    if (typeof children === "string") {
+        const firstPrevChild = previousChildren?.[0];
+        if (firstPrevChild &&
+            firstPrevChild.node &&
+            firstPrevChild.type === "text") {
+            nodeConfig_1.NodeConfig.setText(firstPrevChild.node, children);
+            return previousChildren.length === 1
+                ? previousChildren
+                : [firstPrevChild];
+        }
+        return [
+            vNode.CreateText(children),
+        ];
+    }
+    return [children];
 }
 function DestroyNodeList(nodeList) {
     for (let node = nodeList.head; node !== null; node = node.next) {
@@ -251,6 +285,10 @@ function AssignChildren(vnode, childrenScope) {
 function UpdateChildren(vnode, init = false, skipInit = false) {
     if (!vnode.children)
         return;
+    if (vnode.children.length === 1 && vnode.children[0].type === "text") {
+        nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, [vnode.children[0].node]);
+        return;
+    }
     const children = vnode.children;
     (0, thread_1.Thread)(function () {
         if (vnode.destroyed || children !== vnode.children)

package/Node/vNode.types.d.ts

@@ -2,6 +2,7 @@ import { Component } from "./component";
 import { IObservableScope } from "../Store/Tree/observableScope";
 import { Injector } from "../Utils/injector";
 import { RecursivePartial } from "../Utils/utils.types";
+import { Emitter } from "../Utils/emitter";
 export type FunctionOr<T> = {
     (): T | Promise<T>;
 } | T;
@@ -20,6 +21,7 @@ export type vNode = {
     node: Node | null;
     children: vNode[] | null;
     destroyed: boolean;
+    onDestroyed: Emitter | null;
     scopes: IObservableScope<unknown>[];
     component: Component;
 };

package/Store/Tree/observableNode.d.ts

@@ -3,6 +3,7 @@ export declare const IS_OBSERVABLE_NODE = "____isObservableNode";
 export declare const GET_OBSERVABLE_VALUE = "____getObservableValue";
 export declare const GET_TO_JSON = "toJSON";
 export declare namespace ObservableNode {
+    function BypassProxy(value: boolean): void;
     function Create<T>(value: T): T;
     function Touch(value: unknown, prop?: string | number): void;
     function ApplyDiff(rootNode: any, diffResult: JsonDiffResult): void;

package/Store/Tree/observableNode.js

@@ -4,6 +4,7 @@ exports.ObservableNode = exports.GET_TO_JSON = exports.GET_OBSERVABLE_VALUE = ex
 const json_1 = require("../../Utils/json");
 const jsonType_1 = require("../../Utils/jsonType");
 const observableScope_1 = require("./observableScope");
+let bypassProxy = false;
 exports.IS_OBSERVABLE_NODE = "____isObservableNode";
 exports.GET_OBSERVABLE_VALUE = "____getObservableValue";
 exports.GET_TO_JSON = "toJSON";
@@ -146,6 +147,8 @@ function CreateProxyFactory(alias) {
                 const scope = scopeCache.get(array);
                 array = observableScope_1.ObservableScope.Value(scope);
                 const arrayValue = array[prop];
+                if (bypassProxy)
+                    return arrayValue;
                 if (typeof prop === "symbol")
                     return arrayValue;
                 if (typeof arrayValue === "function")
@@ -221,6 +224,8 @@ function CreateProxyFactory(alias) {
             case exports.GET_OBSERVABLE_VALUE:
                 return object;
             default: {
+                if (bypassProxy)
+                    return object[prop];
                 return GetAccessorValue(object, prop);
             }
         }
@@ -259,6 +264,10 @@ function CreateProxyFactory(alias) {
 const DefaultCreateProxy = CreateProxyFactory();
 var ObservableNode;
 (function (ObservableNode) {
+    function BypassProxy(value) {
+        bypassProxy = value;
+    }
+    ObservableNode.BypassProxy = BypassProxy;
     function Create(value) {
         return DefaultCreateProxy(value);
     }

package/Store/Tree/observableScope.d.ts

@@ -24,12 +24,6 @@ export declare class ObservableScope<T> extends ObservableScopeWrapper<T> {
         (): T | Promise<T>;
     });
 }
-interface ICalcFunction<T> {
-    getFunction: {
-        (): T;
-    };
-    value: T;
-}
 export interface IObservableScope<T> extends IDestroyable {
     getFunction: {
         (): T;
@@ -41,15 +35,18 @@ export interface IObservableScope<T> extends IDestroyable {
     dirty: boolean;
     emitter: Emitter;
     emitters: (Emitter | null)[];
-    calcFunctions: ICalcFunction<any>[];
+    calcScopes: {
+        [id: string]: IObservableScope<unknown> | null;
+    } | null;
+    calc: boolean;
     onDestroyed: Emitter | null;
     destroyed: boolean;
 }
-export declare function CalcScope<T>(callback: () => T): T;
+export declare function CalcScope<T>(callback: () => T, idOverride?: string): unknown;
 export declare namespace ObservableScope {
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
-    }): IObservableScope<T>;
+    }, calc?: boolean): IObservableScope<T>;
     function Register(emitter: Emitter): void;
     function Init<T>(scope: IObservableScope<T>): void;
     function Peek<T>(scope: IObservableScope<T>): T;
@@ -57,9 +54,8 @@ export declare namespace ObservableScope {
     function Touch<T>(scope: IObservableScope<T>): void;
     function Watch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
     function Unwatch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T> | ObservableScopeValue<T>]>): void;
-    function OnDestroyed(scope: IObservableScope<unknown>, callback: () => void): void;
+    function OnDestroyed(scope: IObservableScope<unknown>, callback: EmitterCallback): 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

@@ -51,25 +51,37 @@ exports.ObservableScope = ObservableScope;
 let watchState = null;
 function WatchScope(scope) {
     const parent = watchState;
-    watchState = [[], []];
+    watchState = [[], scope.calcScopes, null];
     const value = scope.getFunction();
     const emitters = watchState[0];
-    emitter_1.Emitter.Distinct(emitters);
-    const result = [value, emitters, watchState[1]];
+    UpdateEmitters(scope, emitters);
+    const calcScopes = watchState[1];
+    const calcScopeValues = calcScopes && Object.values(calcScopes);
+    for (let x = 0; calcScopeValues && x < calcScopeValues.length; x++)
+        calcScopeValues[x] && ObservableScope.Destroy(calcScopeValues[x]);
+    scope.calcScopes = watchState[2];
     watchState = parent;
-    return result;
-}
-function CalcScope(callback) {
-    const value = callback();
-    if (watchState !== null)
-        watchState[1].push({
-            getFunction: callback,
-            value,
-        });
     return value;
 }
+function CalcScope(callback, idOverride) {
+    if (watchState === null)
+        return callback();
+    const nextScopes = (watchState[2] ??= {});
+    const currentScopes = watchState[1];
+    const id = idOverride ?? callback.toString();
+    const currentScope = currentScopes?.[id];
+    if (currentScope) {
+        delete currentScopes[id];
+        nextScopes[id] = currentScope;
+    }
+    else if (!nextScopes[id]) {
+        const scope = ObservableScope.Create(callback, true);
+        nextScopes[id] = scope;
+    }
+    return ObservableScope.Value(nextScopes[id]);
+}
 (function (ObservableScope) {
-    function Create(valueFunction) {
+    function Create(valueFunction, calc = false) {
         const scope = {
             getFunction: valueFunction,
             value: null,
@@ -78,9 +90,10 @@ function CalcScope(callback) {
             dirty: true,
             emitter: emitter_1.Emitter.Create(),
             emitters: null,
-            calcFunctions: null,
-            onDestroyed: null,
+            calcScopes: null,
+            calc,
             destroyed: false,
+            onDestroyed: null,
             setCallback: function () {
                 return OnSet(scope);
             },
@@ -156,16 +169,13 @@ function CalcScope(callback) {
 function DirtyScope(scope) {
     if (scope.dirty || !scope.getFunction)
         return;
-    let dirty = scope.calcFunctions.length === 0;
-    for (let x = 0; !dirty && x < scope.calcFunctions.length; x++) {
-        const calc = scope.calcFunctions[x];
-        dirty = dirty || calc.value !== calc.getFunction();
-    }
-    scope.dirty = dirty;
-    if (!scope.dirty)
-        return;
-    if (scope.async) {
+    scope.dirty = true;
+    if (scope.async)
+        UpdateValue(scope);
+    else if (scope.calc) {
+        const startValue = scope.value;
         UpdateValue(scope);
+        startValue !== scope.value && emitter_1.Emitter.Emit(scope.emitter);
     }
     else
         emitter_1.Emitter.Emit(scope.emitter, scope);
@@ -185,7 +195,7 @@ function ProcessScopeQueue() {
 function OnSet(scope) {
     if (scope.destroyed)
         return true;
-    if (scope.async || scope.calcFunctions.length > 0) {
+    if (scope.async || scope.calc) {
         if (scopeQueue.length === 0)
             queueMicrotask(ProcessScopeQueue);
         scopeQueue.push(scope);
@@ -197,7 +207,7 @@ function UpdateValue(scope) {
     if (!scope.dirty)
         return;
     scope.dirty = false;
-    const [value, emitters, calcFunctions] = WatchScope(scope);
+    const value = WatchScope(scope);
     if (scope.async) {
         scope.promise = value.then(function (result) {
             if (scope.destroyed)
@@ -209,10 +219,9 @@ function UpdateValue(scope) {
     }
     else
         scope.value = value;
-    scope.calcFunctions = calcFunctions;
-    UpdateEmitters(scope, emitters);
 }
 function UpdateEmitters(scope, right) {
+    emitter_1.Emitter.Distinct(right);
     if (scope.emitters === null) {
         for (let x = 0; x < right.length; x++)
             emitter_1.Emitter.On(right[x], scope.setCallback);
@@ -237,11 +246,14 @@ function UpdateEmitters(scope, right) {
 function DestroyScope(scope) {
     if (!scope)
         return;
+    const scopes = scope.calcScopes && Object.values(scope.calcScopes);
+    scopes && ObservableScope.DestroyAll(scopes);
+    scope.calcScopes = null;
     scope.emitters = null;
+    emitter_1.Emitter.Clear(scope.emitter);
     scope.emitter = null;
     scope.getFunction = null;
     scope.setCallback = null;
-    scope.calcFunctions = null;
     scope.destroyed = true;
-    scope.onDestroyed !== null && emitter_1.Emitter.Emit(scope.onDestroyed);
+    scope.onDestroyed && emitter_1.Emitter.Emit(scope.onDestroyed);
 }

package/Utils/array.d.ts

@@ -1,4 +1,5 @@
 export declare function RemoveNulls(array: (unknown | null)[], startIndex?: number): void;
 export declare function ArrayDiff(source: any[], target: any[]): boolean;
 export declare function ReconcileSortedEmitters<T extends [number]>(left: T[], right: T[], add: (value: T) => void, remove: (value: T) => void): void;
+export declare function InsertionSortTuples<T extends [number, ...any[]]>(arr: T[]): T[];
 export declare function ReconcileSortedArrays<T>(left: T[], right: T[], add: (value: T) => void, remove: (value: T) => void): void;

package/Utils/array.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoveNulls = RemoveNulls;
 exports.ArrayDiff = ArrayDiff;
 exports.ReconcileSortedEmitters = ReconcileSortedEmitters;
+exports.InsertionSortTuples = InsertionSortTuples;
 exports.ReconcileSortedArrays = ReconcileSortedArrays;
 function RemoveNulls(array, startIndex = 0) {
     let nullIndex = startIndex;
@@ -50,6 +51,19 @@ function ReconcileSortedEmitters(left, right, add, remove) {
     for (let ri = rightIndex; ri < right.length; ri++)
         add(right[ri]);
 }
+function InsertionSortTuples(arr) {
+    const n = arr.length;
+    for (let i = 1; i < n; i++) {
+        const currentItem = arr[i];
+        let j = i - 1;
+        while (j >= 0 && arr[j][0] > currentItem[0]) {
+            arr[j + 1] = arr[j];
+            j--;
+        }
+        arr[j + 1] = currentItem;
+    }
+    return arr;
+}
 function ReconcileSortedArrays(left, right, add, remove) {
     let leftIndex = 0;
     let rightIndex = 0;

package/Utils/decorators.js

@@ -50,17 +50,17 @@ function ComputedDecorator(target, prop, descriptor, defaultValue) {
                 const syncStore = new Store_1.StoreSync();
                 observableScope_1.ObservableScope.Watch(getterScope, (scope) => {
                     const data = observableScope_1.ObservableScope.Value(scope);
-                    syncStore.Write(data, 'root');
+                    syncStore.Write(data, "root");
                 });
                 observableScope_1.ObservableScope.Init(getterScope);
-                const propertyScope = observableScope_1.ObservableScope.Create(() => syncStore.Get('root', defaultValue));
+                const propertyScope = observableScope_1.ObservableScope.Create(() => syncStore.Get("root", defaultValue));
                 observableScope_1.ObservableScope.OnDestroyed(propertyScope, function () {
                     observableScope_1.ObservableScope.Destroy(getterScope);
                 });
                 scopeMap[propertyKey] = [propertyScope, undefined];
             }
             return observableScope_1.ObservableScope.Value(scopeMap[propertyKey][0]);
-        }
+        },
     };
 }
 function ComputedAsync(defaultValue) {
@@ -81,13 +81,13 @@ function ComputedAsyncDecorator(target, prop, descriptor, defaultValue) {
         get: function () {
             const scopeMap = GetScopeMapForInstance(this);
             if (scopeMap[propertyKey] === undefined) {
-                const getterScope = observableScope_1.ObservableScope.Create(async () => getter.call(this));
+                const getterScope = observableScope_1.ObservableScope.Create(() => getter.call(this));
                 const asyncStore = new Store_1.StoreAsync();
                 observableScope_1.ObservableScope.Watch(getterScope, (scope) => {
-                    asyncStore.Write(observableScope_1.ObservableScope.Value(scope), 'root');
+                    asyncStore.Write(observableScope_1.ObservableScope.Value(scope), "root");
                 });
                 observableScope_1.ObservableScope.Init(getterScope);
-                const propertyScope = observableScope_1.ObservableScope.Create(() => asyncStore.Get('root', defaultValue));
+                const propertyScope = observableScope_1.ObservableScope.Create(() => asyncStore.Get("root", defaultValue));
                 observableScope_1.ObservableScope.OnDestroyed(propertyScope, function () {
                     observableScope_1.ObservableScope.Destroy(getterScope);
                     asyncStore.Destroy();
@@ -95,7 +95,7 @@ function ComputedAsyncDecorator(target, prop, descriptor, defaultValue) {
                 scopeMap[propertyKey] = [propertyScope, undefined];
             }
             return observableScope_1.ObservableScope.Value(scopeMap[propertyKey][0]);
-        }
+        },
     };
 }
 function State() {
@@ -113,7 +113,7 @@ function StateDecorator(target, propertyKey) {
         set: function (val) {
             const map = GetNodeMapForInstance(this);
             if (map[propertyKey] === undefined)
-                map[propertyKey] = observableNode_1.ObservableNode.Create({ root: val });
+                map[propertyKey] ??= observableNode_1.ObservableNode.Create({ root: val });
             else
                 map[propertyKey].root = val;
         },
@@ -133,7 +133,7 @@ function ValueDecorator(target, propertyKey) {
         enumerable: true,
         get: function () {
             const propertyMap = GetScopeMapForInstance(this);
-            const tuple = propertyMap[propertyKey] ??= [null, undefined];
+            const tuple = (propertyMap[propertyKey] ??= [null, undefined]);
             tuple[0] ??= CreateValueScope(tuple);
             return observableScope_1.ObservableScope.Value(tuple[0]);
         },

package/Utils/distinctArray.d.ts

@@ -1,10 +1,12 @@
 export type DistinctArray<T> = {
-    id: (value: T) => number;
-    distinct: Array<true | undefined> | null;
+    id: (value: T) => unknown;
+    distinct: Set<unknown> | null;
     array: T[];
 };
 export declare namespace DistinctArray {
-    function Create<T>(id: (value: T) => number): DistinctArray<T>;
+    function Create<T>(id?: (value: T) => unknown): DistinctArray<T>;
     function Push<T>(distinctArr: DistinctArray<T>, value: T): void;
     function Get<T>({ array }: DistinctArray<T>): T[];
+    function Size<T>(distinct: DistinctArray<T>): number;
+    function Clear<T>(distinct: DistinctArray<T>): void;
 }

package/Utils/distinctArray.js

@@ -3,31 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DistinctArray = void 0;
 var DistinctArray;
 (function (DistinctArray) {
-    function Create(id) {
+    function Create(id = (val) => val) {
         return {
             id,
             distinct: null,
-            array: []
+            array: [],
         };
     }
     DistinctArray.Create = Create;
     function Push(distinctArr, value) {
-        const { id, array } = distinctArr;
-        switch (array.length) {
+        switch (distinctArr.array.length) {
             case 0:
-                array.push(value);
+                distinctArr.array.push(value);
                 break;
             case 1: {
                 if (distinctArr.distinct === null) {
-                    distinctArr.distinct = [];
-                    distinctArr.distinct[id(array[0])] = true;
+                    distinctArr.distinct = new Set([
+                        distinctArr.id(distinctArr.array[0]),
+                    ]);
                 }
             }
             default: {
-                const vId = id(value);
-                if (distinctArr.distinct[vId] === undefined) {
-                    distinctArr.distinct[vId] = true;
-                    array.push(value);
+                const vId = distinctArr.id(value);
+                if (!distinctArr.distinct.has(vId)) {
+                    distinctArr.distinct.add(vId);
+                    distinctArr.array.push(value);
                 }
             }
         }
@@ -37,4 +37,13 @@ var DistinctArray;
         return array;
     }
     DistinctArray.Get = Get;
+    function Size(distinct) {
+        return distinct.distinct.size;
+    }
+    DistinctArray.Size = Size;
+    function Clear(distinct) {
+        distinct.array = [];
+        distinct.distinct?.clear();
+    }
+    DistinctArray.Clear = Clear;
 })(DistinctArray || (exports.DistinctArray = DistinctArray = {}));

package/Utils/emitter.d.ts

@@ -8,6 +8,6 @@ export declare namespace Emitter {
     function Remove(emitter: Emitter, callback: EmitterCallback): void;
     function Clear(emitter: Emitter): void;
     function Distinct(emitters: Emitter[]): void;
-    function Sort(emitters: Emitter[]): Emitter[];
+    function Sort(emitters: Emitter[]): void;
     function Compare(a: Emitter, b: Emitter): number;
 }

package/Utils/emitter.js

@@ -21,7 +21,8 @@ var Emitter;
     function Emit(emitter, ...args) {
         let removed = false;
         for (let x = 1; x < emitter.length; x++) {
-            if (emitter[x] === null || emitter[x](...args) === true) {
+            if (emitter[x] === null ||
+                emitter[x](...args) === true) {
                 removed = true;
                 emitter[x] = null;
             }
@@ -41,16 +42,16 @@ var Emitter;
     }
     Emitter.Clear = Clear;
     function Distinct(emitters) {
-        if (emitters.length === 1)
+        if (emitters.length < 2)
             return;
-        emitters.length < 50 ? DistinctSmall(emitters) : DistinctLarge(emitters);
+        emitters.length < 51 ? DistinctSmall(emitters) : DistinctLarge(emitters);
     }
     Emitter.Distinct = Distinct;
     function DistinctSmall(emitters) {
         Sort(emitters);
-        let lastId = -1;
+        let lastId = emitters[0][0];
         let remove = false;
-        for (let x = 0; x < emitters.length; x++) {
+        for (let x = 1; x < emitters.length; x++) {
             const id = emitters[x][0];
             if (lastId === emitters[x][0]) {
                 emitters[x] = null;
@@ -76,7 +77,10 @@ var Emitter;
         Sort(emitters);
     }
     function Sort(emitters) {
-        return emitters.sort(Compare);
+        if (emitters.length < 11)
+            (0, array_1.InsertionSortTuples)(emitters);
+        else
+            emitters.sort(Compare);
     }
     Emitter.Sort = Sort;
     function Compare(a, b) {

package/Utils/injector.d.ts

@@ -3,7 +3,7 @@ export declare class Injector {
     private typeMap;
     constructor();
     Get<T>(type: any): T;
-    Set<T>(type: any, instance: T): void;
+    Set<T>(type: any, instance: T): T;
 }
 export declare namespace Injector {
     function Current(): Injector;

package/Utils/injector.js

@@ -7,15 +7,14 @@ class Injector {
         this.typeMap = new Map();
     }
     Get(type) {
-        if (this.typeMap.size === 0)
-            return this.parent && this.parent.Get(type);
-        var ret = this.typeMap.get(type);
-        if (!ret)
-            ret = this.parent && this.parent.Get(type);
-        return ret;
+        if (this.typeMap.has(type)) {
+            return this.typeMap.get(type);
+        }
+        return this.parent ? this.parent.Get(type) : undefined;
     }
     Set(type, instance) {
         this.typeMap.set(type, instance);
+        return instance;
     }
 }
 exports.Injector = Injector;
@@ -26,11 +25,14 @@ exports.Injector = Injector;
     }
     Injector.Current = Current;
     function Scope(injector, action, ...args) {
-        var parent = Current();
+        const parent = Current();
         scope = injector;
-        const ret = action(...args);
-        scope = parent;
-        return ret;
+        try {
+            return action(...args);
+        }
+        finally {
+            scope = parent;
+        }
     }
     Injector.Scope = Scope;
 })(Injector || (exports.Injector = Injector = {}));

package/Utils/thread.js

@@ -19,7 +19,7 @@ function timeRemaining() {
 function createDeadline() {
     return {
         end: Date.now() + workTimeMs,
-        timeRemaining
+        timeRemaining,
     };
 }
 function ProcessQueue(deadline = createDeadline()) {
@@ -49,7 +49,9 @@ function DoWork(ctx, deadline = createDeadline()) {
     threadContext = ctx;
     const async = ctx.async;
     let callback;
-    while (async === ctx.async && deadline.timeRemaining() > 0 && (callback = list_1.List.Pop(ctx.workList)))
+    while (async === ctx.async &&
+        deadline.timeRemaining() > 0 &&
+        (callback = list_1.List.Pop(ctx.workList)))
         Invoke(ctx, callback);
     if (ctx.workList.size > 0)
         ScheduleWork(ctx);
@@ -59,7 +61,7 @@ function CreateContext() {
     return {
         async: false,
         workEndNode: null,
-        workList: list_1.List.Create()
+        workList: list_1.List.Create(),
     };
 }
 function ScheduleCallback(callback, before, async) {
@@ -89,7 +91,9 @@ function After(callback) {
 }
 function Callback(callback) {
     return function (a, b, c, d) {
-        Schedule(function () { callback(a, b, c, d); });
+        Schedule(function () {
+            callback(a, b, c, d);
+        });
     };
 }
 var inSynchCallback = false;
@@ -109,7 +113,7 @@ function Thread(callback) {
         Synch(callback);
 }
 function ThreadAsync(callback) {
-    return new Promise(resolve => Thread(function (async) {
+    return new Promise((resolve) => Thread(function (async) {
         callback(async);
         Thread(resolve);
     }));

package/package.json

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