@mintjamsinc/ichigojs 0.1.71 → 0.1.73

package/dist/ichigo.umd.js

@@ -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)) {
+                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)) {
-                resolveDependencies(funcName);
+                resolvedDependencies[funcName] = Array.from(resolved[funcName]);
             }
             return resolvedDependencies;
         }
@@ -7995,6 +8023,41 @@
          * This allows mapping variable names to their actual source paths for dependency tracking.
          */
         static pathAliases = new Map();
+        /**
+         * The `Object.prototype.toString` tags of the *only* value types we deeply
+         * proxy. Everything else is returned untouched (raw).
+         *
+         * Rationale: a Proxy can only safely intercept plain data containers. Built-in
+         * and host objects — `Date`, `RegExp`, `File`, `Blob`, `FileList`, `Promise`,
+         * `WeakMap`/`WeakSet`, typed arrays, DOM nodes, etc. — carry private internal
+         * slots, and invoking their native methods with a Proxy as the `this`/receiver
+         * throws "Illegal invocation". They must therefore never be wrapped. This is an
+         * allow-list rather than a deny-list so that *every* such exotic type is
+         * excluded by default, not just the handful we happened to enumerate.
+         *
+         * Plain user-defined class instances report `[object Object]` (unless they set
+         * `Symbol.toStringTag`) and so remain reactive, preserving prior behaviour.
+         * `Map`/`Set` stay reactive because the proxy specially wraps their mutation
+         * methods (see the `get` trap); `WeakMap`/`WeakSet` are intentionally excluded
+         * since they cannot be wrapped that way and would break the same as `File`.
+         *
+         * Callers that want a plain object kept non-reactive can still opt out
+         * explicitly via {@link markRaw}.
+         */
+        static REACTIVE_TYPE_TAGS = new Set([
+            '[object Object]',
+            '[object Array]',
+            '[object Arguments]',
+            '[object Map]',
+            '[object Set]',
+        ]);
+        /**
+         * Whether the given non-null object value is one we deeply proxy.
+         * See {@link REACTIVE_TYPE_TAGS} for the reasoning.
+         */
+        static isReactivable(value) {
+            return this.REACTIVE_TYPE_TAGS.has(Object.prototype.toString.call(value));
+        }
         /**
          * Creates a reactive proxy for the given object.
          * The proxy will call the onChange callback whenever a property is modified.
@@ -8014,11 +8077,10 @@
             if (this.rawObjects.has(target)) {
                 return target;
             }
-            // Don't wrap built-in objects that have internal slots
-            // These objects require their methods to be called with the correct 'this' context
-            // Use Object.prototype.toString for more reliable type checking
-            const typeTag = Object.prototype.toString.call(target);
-            if (typeTag === '[object Date]' || typeTag === '[object RegExp]' || typeTag === '[object Error]') {
+            // Only deeply proxy plain data containers; return every built-in/host
+            // object (Date, File, Blob, Promise, WeakMap, DOM nodes, …) as-is, since
+            // their native methods break when invoked through a Proxy receiver.
+            if (!this.isReactivable(target)) {
                 return target;
             }
             // Check if the target is already a proxy - if so, return it as-is to prevent double-wrapping
@@ -8054,10 +8116,10 @@
                         if (ReactiveProxy.rawObjects.has(value)) {
                             return value;
                         }
-                        // Don't wrap built-in objects that have internal slots
-                        // Use Object.prototype.toString for more reliable type checking
-                        const valueTypeTag = Object.prototype.toString.call(value);
-                        if (valueTypeTag === '[object Date]' || valueTypeTag === '[object RegExp]' || valueTypeTag === '[object Error]') {
+                        // Only deeply proxy plain data containers; hand back built-in
+                        // and host objects (Date, File, Blob, Promise, WeakMap, DOM
+                        // nodes, …) untouched so their native methods keep working.
+                        if (!ReactiveProxy.isReactivable(value)) {
                             return value;
                         }
                         // Build the nested path