@mintjamsinc/ichigojs 0.1.84 → 0.1.86

package/dist/ichigo.cjs

@@ -6766,28 +6766,29 @@
                     }
                 }
                 else if (node.type === 'MemberExpression') {
-                    // Reconstruct chain parts from a MemberExpression (e.g. a.b.c)
+                    // Reconstruct chain parts from a MemberExpression (e.g. a.b.c). Each part
+                    // carries its own separator so that the chain is spelled the way the reactive
+                    // proxy reports changes: array indices in brackets, properties after a dot
+                    // (e.g. "items[0].name").
                     const parts = [];
                     let cur = node;
-                    let stop = false;
-                    while (cur && !stop) {
+                    while (cur) {
                         // property part (right side)
                         if (cur.property) {
                             if (!cur.computed && cur.property.type === 'Identifier') {
-                                parts.unshift(cur.property.name);
+                                parts.unshift(`.${cur.property.name}`);
+                            }
+                            else if (cur.computed && cur.property.type === 'Literal' && typeof cur.property.value === 'number') {
+                                parts.unshift(`[${cur.property.value}]`);
                             }
                             else if (cur.computed && cur.property.type === 'Literal') {
-                                parts.unshift(String(cur.property.value));
+                                parts.unshift(`.${String(cur.property.value)}`);
                             }
-                            else if (cur.computed && cur.property.type === 'Identifier') {
-                                // e.g. obj[prop] -> include the prop identifier (it will also be added separately)
-                                parts.unshift(cur.property.name);
-                            }
-                            else {
-                                // unknown property shape (e.g. expression) — stop adding chain here
-                                // inner expressions will be visited separately by walk.full
-                                stop = true;
-                                break;
+                            else if (cur.computed) {
+                                // e.g. items[i] or items[i + 1]: the index is only known when the
+                                // expression runs, so "[*]" stands for any index or key. Identifiers
+                                // inside the index expression are visited separately by walk.full.
+                                parts.unshift('[*]');
                             }
                         }
                         // object part (left side)
@@ -6807,7 +6808,6 @@
                             }
                             else {
                                 // other object types (CallExpression, etc.) — stop here
-                                stop = true;
                                 break;
                             }
                         }
@@ -6815,10 +6815,15 @@
                             break;
                         }
                     }
-                    if (parts.length > 0) {
-                        // Add progressive chains: 'a', 'a.b', 'a.b.c'
+                    // A chain that does not start at a name (e.g. `this.a.b` or `f().b`) begins
+                    // with its first property; one that begins with an index names no binding.
+                    if (parts.length > 0 && parts[0].startsWith('.')) {
+                        parts[0] = parts[0].substring(1);
+                    }
+                    if (parts.length > 0 && !parts[0].startsWith('[')) {
+                        // Add progressive chains: 'a', 'a.b', 'a.b[0]', 'a.b[0].c'
                         for (let i = 0; i < parts.length; i++) {
-                            const chain = parts.slice(0, i + 1).join('.');
+                            const chain = parts.slice(0, i + 1).join('');
                             identifiers.add(chain);
                             // Also apply functionDependencies lookup for the chain key
                             if (functionDependencies[chain]) {
@@ -6832,6 +6837,16 @@
             });
             return Array.from(identifiers);
         }
+        /**
+         * Returns the binding name an identifier chain starts with
+         * (e.g. "items" for "items[0].name" or "user.name").
+         * @param identifier An identifier or member chain returned by extractIdentifiers.
+         * @returns The left-most name of the chain.
+         */
+        static baseIdentifier(identifier) {
+            const end = identifier.search(/[.[]/);
+            return end === -1 ? identifier : identifier.substring(0, end);
+        }
         /**
          * Analyzes the dependencies of functions in the provided dictionary.
          * @param functions A dictionary mapping function names to their implementations.
@@ -7246,7 +7261,7 @@
             // Use the base (left-most) segment of member chains and preserve order.
             const baseIdentifiers = [];
             for (const id of extractedIdentifiers) {
-                const base = id.split('.')[0];
+                const base = ExpressionUtils.baseIdentifier(id);
                 if (!baseIdentifiers.includes(base)) {
                     baseIdentifiers.push(base);
                 }
@@ -7787,13 +7802,20 @@
         }
         /**
          * Updates a regular attribute.
+         * An attribute that already holds the value is left alone: setting `src` on
+         * an <iframe>, even to the same URL, loads its page again.
          */
         #updateAttribute(element, name, value) {
             if (value == null || value === false) {
-                element.removeAttribute(name);
+                if (element.hasAttribute(name)) {
+                    element.removeAttribute(name);
+                }
             }
             else {
-                element.setAttribute(name, String(value));
+                const text = String(value);
+                if (element.getAttribute(name) !== text) {
+                    element.setAttribute(name, text);
+                }
             }
         }
     }
