@acorex/platform 20.9.42 → 20.9.44

package/fesm2022/acorex-platform-layout-widget-core.mjs

@@ -2077,15 +2077,27 @@ class AXPWidgetRendererDirective {
         });
     }
     //#region ----   Expression Caching Methods   ----
+    /**
+     * Returns a cache hit only when an entry exists and is still within TTL.
+     * Must not use `value !== null` as the hit check: a cached `undefined` would look like a hit
+     * while a cached `null` would look like a miss (`getCachedExpressionResult` used to return `null` for both).
+     */
     getCachedExpressionResult(expressionKey) {
         const cached = this.expressionCache.get(expressionKey);
         if (cached && performance.now() - cached.timestamp < this.EXPRESSION_CACHE_TTL) {
-            // console.log(`💾 [${this.node().type}] Using cached expression result for '${expressionKey}'`);
-            return cached.value;
+            return { hit: true, value: cached.value };
         }
-        return null;
+        return { hit: false };
     }
+    /**
+     * Skip caching nullish results so a late-arriving value (e.g. options.node going from null to a widget)
+     * is re-evaluated on the next updateOptionsBasedOnContext pass instead of being frozen for TTL.
+     */
     setCachedExpressionResult(expressionKey, value) {
+        if (value == null) {
+            this.expressionCache.delete(expressionKey);
+            return;
+        }
         this.expressionCache.set(expressionKey, {
             value,
             timestamp: performance.now(),
@@ -2660,11 +2672,11 @@ class AXPWidgetRendererDirective {
         }
         // console.log(`🔍 [${this.node().type}] Evaluating ${this.expressionEvaluators.size} expressions`);
         const updatePromises = Array.from(this.expressionEvaluators).map(async ([path, evaluator]) => {
-            // Check cache first
-            const cachedValue = this.getCachedExpressionResult(path);
-            if (cachedValue !== null) {
-                // console.log(`💾 [${this.node().type}] Using cached expression result for '${path}'`);
-                return { path, newValue: cachedValue, fromCache: true };
+            const cached = this.getCachedExpressionResult(path);
+            if (cached.hit) {
+                const hasLastValue = this.lastExpressionResults.has(path);
+                const hasChanged = !hasLastValue || !isEqual(cached.value, this.lastExpressionResults.get(path));
+                return { path, newValue: cached.value, fromCache: true, hasChanged };
             }
             // Evaluate expression if not cached
             const evalStartTime = performance.now();