@mintjamsinc/ichigojs 0.1.70 → 0.1.72

package/README.md

@@ -1021,6 +1021,10 @@ MIT License - Copyright (c) 2025 MintJams Inc.
 
 Inspired by [Vue.js](https://vuejs.org/) - A progressive JavaScript framework.
 
+## Trademarks
+
+All trademarks are the property of their respective owners.
+
 ---
 
 Built with ❤️ by [MintJams Inc.](https://github.com/mintjamsinc)

package/dist/ichigo.cjs

@@ -6945,42 +6945,70 @@
                     functionDependencies[funcName] = [];
                 }
             }
-            // Second pass: recursively resolve function dependencies
-            const resolvedDependencies = {};
-            const resolving = new Set(); // To detect circular dependencies
-            const resolveDependencies = (funcName) => {
-                // If already resolved, return cached result
-                if (resolvedDependencies[funcName]) {
-                    return resolvedDependencies[funcName];
-                }
-                // Check for circular dependency
-                if (resolving.has(funcName)) {
-                    console.warn(`Circular dependency detected for function: ${funcName}`);
-                    return [];
-                }
-                resolving.add(funcName);
-                const allDependencies = new Set();
-                const directDependencies = functionDependencies[funcName] || [];
-                for (const dep of directDependencies) {
+            // Second pass: resolve each function's transitive reactive dependencies.
+            //
+            // A function's direct dependency list mixes two kinds of identifiers: references to other
+            // functions (call edges) and references to reactive data properties (the values we actually
+            // care about). We want, for every function, the full set of reactive properties reachable by
+            // following call edges to any depth.
+            //
+            // Functions are free to reference each other cyclically — a poller that reschedules itself
+            // (`scheduleOperationPoll` -> `pollOperation` -> `scheduleOperationPoll`), a pair of mutually
+            // recursive helpers, or any state machine. This is valid JavaScript, so the resolver must not
+            // treat it as an error. Every function in a cycle (more precisely, a strongly connected
+            // component) is reachable from the others, so they all share the same transitive dependency
+            // set: the union of every member's direct reactive dependencies.
+            //
+            // A depth-first walk that bails out on back-edges cannot compute that correctly — it drops the
+            // dependencies contributed around the cycle and caches incomplete, traversal-order-dependent
+            // results, which would silently break reactivity for any computed that reads reactive data
+            // through a cyclic method. We instead split each function's direct dependencies into reactive
+            // properties and call edges, then propagate reactive properties along call edges until the sets
+            // stop growing (a fixpoint). This converges regardless of cycles and yields the exact transitive
+            // closure for every function, including those participating in a cycle.
+            const directReactive = {};
+            const callEdges = {};
+            for (const funcName of Object.keys(functions)) {
+                const reactive = new Set();
+                const edges = [];
+                for (const dep of functionDependencies[funcName] || []) {
                     if (dep === funcName)
-                        continue; // Skip self-references
+                        continue; // Skip self-references.
                     if (functions[dep]) {
-                        // It's a function, recursively resolve its dependencies
-                        const subDependencies = resolveDependencies(dep);
-                        subDependencies.forEach(subDep => allDependencies.add(subDep));
+                        edges.push(dep); // Call edge to another function.
                     }
                     else {
-                        // It's a variable, add directly
-                        allDependencies.add(dep);
+                        reactive.add(dep); // Reactive data property (terminal dependency).
                     }
                 }
-                resolving.delete(funcName);
-                resolvedDependencies[funcName] = Array.from(allDependencies);
-                return resolvedDependencies[funcName];
-            };
-            // Resolve all functions
+                directReactive[funcName] = reactive;
+                callEdges[funcName] = edges;
+            }
+            // Seed each function with its own direct reactive dependencies, then propagate along call edges
+            // until no set changes. Each pass can only add properties, and the universe of properties is
+            // finite, so the loop is guaranteed to terminate.
+            const resolved = {};
             for (const funcName of Object.keys(functions)) {
-                resolveDependencies(funcName);
+                resolved[funcName] = new Set(directReactive[funcName]);
+            }
+            let changed = true;
+            while (changed) {
+                changed = false;
+                for (const funcName of Object.keys(functions)) {
+                    const target = resolved[funcName];
+                    for (const edge of callEdges[funcName]) {
+                        for (const dep of resolved[edge]) {
+                            if (!target.has(dep)) {
+                                target.add(dep);
+                                changed = true;
+                            }
+                        }
+                    }
+                }
+            }
+            const resolvedDependencies = {};
+            for (const funcName of Object.keys(functions)) {
+                resolvedDependencies[funcName] = Array.from(resolved[funcName]);
             }
             return resolvedDependencies;
         }
@@ -13757,7 +13785,8 @@
             this.#logManager = new VLogManager(options.logLevel);
             this.#logger = this.#logManager.getLogger('VApplication');
             // Analyze function dependencies
-            this.#functionDependencies = ExpressionUtils.analyzeFunctionDependencies(options.methods || {});
+            const methods = (options.methods || {});
+            this.#functionDependencies = ExpressionUtils.analyzeFunctionDependencies(methods);
             // Analyze computed dependencies based on getter functions only.
             // Writable computeds (defined as { get, set }) contribute their getter for dependency analysis.
             const computedGetters = {};
@@ -13766,7 +13795,23 @@
                     computedGetters[key] = VApplication.#getComputedGetter(def);
                 }
             }
-            this.#computedDependencies = ExpressionUtils.analyzeFunctionDependencies(computedGetters);
+            // Resolve computed dependencies against BOTH the computed getters AND the methods, so a
+            // computed that delegates to a method inherits that method's reactive dependencies. A
+            // computed whose only reactive reads happen inside a called method (e.g. a reactive i18n
+            // `t()` helper that reads `this.localization`) would otherwise never be invalidated, leaving
+            // its binding stale on a dependency change. Analyzing the combined set flattens every
+            // computed→method (and computed→computed, method→method) edge down to the underlying
+            // reactive paths — the same expansion that template-expression analysis already performs for
+            // method calls (see ExpressionUtils.extractIdentifiers). We then keep only the computed
+            // entries, since #computedDependencies must be keyed by computed name alone.
+            const combinedDependencies = ExpressionUtils.analyzeFunctionDependencies({
+                ...methods,
+                ...computedGetters,
+            });
+            this.#computedDependencies = {};
+            for (const key of Object.keys(computedGetters)) {
+                this.#computedDependencies[key] = combinedDependencies[key] || [];
+            }
             // Initialize watcher manager
             this.#watcher = new VWatcher(this.#logger);
             // Initialize bindings from data, computed, and methods
@@ -14120,10 +14165,10 @@
         }
         /**
          * Marks computed properties as dirty (pull-based invalidation) when a dependency changes.
-         * Uses the statically analyzed dependency graph; because computed→computed dependencies are
-         * flattened to their underlying reactive paths during analysis, a single change marks every
-         * transitively dependent computed dirty in one pass. The actual recomputation is deferred until
-         * the value is read (see #recomputeOne).
+         * Uses the statically analyzed dependency graph; because computed→computed and computed→method
+         * dependencies are flattened to their underlying reactive paths during analysis, a single change
+         * marks every transitively dependent computed dirty in one pass. The actual recomputation is
+         * deferred until the value is read (see #recomputeOne).
          * @param identifier The changed identifier reported by the bindings change tracker.
          */
         #markDirtyComputeds(identifier) {