@mintjamsinc/ichigojs 0.1.73 → 0.1.74

package/dist/ichigo.esm.js

@@ -8434,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
@@ -8512,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;
@@ -8688,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.
@@ -10783,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);
         }
     }
     /**