@mintjamsinc/ichigojs 0.1.72 → 0.1.74

package/dist/ichigo.esm.js

@@ -8017,6 +8017,41 @@ class ReactiveProxy {
      * 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.
@@ -8036,11 +8071,10 @@ class ReactiveProxy {
         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
@@ -8076,10 +8110,10 @@ class ReactiveProxy {
                     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
@@ -8400,6 +8434,13 @@ class VBindings {
      * Flag to suppress onChange callbacks temporarily.
      */
     #suppressOnChange = false;
+    /**
+     * Flag forcing the next write through the `set` trap to stay in THIS scope's own
+     * local store instead of walking up to an inherited binding of the same name.
+     * Set only by {@link setLocal} for scope-local variables (e.g. v-for loop items),
+     * which must shadow — never overwrite — a parent binding with the same key.
+     */
+    #localWrite = false;
     /**
      * Per-instance path aliases. Maps local variable names to their reactive source paths.
      * Scoped here instead of the global ReactiveProxy map so that v-for items each maintain
@@ -8478,8 +8519,13 @@ class VBindings {
                     setter(value);
                     return true;
                 }
+                // For a key that is not local to this scope, an assignment normally
+                // retargets to the nearest parent that owns it, so reassignments
+                // (e.g. `count = count + 1` in a handler) mutate the original binding.
+                // A scope-local write (setLocal — used for v-for loop variables) skips
+                // this walk so the variable shadows, never clobbers, an inherited key.
                 let target = obj;
-                if (!Reflect.has(target, key)) {
+                if (!this.#localWrite && !Reflect.has(target, key)) {
                     for (let parent = this.#parent; parent; parent = parent.#parent) {
                         if (Reflect.has(parent.#local, key)) {
                             target = parent.#local;
@@ -8654,6 +8700,25 @@ class VBindings {
     set(key, value) {
         this.#local[key] = value;
     }
+    /**
+     * Sets a binding value in THIS scope's own local store, without walking up to a
+     * parent scope. Used for scope-local variables (e.g. v-for loop items) that must
+     * shadow — never overwrite — an inherited binding of the same name. Contrast with
+     * {@link set}, which retargets a write of an inherited key to the owning parent so
+     * that reassignments mutate the original; a loop variable named like a root data /
+     * method / computed key (e.g. `t`) would otherwise clobber it.
+     * @param key The binding name.
+     * @param value The binding value.
+     */
+    setLocal(key, value) {
+        this.#localWrite = true;
+        try {
+            this.#local[key] = value;
+        }
+        finally {
+            this.#localWrite = false;
+        }
+    }
     /**
      * Gets a binding value.
      * @param key The binding name.
@@ -10749,26 +10814,30 @@ class VForDirective {
      * Sets item bindings for a VNode, handling nested destructuring if needed.
      */
     #setItemBindings(bindings, context) {
+        // Loop variables are scope-local: they must shadow, never overwrite, an
+        // inherited binding of the same name (a data / method / computed key on a
+        // parent scope). setLocal writes to this iteration's own store so a loop
+        // variable named like e.g. the i18n helper `t` cannot clobber it.
         if (this.#itemDestructure && Array.isArray(context.item)) {
             // Nested destructuring: spread array items to individual bindings
             // e.g., item = ['alice', 1] with itemDestructure = ['k', 'v']
-            // bindings.set('k', 'alice')
-            // bindings.set('v', 1)
+            // bindings.setLocal('k', 'alice')
+            // bindings.setLocal('v', 1)
             this.#itemDestructure.forEach((name, i) => {
-                bindings.set(name, context.item[i]);
+                bindings.setLocal(name, context.item[i]);
             });
         }
         else if (this.#itemName) {
             // Simple item binding
-            bindings.set(this.#itemName, context.item);
+            bindings.setLocal(this.#itemName, context.item);
         }
         if (this.#indexName) {
             // For objects, use objectKey if available; otherwise use numeric index
-            bindings.set(this.#indexName, context.objectKey ?? context.index);
+            bindings.setLocal(this.#indexName, context.objectKey ?? context.index);
         }
         if (this.#thirdName) {
             // Third argument is always the numeric index
-            bindings.set(this.#thirdName, context.index);
+            bindings.setLocal(this.#thirdName, context.index);
         }
     }
     /**