@mintjamsinc/ichigojs 0.1.73 → 0.1.74

package/dist/ichigo.umd.js

@@ -8440,6 +8440,13 @@
          * 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
@@ -8518,8 +8525,13 @@
                         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;
@@ -8694,6 +8706,25 @@
         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.
@@ -10789,26 +10820,30 @@
          * 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);
             }
         }
         /**