@@ -8033,6 +8055,11 @@
          * This allows mapping variable names to their actual source paths for dependency tracking.
          */
         static pathAliases = new Map();
+        /**
+         * Compiled patterns for identifiers that contain a "[*]" index, keyed by the
+         * identifier and whether descendants of the path also match.
+         */
+        static pathPatterns = new Map();
         /**
          * The `Object.prototype.toString` tags of the *only* value types we deeply
          * proxy. Everything else is returned untouched (raw).
@@ -8395,24 +8422,47 @@
          */
         static doesChangeMatchIdentifier(changePath, identifier) {
             // Direct match
-            if (changePath === identifier) {
+            if (this.pathMatches(changePath, identifier)) {
                 return true;
             }
-            // Check if the identifier has an alias that matches
+            // Check if the change path is the resolved identifier or lies below it
+            // (handles cases like array item changes)
             const resolvedIdentifier = this.resolvePathAlias(identifier);
-            if (resolvedIdentifier && changePath === resolvedIdentifier) {
+            if (resolvedIdentifier && this.pathMatches(changePath, resolvedIdentifier, true)) {
                 return true;
             }
-            // Check if change path starts with the resolved identifier
-            // (handles cases like array item changes)
-            if (resolvedIdentifier) {
-                if (changePath.startsWith(resolvedIdentifier + '.') ||
-                    changePath.startsWith(resolvedIdentifier + '[')) {
-                    return true;
-                }
-            }
             return false;
         }
+        /**
+         * Checks whether a change path names the location an identifier refers to.
+         * A "[*]" index in the identifier (e.g. "items[*].name" for `items[i].name`)
+         * stands for an index known only when the expression runs and matches any
+         * one index or key.
+         *
+         * @param changePath The path that was changed (e.g., "items[2].name")
+         * @param identifier The identifier to check (e.g., "items[*].name")
+         * @param descendants Whether a change below the identifier also matches
+         * @returns True if the change path matches the identifier
+         */
+        static pathMatches(changePath, identifier, descendants = false) {
+            if (changePath === identifier) {
+                return true;
+            }
+            if (!identifier.includes('[*]')) {
+                return descendants && (changePath.startsWith(identifier + '.') || changePath.startsWith(identifier + '['));
+            }
+            const cacheKey = descendants ? identifier + ' ' : identifier;
+            let pattern = this.pathPatterns.get(cacheKey);
+            if (!pattern) {
+                const source = identifier
+                    .split('[*]')
+                    .map(part => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+                    .join('(?:\\[[^\\]]*\\]|\\.[^.[]+)');
+                pattern = new RegExp(`^${source}${descendants ? '(?:[.[].*)?' : ''}$`);
+                this.pathPatterns.set(cacheKey, pattern);
+            }
+            return pattern.test(changePath);
+        }
     }
 
     // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
@@ -8908,18 +8958,15 @@
          * global aliases (computed properties etc.).
          */
         doesChangeMatchIdentifier(changePath, identifier) {
-            // Direct match
-            if (changePath === identifier) {
+            // Direct match (an index "[*]" in the identifier matches any index)
+            if (ReactiveProxy.pathMatches(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 + '[')) {
+                // changePath is resolved itself or a descendant of it (e.g. "files[0].isModified" for resolved "files[0]")
+                if (ReactiveProxy.pathMatches(changePath, resolved, true)) {
                     return true;
                 }
                 // changePath is an ancestor of resolved (e.g. "files" for resolved "files[0].isModified")
@@ -9984,7 +10031,7 @@
                 // Build base parameter names (no dots), preserving order of first appearance
                 const baseArgs = [];
                 for (const id of ids) {
-                    const base = id.split('.')[0];
+                    const base = ExpressionUtils.baseIdentifier(id);
                     if (!baseArgs.includes(base)) {
                         baseArgs.push(base);
                     }
@@ -12060,6 +12107,11 @@
          * The expression evaluator for this directive.
          */
         #evaluator;
+        /**
+         * The HTML last set on the element. The same HTML is not set again: that
+         * would replace the elements inside, and load their frames and images again.
+         */
+        #html;
         /**
          * @param context The context for parsing the directive.
          */
@@ -12110,10 +12162,14 @@
                 get dependentIdentifiers() {
                     return identifiers;
                 },
-                applyToDOM() {
+                applyToDOM: () => {
                     const element = vNode.node;
-                    const htmlContent = evaluator.evaluate();
-                    element.innerHTML = htmlContent ?? '';
+                    const htmlContent = evaluator.evaluate() ?? '';
+                    if (htmlContent === this.#html) {
+                        return;
+                    }
+                    this.#html = htmlContent;
+                    element.innerHTML = htmlContent;
                 }
             };
             return updater;
@@ -12320,7 +12376,7 @@
                     const identifiers = optionsDirective.dependentIdentifiers;
                     const baseArgs = [];
                     for (const id of identifiers) {
-                        const base = id.split('.')[0];
+                        const base = ExpressionUtils.baseIdentifier(id);
                         if (!baseArgs.includes(base))
                             baseArgs.push(base);
                     }
@@ -12400,7 +12456,7 @@
                 // Note: inline expressions receive entries and $ctx as parameters
                 const baseArgs = [];
                 for (const id of identifiers) {
-                    const base = id.split('.')[0];
+                    const base = ExpressionUtils.baseIdentifier(id);
                     if (!baseArgs.includes(base))
                         baseArgs.push(base);
                 }
@@ -13538,7 +13594,7 @@
                     const identifiers = optionsDirective.dependentIdentifiers;
                     const baseArgs = [];
                     for (const id of identifiers) {
-                        const base = id.split('.')[0];
+                        const base = ExpressionUtils.baseIdentifier(id);
                         if (!baseArgs.includes(base))
                             baseArgs.push(base);
                     }
@@ -13626,7 +13682,7 @@
                 // Note: inline expressions receive entries, observer, options, and $ctx as parameters
                 const baseArgs = [];
                 for (const id of identifiers) {
-                    const base = id.split('.')[0];
+                    const base = ExpressionUtils.baseIdentifier(id);
                     if (!baseArgs.includes(base))
                         baseArgs.push(base);
                 }
@@ -13759,7 +13815,7 @@
                     const identifiers = optionsDirective.dependentIdentifiers;
                     const baseArgs = [];
                     for (const id of identifiers) {
-                        const base = id.split('.')[0];
+                        const base = ExpressionUtils.baseIdentifier(id);
                         if (!baseArgs.includes(base))
                             baseArgs.push(base);
                     }
@@ -13839,7 +13895,7 @@
                 // Note: inline expressions receive entries and $ctx as parameters
                 const baseArgs = [];
                 for (const id of identifiers) {
-                    const base = id.split('.')[0];
+                    const base = ExpressionUtils.baseIdentifier(id);
                     if (!baseArgs.includes(base))
                         baseArgs.push(base);
                 }