j-templates 7.0.71 → 7.0.73

package/Store/Tree/observableScope.js

@@ -5,7 +5,6 @@ exports.CalcScope = CalcScope;
 const array_1 = require("../../Utils/array");
 const emitter_1 = require("../../Utils/emitter");
 const functions_1 = require("../../Utils/functions");
-const list_1 = require("../../Utils/list");
 /**
  * Creates a dynamic (reactive) observable scope.
  * @template T The type of value stored in the scope.
@@ -23,15 +22,14 @@ function CreateDynamicScope(getFunction, greedy, value) {
         dirty: false,
         destroyed: false,
         getFunction,
-        setCallback: function () {
-            return OnSet(scope);
-        },
+        setCallback: null,
         value,
         emitter: emitter_1.Emitter.Create(),
         emitters: null,
         onDestroyed: null,
         calcScopes: null,
     };
+    scope.setCallback = OnSet.bind(scope);
     return scope;
 }
 /**
@@ -80,18 +78,15 @@ function OnSetQueued(scope) {
  * @param scope The scope to mark for update.
  * @returns true if the scope is static or destroyed, false if queued or non-greedy scope emitted.
  */
-function OnSet(scope) {
-    if (scope.type === "static" || scope.destroyed)
-        return true;
-    if (scope.dirty)
-        return false;
-    scope.dirty = true;
-    if (scope.greedy) {
-        OnSetQueued(scope);
+function OnSet() {
+    if (this.dirty)
+        return;
+    this.dirty = true;
+    if (this.greedy) {
+        OnSetQueued(this);
         return;
     }
-    emitter_1.Emitter.Emit(scope.emitter, scope);
-    return false;
+    emitter_1.Emitter.Emit(this.emitter, this);
 }
 /**
  * Registers an emitter using SAME_STRATEGY.
@@ -214,38 +209,6 @@ const SORTED_STRATEGY = 3;
 const DISTINCT_STRATEGY = 4;
 const SHRINK_STRATEGY = 5;
 let watchState = null;
-const watchPool = list_1.List.Create();
-/**
- * Creates a new watch state object, reusing from pool if available.
- * Object pooling reduces GC pressure during frequent watch operations.
- * @returns A new or recycled watch state object.
- */
-function CreateWatchState() {
-    return (list_1.List.Pop(watchPool) ?? {
-        emitterIndex: 0,
-        value: null,
-        emitters: null,
-        emitterIds: null,
-        currentCalc: null,
-        nextCalc: null,
-        strategy: PUSH_STRATEGY,
-    });
-}
-/**
- * Returns a watch state object to the pool for reuse.
- * Resets all fields to their default values before pooling.
- * @param state The watch state to return to the pool.
- */
-function ReturnWatchState(state) {
-    state.emitterIndex = 0;
-    state.value = null;
-    state.emitters = null;
-    state.emitterIds = null;
-    state.currentCalc = null;
-    state.nextCalc = null;
-    state.strategy = SORTED_STRATEGY;
-    list_1.List.Push(watchPool, state);
-}
 /**
  * Executes a callback while tracking all scope and emitter dependencies.
  * Creates a watch context that records what was accessed during execution.
@@ -255,11 +218,15 @@ function ReturnWatchState(state) {
  */
 function WatchFunction(callback, currentCalc, initialEmitters) {
     const parent = watchState;
-    watchState = CreateWatchState();
-    watchState.emitters = initialEmitters ?? [];
-    watchState.currentCalc = currentCalc;
-    if (initialEmitters !== null)
-        watchState.strategy = SAME_STRATEGY;
+    watchState = {
+        emitterIndex: 0,
+        value: null,
+        emitters: initialEmitters ?? [],
+        emitterIds: null,
+        currentCalc,
+        nextCalc: null,
+        strategy: initialEmitters === null ? SORTED_STRATEGY : SAME_STRATEGY,
+    };
     watchState.value = callback();
     const resultState = watchState;
     watchState = parent;
@@ -290,7 +257,6 @@ function ExecuteScope(scope) {
         });
     else
         scope.value = state.value;
-    ReturnWatchState(state);
 }
 /**
  * Creates a scope from a function, choosing between static and dynamic based on dependencies.
@@ -312,11 +278,9 @@ function ExecuteFunction(callback, greedy, allowStatic) {
                 scope.value = result;
                 emitter_1.Emitter.Emit(scope.emitter, scope);
             });
-        ReturnWatchState(state);
         return scope;
     }
     const value = state.value;
-    ReturnWatchState(state);
     return CreateStaticScope(value);
 }
 /**
@@ -401,9 +365,9 @@ function DestroyAllScopes(scopes) {
 function DestroyScope(scope) {
     if (!scope || scope.type === "static")
         return;
-    emitter_1.Emitter.Clear(scope.emitter);
-    const scopes = scope.calcScopes && Object.values(scope.calcScopes);
-    scopes && DestroyAllScopes(scopes);
+    emitter_1.Emitter.Destroy(scope.emitter);
+    for (const key in scope.calcScopes)
+        DestroyScope(scope.calcScopes[key]);
     scope.calcScopes = null;
     for (let x = 0; x < scope.emitters.length; x++)
         emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
@@ -513,9 +477,10 @@ var ObservableScope;
      * @param scope The scope to mark for update.
      */
     function Update(scope) {
-        if (!scope)
+        if (!scope || scope.type === "static")
             return;
-        OnSet(scope);
+        // OnSet(scope);
+        scope.setCallback();
     }
     ObservableScope.Update = Update;
     /**

package/Utils/emitter.d.ts

@@ -1,10 +1,11 @@
-export type EmitterCallback<T extends readonly any[] = any[]> = (...args: T) => boolean | void;
+export type EmitterCallback<T extends readonly any[] = any[]> = (...args: T) => void;
 export type Emitter = [number, ...EmitterCallback[]];
 export declare namespace Emitter {
     function Create(): Emitter;
     function GetId(emitter: Emitter): number;
     function On(emitter: Emitter, callback: EmitterCallback): void;
     function Emit(emitter: Emitter, ...args: any[]): void;
+    function Destroy(emitter: Emitter): void;
     function Remove(emitter: Emitter, callback: EmitterCallback): void;
     function Clear(emitter: Emitter): void;
     function Distinct(emitters: Emitter[]): void;

package/Utils/emitter.js

@@ -19,17 +19,26 @@ var Emitter;
     }
     Emitter.On = On;
     function Emit(emitter, ...args) {
+        if (emitter[0] === -1)
+            return;
         let writePos = 1;
         for (let x = 1; x < emitter.length; x++) {
-            if (emitter[x] !== null &&
-                emitter[x](...args) !== true)
+            if (emitter[x] !== null) {
+                emitter[x](...args);
                 emitter[writePos++] = emitter[x];
+            }
         }
         if (writePos < emitter.length)
             emitter.splice(writePos);
     }
     Emitter.Emit = Emit;
+    function Destroy(emitter) {
+        emitter[0] = -1;
+    }
+    Emitter.Destroy = Destroy;
     function Remove(emitter, callback) {
+        if (emitter[0] === -1)
+            return;
         const index = emitter.indexOf(callback);
         if (index >= 1)
             emitter[index] = null;

package/package.json

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