@mintjamsinc/ichigojs 0.1.49 → 0.1.51

package/dist/ichigo.cjs

@@ -7581,9 +7581,17 @@
         #updateProperty(element, name, value) {
             if (value == null && (name === 'value' || name === 'textContent' || name === 'innerHTML')) {
                 element[name] = '';
+                if (name === 'value') {
+                    element._value = null;
+                }
             }
             else {
                 element[name] = value;
+                if (name === 'value') {
+                    // Store the original typed value so that v-model on radio buttons
+                    // can preserve the type (e.g., boolean false instead of string "false").
+                    element._value = value;
+                }
             }
         }
         /**
@@ -8119,6 +8127,12 @@
          * Flag to suppress onChange callbacks temporarily.
          */
         #suppressOnChange = 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
+         * their own alias (e.g. "file" -> "files[0]") without overwriting each other.
+         */
+        #localAliases = new Map();
         /**
          * Creates a new instance of VBindings.
          * @param parent The parent bindings, if any.
@@ -8153,7 +8167,7 @@
                         const existingPath = ReactiveProxy.getPath(value);
                         if (existingPath) {
                             // Register a path alias so changes to the source path will match this identifier
-                            ReactiveProxy.registerPathAlias(key, existingPath);
+                            this.#localAliases.set(key, existingPath);
                             this.#logger?.debug(`Path alias registered: ${key} -> ${existingPath}`);
                             // Keep the existing proxy as-is to preserve reactivity chain
                             newValue = value;
@@ -8168,7 +8182,7 @@
                                         const propPath = ReactiveProxy.getPath(propValue);
                                         if (propPath) {
                                             // Register alias: key.propKey -> propPath
-                                            ReactiveProxy.registerPathAlias(`${key}.${propKey}`, propPath);
+                                            this.#localAliases.set(`${key}.${propKey}`, propPath);
                                             this.#logger?.debug(`Property path alias registered: ${key}.${propKey} -> ${propPath}`);
                                         }
                                     }
@@ -8189,8 +8203,14 @@
                         }
                     }
                     else if (value === null || value === undefined) {
-                        // When setting to null/undefined, unregister any path alias
-                        ReactiveProxy.unregisterPathAlias(key);
+                        // When setting to null/undefined, remove local aliases for this key and nested paths
+                        for (const aliasKey of [...this.#localAliases.keys()]) {
+                            if (aliasKey === key ||
+                                aliasKey.startsWith(key + ".") ||
+                                aliasKey.startsWith(key + "[")) {
+                                this.#localAliases.delete(aliasKey);
+                            }
+                        }
                     }
                     const oldValue = Reflect.get(target, key);
                     const result = Reflect.set(target, key, newValue);
@@ -8327,6 +8347,54 @@
         markChanged(key) {
             this.#changes.add(key);
         }
+        /**
+         * Resolves a local path alias for the given identifier by walking up the bindings chain.
+         * Returns the resolved source path, or undefined if no alias is found.
+         */
+        resolveAlias(identifier) {
+            // Direct match in local aliases
+            if (this.#localAliases.has(identifier)) {
+                return this.#localAliases.get(identifier);
+            }
+            // Check if this is a nested path of a locally aliased variable (e.g. "file.isModified")
+            for (const [alias, source] of this.#localAliases.entries()) {
+                if (identifier.startsWith(alias + '.') || identifier.startsWith(alias + '[')) {
+                    return source + identifier.substring(alias.length);
+                }
+            }
+            // Walk up the parent chain
+            return this.#parent?.resolveAlias(identifier);
+        }
+        /**
+         * Checks whether a reactive change path matches a given identifier, taking local path
+         * aliases into account. Falls back to ReactiveProxy.doesChangeMatchIdentifier for
+         * global aliases (computed properties etc.).
+         */
+        doesChangeMatchIdentifier(changePath, identifier) {
+            // Direct match
+            if (changePath === identifier) {
+                return true;
+            }
+            // Resolve via local (scoped) alias chain
+            const resolved = this.resolveAlias(identifier);
+            if (resolved) {
+                if (changePath === resolved) {
+                    return true;
+                }
+                // changePath is a descendant of resolved (e.g. "files[0].isModified" for resolved "files[0]")
+                if (changePath.startsWith(resolved + '.') || changePath.startsWith(resolved + '[')) {
+                    return true;
+                }
+                // changePath is an ancestor of resolved (e.g. "files" for resolved "files[0].isModified")
+                // This handles raw objects: when the parent collection is replaced/spliced, all item
+                // properties are considered changed.
+                if (resolved.startsWith(changePath + '.') || resolved.startsWith(changePath + '[')) {
+                    return true;
+                }
+            }
+            // Fall back to global alias resolution (computed properties, etc.)
+            return ReactiveProxy.doesChangeMatchIdentifier(changePath, identifier);
+        }
     }
 
     // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
