j-templates 7.0.50 → 7.0.52

package/DOM/createPropertyAssignment.js

@@ -37,7 +37,7 @@ function AssignValue(target, value) {
     const start = target.selectionStart;
     const end = target.selectionEnd;
     target.value = value;
-    if (target.ownerDocument.activeElement = target)
+    if (target.ownerDocument.activeElement === target)
         target.setSelectionRange(start, end);
 }
 function AssignClassName(target, value) {

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,11 +24,9 @@ export declare class ObservableScope<T> extends ObservableScopeWrapper<T> {
         (): T | Promise<T>;
     });
 }
-interface ICalcFunction<T> {
-    getFunction: {
-        (): T;
-    };
-    value: T;
+interface ICalcObservable<T> {
+    id: string;
+    scope: IObservableScope<T>;
 }
 export interface IObservableScope<T> extends IDestroyable {
     getFunction: {
@@ -41,15 +39,16 @@ export interface IObservableScope<T> extends IDestroyable {
     dirty: boolean;
     emitter: Emitter;
     emitters: (Emitter | null)[];
-    calcFunctions: ICalcFunction<any>[];
+    calcScopes: ICalcObservable<unknown>[] | null;
+    calc: boolean;
     onDestroyed: Emitter | null;
     destroyed: boolean;
 }
-export declare function CalcScope<T>(callback: () => T): T;
+export declare function CalcScope<T>(callback: () => T): any;
 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;

package/Store/Tree/observableScope.js

@@ -51,25 +51,42 @@ 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];
+    for (let x = 0; calcScopes && x < calcScopes.length; x++)
+        ObservableScope.Destroy(calcScopes[x]?.scope);
+    scope.calcScopes = watchState[2];
     watchState = parent;
-    return result;
+    return value;
 }
 function CalcScope(callback) {
-    const value = callback();
-    if (watchState !== null)
-        watchState[1].push({
-            getFunction: callback,
-            value,
-        });
-    return value;
+    if (watchState === null)
+        return callback();
+    watchState[2] ??= [];
+    const currentScopes = watchState[1];
+    const id = callback.toString();
+    if (currentScopes !== null) {
+        let index = 0;
+        for (; currentScopes[index].id !== id; index++) { }
+        if (index < currentScopes.length) {
+            const scope = currentScopes[index];
+            currentScopes[index] = null;
+            watchState[2].push(scope);
+            return ObservableScope.Value(scope.scope);
+        }
+    }
+    const scope = ObservableScope.Create(callback, true);
+    watchState[2].push({
+        id,
+        scope,
+    });
+    return ObservableScope.Value(scope);
 }
 (function (ObservableScope) {
-    function Create(valueFunction) {
+    function Create(valueFunction, calc = false) {
         const scope = {
             getFunction: valueFunction,
             value: null,
@@ -78,9 +95,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,14 +174,15 @@ 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)
+    if (scope.calc) {
+        const startVal = scope.value;
+        scope.dirty = true;
+        UpdateValue(scope);
+        if (startVal !== scope.value)
+            emitter_1.Emitter.Emit(scope.emitter);
         return;
+    }
+    scope.dirty = true;
     if (scope.async) {
         UpdateValue(scope);
     }
@@ -185,7 +204,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 +216,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 +228,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);
@@ -241,7 +259,8 @@ function DestroyScope(scope) {
     scope.emitter = null;
     scope.getFunction = null;
     scope.setCallback = null;
-    scope.calcFunctions = null;
+    for (let x = 0; scope.calcScopes && x < scope.calcScopes.length; x++)
+        ObservableScope.Destroy(scope.calcScopes[x].scope);
     scope.destroyed = true;
     scope.onDestroyed !== null && emitter_1.Emitter.Emit(scope.onDestroyed);
 }

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/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.50",
+  "version": "7.0.52",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",