@mintjamsinc/ichigojs 0.1.72 → 0.1.74

package/README.md

@@ -1027,4 +1027,4 @@ All trademarks are the property of their respective owners.
 
 ---
 
-Built with ❤️ by [MintJams Inc.](https://github.com/mintjamsinc)
+Built with ❤️ by [MintJams Inc.](https://www.mintjams.jp/)

package/dist/ichigo.cjs

@@ -8023,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.
@@ -8042,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
@@ -8082,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
@@ -8406,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
@@ -8484,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;
@@ -8660,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.
@@ -10755,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);
             }
         }
         /**