@mintjamsinc/ichigojs 0.1.50 → 0.1.51

package/dist/ichigo.esm.js

@@ -8121,6 +8121,12 @@ class VBindings {
      * 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.
@@ -8155,7 +8161,7 @@ class VBindings {
                     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;
@@ -8170,7 +8176,7 @@ class VBindings {
                                     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}`);
                                     }
                                 }
@@ -8191,8 +8197,14 @@ class VBindings {
                     }
                 }
                 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);
@@ -8329,6 +8341,54 @@ class VBindings {
     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.
@@ -9045,7 +9105,7 @@ class VNode {
         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;
@@ -9068,7 +9128,7 @@ class VNode {
                 }
                 // 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();
                     }
@@ -9077,7 +9137,7 @@ class VNode {
             // 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();
                     }
@@ -9085,7 +9145,7 @@ class VNode {
             }
             // 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();
                 }