@mintjamsinc/ichigojs 0.1.84 → 0.1.86

package/dist/ichigo.esm.js

@@ -6760,28 +6760,29 @@ class ExpressionUtils {
                 }
             }
             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)
@@ -6801,7 +6802,6 @@ class ExpressionUtils {
                         }
                         else {
                             // other object types (CallExpression, etc.) — stop here
-                            stop = true;
                             break;
                         }
                     }
@@ -6809,10 +6809,15 @@ class ExpressionUtils {
                         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]) {
@@ -6826,6 +6831,16 @@ class ExpressionUtils {
         });
         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.
@@ -7240,7 +7255,7 @@ class ExpressionEvaluator {
         // 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);
             }
@@ -7781,13 +7796,20 @@ class VBindDirective {
     }
     /**
      * 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);
+            }
         }
     }
 }
@@ -8027,6 +8049,11 @@ class ReactiveProxy {
      * 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).
@@ -8389,24 +8416,47 @@ class ReactiveProxy {
      */
     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.
@@ -8902,18 +8952,15 @@ class VBindings {
      * 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")
@@ -9978,7 +10025,7 @@ class VTextEvaluator {
             // 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);
                 }
@@ -12054,6 +12101,11 @@ class VHtmlDirective {
      * 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.
      */
@@ -12104,10 +12156,14 @@ class VHtmlDirective {
             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;
@@ -12314,7 +12370,7 @@ class VIntersectionDirective {
                 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);
                 }
@@ -12394,7 +12450,7 @@ class VIntersectionDirective {
             // 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);
             }
@@ -13532,7 +13588,7 @@ class VPerformanceDirective {
                 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);
                 }
@@ -13620,7 +13676,7 @@ class VPerformanceDirective {
             // 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);
             }
@@ -13753,7 +13809,7 @@ class VResizeDirective {
                 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);
                 }
@@ -13833,7 +13889,7 @@ class VResizeDirective {
             // 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);
             }