j-templates 7.0.84 → 7.0.85

package/Store/Tree/observableScope.d.ts

@@ -35,8 +35,8 @@ interface IDynamicObservableScope<T> {
     emitters: (Emitter | null)[];
     /** Emitter for notifying when the scope is destroyed */
     onDestroyed: Emitter | null;
-    /** Map of nested calc scopes created during this scope's execution */
-    calcScopes: {
+    /** Map of nested scopes created during this scope's execution */
+    scopes: {
         [id: string]: IObservableScope<unknown> | null;
     } | null;
 }
@@ -61,6 +61,23 @@ export type IObservableScope<T> = IStaticObservableScope<T> | IDynamicObservable
  * @returns The computed value, reusing existing scope if available.
  */
 export declare function CalcScope<T>(callback: () => T, idOverride?: string): T;
+/**
+ * Creates a computed scope that isn't registered as a dependency with the parent.
+ * Use this function to read reactive data without subscribing to changes
+ * to that data.
+ *
+ * Unlike CalcScope, PeekScope does not register itself as a dependency, meaning
+ * changes to the data accessed within the callback will not trigger recomputation
+ * of the parent scope. The scope is still memoized by ID within the watch context
+ * to avoid redundant computation during the same evaluation.
+ *
+ * Only works within a watch context (during another scope's execution).
+ * @template T The type of value returned by the callback.
+ * @param callback The function to compute the derived value.
+ * @param idOverride Optional custom ID for memoization when using multiple peek scopes.
+ * @returns The computed value, reusing existing scope if available.
+ */
+export declare function PeekScope<T>(callback: () => T, idOverride?: string): T;
 export declare namespace ObservableScope {
     /**
      * Creates a new observable scope from a value function.

package/Store/Tree/observableScope.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = void 0;
 exports.CalcScope = CalcScope;
+exports.PeekScope = PeekScope;
 const emitter_1 = require("../../Utils/emitter");
 const functions_1 = require("../../Utils/functions");
 /**
@@ -26,7 +27,7 @@ function CreateDynamicScope(getFunction, greedy, value) {
         emitter: emitter_1.Emitter.Create(),
         emitters: null,
         onDestroyed: null,
-        calcScopes: null,
+        scopes: null,
     };
     scope.setCallback = OnSet.bind(scope);
     return scope;
@@ -220,17 +221,21 @@ function WatchFunction(callback, currentCalc, initialEmitters) {
  */
 function ExecuteScope(scope) {
     scope.dirty = false;
-    const state = WatchFunction(scope.getFunction, scope.calcScopes, scope.emitters);
+    const state = WatchFunction(scope.getFunction, scope.scopes, scope.emitters);
     UpdateEmitters(scope, state);
     const calcScopes = state.currentCalc;
-    scope.calcScopes = state.nextCalc;
+    scope.scopes = state.nextCalc;
     for (const key in calcScopes)
         DestroyScope(calcScopes[key]);
-    if (scope.async)
-        state.value.then(function (result) {
+    if (scope.async) {
+        const promise = state.value;
+        promise.then(function (result) {
+            if (state.value !== promise)
+                return;
             scope.value = result;
             emitter_1.Emitter.Emit(scope.emitter, scope);
         });
+    }
     else
         scope.value = state.value;
 }
@@ -247,18 +252,33 @@ function ExecuteFunction(callback, greedy, allowStatic) {
     const state = WatchFunction(callback, null, null);
     if (!allowStatic || async || state.emitters !== null) {
         const scope = CreateDynamicScope(callback, greedy, async ? null : state.value);
-        scope.calcScopes = state.nextCalc;
+        scope.scopes = state.nextCalc;
         UpdateEmitters(scope, state);
-        if (async)
-            state.value.then(function (result) {
+        if (async) {
+            const promise = state.value;
+            promise.then(function (result) {
+                if (state.value !== promise)
+                    return;
                 scope.value = result;
                 emitter_1.Emitter.Emit(scope.emitter, scope);
             });
+        }
         return scope;
     }
     const value = state.value;
     return CreateStaticScope(value);
 }
+function ScopeHelper(callback, id, greedy) {
+    const nextScopes = (watchState.nextCalc ??= {});
+    if (nextScopes[id])
+        return nextScopes[id];
+    const currentScopes = watchState.currentCalc;
+    nextScopes[id] =
+        currentScopes?.[id] ?? ExecuteFunction(callback, greedy, true);
+    if (currentScopes?.[id])
+        delete currentScopes[id];
+    return nextScopes[id];
+}
 /**
  * Creates a computed scope that acts as a gatekeeper for parent scope emissions.
  * If this scope's value doesn't change (=== comparison) it won't emit.
@@ -277,18 +297,33 @@ function ExecuteFunction(callback, greedy, allowStatic) {
 function CalcScope(callback, idOverride) {
     if (watchState === null)
         return callback();
-    const nextScopes = (watchState.nextCalc ??= {});
-    const id = idOverride ?? "default";
-    if (nextScopes[id]) {
-        RegisterScope(nextScopes[id]);
-        return GetScopeValue(nextScopes[id]);
-    }
-    const currentScopes = watchState.currentCalc;
-    nextScopes[id] = currentScopes?.[id] ?? ExecuteFunction(callback, true, true);
-    if (currentScopes?.[id])
-        delete currentScopes[id];
-    RegisterScope(nextScopes[id]);
-    return GetScopeValue(nextScopes[id]);
+    const id = idOverride ?? "calc_default";
+    const scope = ScopeHelper(callback, id, true);
+    RegisterScope(scope);
+    return GetScopeValue(scope);
+}
+/**
+ * Creates a computed scope that isn't registered as a dependency with the parent.
+ * Use this function to read reactive data without subscribing to changes
+ * to that data.
+ *
+ * Unlike CalcScope, PeekScope does not register itself as a dependency, meaning
+ * changes to the data accessed within the callback will not trigger recomputation
+ * of the parent scope. The scope is still memoized by ID within the watch context
+ * to avoid redundant computation during the same evaluation.
+ *
+ * Only works within a watch context (during another scope's execution).
+ * @template T The type of value returned by the callback.
+ * @param callback The function to compute the derived value.
+ * @param idOverride Optional custom ID for memoization when using multiple peek scopes.
+ * @returns The computed value, reusing existing scope if available.
+ */
+function PeekScope(callback, idOverride) {
+    if (watchState === null)
+        return callback();
+    const id = idOverride ?? "peek_default";
+    const scope = ScopeHelper(callback, id, false);
+    return GetScopeValue(scope);
 }
 /**
  * Updates a scope's dependency emitters using efficient diffing.
@@ -350,12 +385,12 @@ function DestroyScope(scope) {
     if (!scope || scope.type === "static")
         return;
     emitter_1.Emitter.Clear(scope.emitter);
-    for (const key in scope.calcScopes)
-        DestroyScope(scope.calcScopes[key]);
+    for (const key in scope.scopes)
+        DestroyScope(scope.scopes[key]);
     for (let x = 0; x < scope.emitters.length; x++)
         emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
     scope.value = undefined;
-    scope.calcScopes = null;
+    scope.scopes = null;
     scope.emitters = null;
     scope.emitter = null;
     scope.getFunction = null;

package/index.d.ts

@@ -1,2 +1,2 @@
 export { Component } from './Node/component';
-export { CalcScope as calc } from './Store/Tree/observableScope';
+export { CalcScope as calc, PeekScope as peek } from './Store/Tree/observableScope';

package/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calc = exports.Component = void 0;
+exports.peek = exports.calc = exports.Component = void 0;
 var component_1 = require("./Node/component");
 Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return component_1.Component; } });
 var observableScope_1 = require("./Store/Tree/observableScope");
 Object.defineProperty(exports, "calc", { enumerable: true, get: function () { return observableScope_1.CalcScope; } });
+Object.defineProperty(exports, "peek", { enumerable: true, get: function () { return observableScope_1.PeekScope; } });

package/package.json

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