@@ -9043,7 +9111,7 @@
             if (this.#nodeType === Node.TEXT_NODE && this.#textEvaluator) {
                 // If this is a text node with a text evaluator, update its content if needed
                 // Check if any of the identifiers are in the changed identifiers (considering path aliases)
-                const changed = this.#textEvaluator.identifiers.some(id => changes.some(change => ReactiveProxy.doesChangeMatchIdentifier(change, id)));
+                const changed = this.#textEvaluator.identifiers.some(id => changes.some(change => this.bindings.doesChangeMatchIdentifier(change, id)));
                 // If the text node has changed, update its content
                 if (changed) {
                     const text = this.#node;
@@ -9066,7 +9134,7 @@
                     }
                     // Prepare bindings for each preparer if relevant identifiers have changed
                     for (const preparer of this.#directiveManager.bindingsPreparers) {
-                        const changed = preparer.dependentIdentifiers.some(id => changes.some(change => ReactiveProxy.doesChangeMatchIdentifier(change, id)));
+                        const changed = preparer.dependentIdentifiers.some(id => changes.some(change => this.bindings.doesChangeMatchIdentifier(change, id)));
                         if (changed) {
                             preparer.prepareBindings();
                         }
@@ -9075,7 +9143,7 @@
                 // Apply DOM updaters from directives, if any
                 if (this.#directiveManager?.domUpdaters) {
                     for (const updater of this.#directiveManager.domUpdaters) {
-                        const changed = updater.dependentIdentifiers.some(id => changes.some(change => ReactiveProxy.doesChangeMatchIdentifier(change, id)));
+                        const changed = updater.dependentIdentifiers.some(id => changes.some(change => this.bindings.doesChangeMatchIdentifier(change, id)));
                         if (changed) {
                             updater.applyToDOM();
                         }
@@ -9083,7 +9151,7 @@
                 }
                 // Recursively update dependent virtual nodes
                 this.#dependents?.forEach(dependentNode => {
-                    const changed = dependentNode.dependentIdentifiers.some(id => changes.some(change => ReactiveProxy.doesChangeMatchIdentifier(change, id)));
+                    const changed = dependentNode.dependentIdentifiers.some(id => changes.some(change => dependentNode.bindings.doesChangeMatchIdentifier(change, id)));
                     if (changed) {
                         dependentNode.update();
                     }
@@ -10771,7 +10839,12 @@
                     element.checked = !!value;
                 }
                 else if (element.type === 'radio') {
-                    element.checked = element.value === String(value);
+                    // Prefer the original typed value stored by VBindDirective (:value binding)
+                    // to avoid type coercion issues (e.g., boolean false vs string "false").
+                    const radioValue = element._value !== undefined
+                        ? element._value
+                        : element.value;
+                    element.checked = radioValue === value;
                 }
                 else {
                     element.value = value ?? '';
@@ -10799,7 +10872,11 @@
                         newValue = target.checked;
                     }
                     else if (target.type === 'radio') {
-                        newValue = target.value;
+                        // Prefer the original typed value stored by VBindDirective (:value binding)
+                        // to preserve the type on write-back (e.g., boolean false, number 0).
+                        newValue = target._value !== undefined
+                            ? target._value
+                            : target.value;
                     }
                     else {
                         newValue = target.value;