j-templates 7.0.89 → 7.0.90

package/DOM/domNodeConfig.js

@@ -145,42 +145,36 @@ exports.DOMNodeConfig = {
         target.replaceChildren(...children);
     },
     reconcileChildren(target, children) {
-        if (!target.firstChild) {
-            for (let x = 0; x < children.length; x++) {
-                const child = getHTMLNode(children[x]);
-                target.appendChild(child);
-            }
-            return;
-        }
-        if (children.length === 0) {
-            target.replaceChildren();
-            return;
+        let lastChild = null;
+        switch (children.length) {
+            case 0:
+                target.replaceChildren();
+                break;
+            case 1:
+                lastChild = getHTMLNode(children[0], target.firstChild);
+                if (target.firstChild !== lastChild)
+                    target.insertBefore(lastChild, target.firstChild);
+                break;
+            default:
+                let actualChild = target.firstChild;
+                let nextChild = null;
+                let x = 0;
+                for (; x < children.length; x++) {
+                    nextChild = getHTMLNode(children[x], actualChild);
+                    while (actualChild && nextChild !== actualChild) {
+                        const nextSibling = actualChild.nextSibling;
+                        target.removeChild(actualChild);
+                        actualChild = nextSibling;
+                    }
+                    if (actualChild)
+                        actualChild = actualChild.nextSibling;
+                    else
+                        target.appendChild(nextChild);
+                }
+                lastChild = nextChild;
+                break;
         }
-        let actualNode = target.firstChild;
-        let x = 0;
-        let removed = false;
-        for (; actualNode && x < children.length; x++) {
-            const child = children[x];
-            let expectedNode = getHTMLNode(child, actualNode);
-            if (!removed && actualNode !== expectedNode) {
-                const remove = actualNode;
-                actualNode = actualNode.nextSibling;
-                target.removeChild(remove);
-                removed = true;
-            }
-            if (actualNode !== expectedNode) {
-                target.insertBefore(expectedNode, actualNode);
-            }
-            else {
-                actualNode = actualNode.nextSibling;
-                removed = false;
-            }
-        }
-        while (target.lastChild && target.lastChild !== children[x - 1])
+        while (target.lastChild !== lastChild)
             target.removeChild(target.lastChild);
-        for (; x < children.length; x++) {
-            const child = getHTMLNode(children[x]);
-            target.appendChild(child);
-        }
     },
 };

package/Store/Tree/observableNode.js

@@ -58,10 +58,12 @@ function UnwrapProxy(value, type = (0, json_2.JsonType)(value)) {
             const keys = Object.keys(value);
             for (let x = 0; x < keys.length; x++)
                 value[keys[x]] = UnwrapProxy(value[keys[x]]);
+            break;
         }
         case "array": {
             for (let x = 0; x < value.length; x++)
                 value[x] = UnwrapProxy(value[x]);
+            break;
         }
     }
     return value;

package/Store/Tree/observableScope.d.ts

