@mintjamsinc/ichigojs 0.1.45 → 0.1.47

package/dist/ichigo.cjs

@@ -7501,13 +7501,15 @@
                     }
                     else if (typeof cls === 'object' && cls !== null) {
                         // Handle object format within array: { className: condition }
-                        return Object.keys(cls).filter(key => cls[key]);
+                        // Keys may contain space-separated class names
+                        return Object.keys(cls).filter(key => cls[key]).flatMap(key => key.split(/\s+/).filter(Boolean));
                     }
                     return [];
                 });
             }
             else if (typeof value === 'object' && value !== null) {
-                newClasses = Object.keys(value).filter(key => value[key]);
+                // Keys may contain space-separated class names
+                newClasses = Object.keys(value).filter(key => value[key]).flatMap(key => key.split(/\s+/).filter(Boolean));
             }
             // Remove previously managed classes
             this.#managedClasses.forEach(cls => element.classList.remove(cls));
@@ -12626,7 +12628,7 @@
         #initializeBindings() {
             // Create bindings with change tracking
             this.#bindings = new VBindings({
-                onChange: (identifier) => {
+                onChange: () => {
                     this.#scheduleUpdate();
                 },
                 vApplication: this
@@ -12804,17 +12806,20 @@
                 processing.add(key);
                 // Get the dependencies for this computed property
                 const deps = this.#computedDependencies[key] || [];
-                // If none of the dependencies have changed, skip recomputation (unless it's initialization)
-                if (!isInitialization && !deps.some(dep => allChanges.has(dep))) {
-                    computed.add(key);
-                    return;
-                }
-                // First, recursively compute any dependent computed properties
+                // First, recursively compute any dependent computed properties.
+                // This must happen before the change check so that computed→computed
+                // dependency chains are resolved and allChanges is up-to-date.
                 for (const dep of deps) {
                     if (this.#options.computed[dep]) {
                         compute(dep);
                     }
                 }
+                // If none of the dependencies have changed, skip recomputation (unless it's initialization).
+                // Checked after recursive computation to detect transitive changes through computed properties.
+                if (!isInitialization && !deps.some(dep => allChanges.has(dep))) {
+                    computed.add(key);
+                    return;
+                }
                 // Now compute this property
                 const computedFn = this.#options.computed[key];
                 try {
@@ -12856,13 +12861,10 @@
                 computed.add(key);
                 processing.delete(key);
             };
-            // Find all computed properties that need to be recomputed
-            for (const [key, deps] of Object.entries(this.#computedDependencies)) {
-                // During initialization, compute all properties
-                // Otherwise, check if any dependency has changed
-                if (isInitialization || deps.some(dep => allChanges.has(dep))) {
-                    compute(key);
-                }
+            // Compute all properties; the recursive logic inside compute() handles
+            // dependency ordering and skips properties whose dependencies did not change.
+            for (const key of Object.keys(this.#computedDependencies)) {
+                compute(key);
             }
         }
         /**