j-templates 7.0.47 → 7.0.48

package/Store/Tree/observableNode.d.ts

@@ -3,7 +3,6 @@ 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,7 +4,6 @@ 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";
@@ -147,8 +146,6 @@ 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")
@@ -224,8 +221,6 @@ function CreateProxyFactory(alias) {
             case exports.GET_OBSERVABLE_VALUE:
                 return object;
             default: {
-                if (bypassProxy)
-                    return object[prop];
                 return GetAccessorValue(object, prop);
             }
         }
@@ -264,10 +259,6 @@ 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.js

@@ -3,10 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = exports.ObservableScopeWrapper = exports.ObservableScopeValue = void 0;
 exports.CalcScope = CalcScope;
 const array_1 = require("../../Utils/array");
-const distinctArray_1 = require("../../Utils/distinctArray");
 const emitter_1 = require("../../Utils/emitter");
 const functions_1 = require("../../Utils/functions");
-const observableNode_1 = require("./observableNode");
 class ObservableScopeValue {
     get Value() {
         return ObservableScope.Value(this.scope);
@@ -53,10 +51,10 @@ exports.ObservableScope = ObservableScope;
 let watchState = null;
 function WatchScope(scope) {
     const parent = watchState;
-    watchState = [distinctArray_1.DistinctArray.Create(emitter_1.Emitter.GetId), []];
+    watchState = [[], []];
     const value = scope.getFunction();
-    const emitters = distinctArray_1.DistinctArray.Get(watchState[0]);
-    emitters.sort(emitter_1.Emitter.Compare);
+    const emitters = watchState[0];
+    emitter_1.Emitter.Distinct(emitters);
     const result = [value, emitters, watchState[1]];
     watchState = parent;
     return result;
@@ -93,7 +91,7 @@ function CalcScope(callback) {
     function Register(emitter) {
         if (watchState === null)
             return;
-        distinctArray_1.DistinctArray.Push(watchState[0], emitter);
+        watchState[0].push(emitter);
     }
     ObservableScope.Register = Register;
     function Init(scope) {
@@ -158,13 +156,11 @@ function CalcScope(callback) {
 function DirtyScope(scope) {
     if (scope.dirty || !scope.getFunction)
         return;
-    observableNode_1.ObservableNode.BypassProxy(true);
     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();
     }
-    observableNode_1.ObservableNode.BypassProxy(false);
     scope.dirty = dirty;
     if (!scope.dirty)
         return;
@@ -178,8 +174,13 @@ let scopeQueue = [];
 function ProcessScopeQueue() {
     const scopes = scopeQueue;
     scopeQueue = [];
-    for (let x = 0; x < scopes.length; x++)
-        DirtyScope(scopes[x]);
+    const distinct = new Set();
+    for (let x = 0; x < scopes.length; x++) {
+        if (!distinct.has(scopes[x])) {
+            distinct.add(scopes[x]);
+            DirtyScope(scopes[x]);
+        }
+    }
 }
 function OnSet(scope) {
     if (scope.destroyed)

package/Utils/distinctArray.d.ts

@@ -1,12 +1,10 @@
 export type DistinctArray<T> = {
-    id: (value: T) => unknown;
-    distinct: Set<unknown> | null;
+    id: (value: T) => number;
+    distinct: Array<true | undefined> | null;
     array: T[];
 };
 export declare namespace DistinctArray {
-    function Create<T>(id?: (value: T) => unknown): DistinctArray<T>;
+    function Create<T>(id: (value: T) => number): 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 = (val) => val) {
+    function Create(id) {
         return {
             id,
             distinct: null,
-            array: [],
+            array: []
         };
     }
     DistinctArray.Create = Create;
     function Push(distinctArr, value) {
-        switch (distinctArr.array.length) {
+        const { id, array } = distinctArr;
+        switch (array.length) {
             case 0:
-                distinctArr.array.push(value);
+                array.push(value);
                 break;
             case 1: {
                 if (distinctArr.distinct === null) {
-                    distinctArr.distinct = new Set([
-                        distinctArr.id(distinctArr.array[0]),
-                    ]);
+                    distinctArr.distinct = [];
+                    distinctArr.distinct[id(array[0])] = true;
                 }
             }
             default: {
-                const vId = distinctArr.id(value);
-                if (!distinctArr.distinct.has(vId)) {
-                    distinctArr.distinct.add(vId);
-                    distinctArr.array.push(value);
+                const vId = id(value);
+                if (distinctArr.distinct[vId] === undefined) {
+                    distinctArr.distinct[vId] = true;
+                    array.push(value);
                 }
             }
         }
@@ -37,13 +37,4 @@ 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

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

package/Utils/emitter.js

@@ -40,6 +40,41 @@ var Emitter;
         emitter.splice(1);
     }
     Emitter.Clear = Clear;
+    function Distinct(emitters) {
+        if (emitters.length === 1)
+            return;
+        emitters.length < 50 ? DistinctSmall(emitters) : DistinctLarge(emitters);
+    }
+    Emitter.Distinct = Distinct;
+    function DistinctSmall(emitters) {
+        Sort(emitters);
+        let lastId = -1;
+        let remove = false;
+        for (let x = 0; x < emitters.length; x++) {
+            const id = emitters[x][0];
+            if (lastId === emitters[x][0]) {
+                emitters[x] = null;
+                remove = true;
+            }
+            lastId = id;
+        }
+        remove && (0, array_1.RemoveNulls)(emitters);
+    }
+    function DistinctLarge(emitters) {
+        let remove = false;
+        const ids = new Set();
+        for (let x = 0; x < emitters.length; x++) {
+            const id = emitters[x][0];
+            if (!ids.has(id))
+                ids.add(id);
+            else {
+                emitters[x] = null;
+                remove = true;
+            }
+        }
+        remove && (0, array_1.RemoveNulls)(emitters);
+        Sort(emitters);
+    }
     function Sort(emitters) {
         return emitters.sort(Compare);
     }

package/Utils/thread.js

@@ -19,7 +19,7 @@ function timeRemaining() {
 function createDeadline() {
     return {
         end: Date.now() + workTimeMs,
-        timeRemaining,
+        timeRemaining
     };
 }
 function ProcessQueue(deadline = createDeadline()) {
@@ -49,9 +49,7 @@ 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);
@@ -61,7 +59,7 @@ function CreateContext() {
     return {
         async: false,
         workEndNode: null,
-        workList: list_1.List.Create(),
+        workList: list_1.List.Create()
     };
 }
 function ScheduleCallback(callback, before, async) {
@@ -91,9 +89,7 @@ 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;
@@ -113,7 +109,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.47",
+  "version": "7.0.48",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",