@@ -17,6 +17,7 @@ interface IDynamicObservableScope<T> {
     type: "dynamic";
     /** Whether the scope's getter function is async */
     async: boolean;
+    pending: Promise<T> | null;
     /** Whether updates are batched (true) or immediate (false) */
     greedy: boolean;
     /** Whether the scope needs recomputation */
@@ -145,20 +146,22 @@ export declare namespace ObservableScope {
      * @param scope The scope to watch for changes.
      * @param callback Function to invoke when the scope's value changes.
      */
-    function Watch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
+    function Watch<T>(scope: IObservableScope<T>, callback: (scope: IObservableScope<T>) => void): void;
     /**
      * Unsubscribes from changes on a dynamic scope.
      * @template T The type of value stored in the scope.
      * @param scope The scope to stop watching.
      * @param callback The callback function to remove.
      */
-    function Unwatch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
+    function Unwatch<T>(scope: IObservableScope<T>, callback: (scope: IObservableScope<T>) => void): void;
     /**
      * Registers a callback to be invoked when the scope is destroyed.
      * @param scope The scope to monitor for destruction.
      * @param callback Function to invoke when the scope is destroyed.
      */
-    function OnDestroyed(scope: IObservableScope<unknown>, callback: EmitterCallback): void;
+    function OnDestroyed(scope: IObservableScope<unknown>, callback: {
+        (): void;
+    }): void;
     /**
      * Marks a scope as dirty, triggering recomputation on next access or batch.
      * @param scope The scope to mark for update.

package/Store/Tree/observableScope.js

@@ -19,6 +19,7 @@ function CreateDynamicScope(getFunction, greedy, value) {
     const scope = {
         type: "dynamic",
         async,
+        pending: null,
         greedy: greedy || async,
         dirty: false,
         destroyed: false,
@@ -80,7 +81,7 @@ function OnSetQueued(scope) {
  * @returns true if the scope is static or destroyed, false if queued or non-greedy scope emitted.
  */
 function OnSet() {
-    if (this.dirty)
+    if (this.dirty || this.destroyed)
         return;
     this.dirty = true;
     if (this.greedy) {
@@ -229,10 +230,11 @@ function ExecuteScope(scope) {
     for (const key in calcScopes)
         DestroyScope(calcScopes[key]);
     if (scope.async) {
-        const promise = state.value;
+        const promise = (scope.pending = state.value);
         promise.then(function (result) {
-            if (state.value !== promise)
+            if (scope.destroyed || scope.pending !== promise)
                 return;
+            scope.pending = null;
             scope.value = result;
             emitter_1.Emitter.Emit(scope.emitter, scope);
         });
@@ -256,10 +258,12 @@ function ExecuteFunction(callback, greedy, allowStatic) {
         scope.scopes = state.nextCalc;
         UpdateEmitters(scope, state);
         if (async) {
-            const promise = state.value;
+            console.log("resolving async scope");
+            const promise = (scope.pending = state.value);
             promise.then(function (result) {
-                if (state.value !== promise)
+                if (scope.destroyed || scope.pending !== promise)
                     return;
+                scope.pending = null;
                 scope.value = result;
                 emitter_1.Emitter.Emit(scope.emitter, scope);
             });
@@ -419,12 +423,13 @@ function DestroyAllScopes(scopes) {
 function DestroyScope(scope) {
     if (!scope || scope.type === "static")
         return;
-    emitter_1.Emitter.Clear(scope.emitter);
     for (const key in scope.scopes)
         DestroyScope(scope.scopes[key]);
+    // Emitter.Destroy(scope.emitter);
+    emitter_1.Emitter.DestroyCallback(scope.setCallback);
     if (scope.emitters !== null)
         for (let x = 0; x < scope.emitters.length; x++)
-            emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+            emitter_1.Emitter.Compact(scope.emitters[x]);
     scope.value = undefined;
     scope.scopes = null;
     scope.emitters = null;

package/Utils/emitter.d.ts

@@ -2,6 +2,8 @@ export type EmitterCallback<T extends readonly any[] = any[]> = (...args: T) =>
 export type Emitter = EmitterCallback[];
 export declare namespace Emitter {
     function Create(): Emitter;
+    function Compact(emitter: Emitter): void;
+    function DestroyCallback(callback: EmitterCallback): void;
     function On(emitter: Emitter, callback: EmitterCallback): void;
     function Emit(emitter: Emitter, ...args: any[]): void;
     function Remove(emitter: Emitter, callback: EmitterCallback): void;

package/Utils/emitter.js

@@ -3,18 +3,93 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = void 0;
 var Emitter;
 (function (Emitter) {
+    const destroyed = new WeakSet();
+    // const pendingCompactEmitters = new Set<Emitter>();
+    let pendingCompactEmitters = [];
     function Create() {
         return [];
     }
     Emitter.Create = Create;
+    const scheduleCallback = typeof requestIdleCallback !== "undefined"
+        ? requestIdleCallback
+        : setTimeout;
+    function Compact(emitter) {
+        if (emitter.length === 0)
+            return;
+        pendingCompactEmitters.push(emitter);
+        ScheduleCompact();
+    }
+    Emitter.Compact = Compact;
+    let compactScheduled = false;
+    function ScheduleCompact() {
+        if (compactScheduled)
+            return;
+        compactScheduled = true;
+        scheduleCallback(PerformCompact);
+    }
+    function PerformCompact() {
+        compactScheduled = false;
+        let compactEmitters = pendingCompactEmitters;
+        pendingCompactEmitters = [];
+        const processedEmitters = new Set();
+        for (let x = 0; x < compactEmitters.length; x++)
+            if (!processedEmitters.has(compactEmitters[x])) {
+                CompactEmitter(compactEmitters[x]);
+                processedEmitters.add(compactEmitters[x]);
+            }
+    }
+    /* export function Compact(emitter: Emitter) {
+      if (emitter.length === 0 || destroyed.has(emitter)) {
+        return;
+      }
+  
+      if (pendingCompactEmitters.size === 0) {
+        scheduleCallback(CompactPending);
+      }
+  
+      pendingCompactEmitters.add(emitter);
+    }
+  
+    function CompactPending() {
+      if (pendingCompactEmitters.size === 0) return;
+  
+      const pending = Array.from(pendingCompactEmitters);
+      pendingCompactEmitters.clear();
+  
+      for (let x = 0; x < pending.length; x++)
+        if (!destroyed.has(pending[x])) CompactEmitter(pending[x]);
+    } */
+    function CompactEmitter(emitter) {
+        let count = 0;
+        for (; count < emitter.length &&
+            (emitter[count] === null || destroyed.has(emitter[count])); count++) { }
+        if (count > 0)
+            emitter.splice(0, count);
+        let writePos = 0;
+        for (let x = 0; x < emitter.length; x++) {
+            if (emitter[x] !== null && !destroyed.has(emitter[x]))
+                emitter[writePos++] = emitter[x];
+        }
+        if (writePos < emitter.length)
+            emitter.splice(writePos);
+    }
+    function DestroyCallback(callback) {
+        destroyed.add(callback);
+    }
+    Emitter.DestroyCallback = DestroyCallback;
+    /* export function Destroy(emitter: Emitter) {
+      pendingCompactEmitters.delete(emitter);
+      destroyed.add(emitter);
+      } */
     function On(emitter, callback) {
         emitter.push(callback);
     }
     Emitter.On = On;
     function Emit(emitter, ...args) {
+        // pendingCompactEmitters.delete(emitter);
         let writePos = 0;
         for (let x = 0; x < emitter.length; x++) {
-            if (emitter[x] !== null) {
+            if (emitter[x] !== null && !destroyed.has(emitter[x])) {
                 emitter[x](...args);
                 emitter[writePos++] = emitter[x];
             }
@@ -25,11 +100,16 @@ var Emitter;
     Emitter.Emit = Emit;
     function Remove(emitter, callback) {
         const index = emitter.indexOf(callback);
-        if (index >= 0)
+        if (index >= 0) {
             emitter[index] = null;
+            Compact(emitter);
+        }
     }
     Emitter.Remove = Remove;
     function Clear(emitter) {
+        if (emitter.length === 0)
+            return;
+        // pendingCompactEmitters.delete(emitter);
         emitter.splice(0);
     }
     Emitter.Clear = Clear;

package/package.json

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