@mintjamsinc/ichigojs 0.1.60 → 0.1.61

package/dist/ichigo.esm.js

@@ -8237,6 +8237,13 @@ class VBindings {
      * their own alias (e.g. "file" -> "files[0]") without overwriting each other.
      */
     #localAliases = new Map();
+    /**
+     * Setters for writable computed properties. When a key registered here is assigned
+     * through the bindings proxy (e.g. via v-model or `bindings.set`), the setter is invoked
+     * instead of writing directly to the local store. The cached value of the computed property
+     * is updated by the recompute cycle through `setSilent`, which bypasses this routing.
+     */
+    #writableComputeds = new Map();
     /**
      * Creates a new instance of VBindings.
      * @param parent The parent bindings, if any.
@@ -8256,6 +8263,14 @@ class VBindings {
                 return this.#parent?.raw[key];
             },
             set: (obj, key, value) => {
+                // If this key is a writable computed, route the assignment through its setter.
+                // `setSilent` (used to update the cached value during recompute) sets `suppressOnChange`,
+                // which bypasses this routing so the cached value can be written directly.
+                if (!this.#suppressOnChange && this.#writableComputeds.has(key)) {
+                    const setter = this.#writableComputeds.get(key);
+                    setter(value);
+                    return true;
+                }
                 let target = obj;
                 if (!Reflect.has(target, key)) {
                     for (let parent = this.#parent; parent; parent = parent.#parent) {
@@ -8442,6 +8457,16 @@ class VBindings {
             this.#suppressOnChange = false;
         }
     }
+    /**
+     * Registers a setter for a writable computed property. When the given key is assigned
+     * through the bindings proxy, the setter will be invoked instead of writing directly to
+     * the local store.
+     * @param key The computed property name.
+     * @param setter The setter function to invoke on assignment.
+     */
+    registerWritableComputed(key, setter) {
+        this.#writableComputeds.set(key, setter);
+    }
     /**
      * Manually adds an identifier to the set of changed identifiers.
      * This is useful for computed properties that need to mark themselves as changed
@@ -13118,8 +13143,15 @@ class VApplication {
         this.#logger = this.#logManager.getLogger('VApplication');
         // Analyze function dependencies
         this.#functionDependencies = ExpressionUtils.analyzeFunctionDependencies(options.methods || {});
-        // Analyze computed dependencies
-        this.#computedDependencies = ExpressionUtils.analyzeFunctionDependencies(options.computed || {});
+        // Analyze computed dependencies based on getter functions only.
+        // Writable computeds (defined as { get, set }) contribute their getter for dependency analysis.
+        const computedGetters = {};
+        if (options.computed) {
+            for (const [key, def] of Object.entries(options.computed)) {
+                computedGetters[key] = VApplication.#getComputedGetter(def);
+            }
+        }
+        this.#computedDependencies = ExpressionUtils.analyzeFunctionDependencies(computedGetters);
         // Initialize watcher manager
         this.#watcher = new VWatcher(this.#logger);
         // Initialize bindings from data, computed, and methods
@@ -13262,6 +13294,26 @@ class VApplication {
             }
         }
     }
+    /**
+     * Extracts the getter function from a computed property definition.
+     * Supports both bare function form and { get, set } object form.
+     */
+    static #getComputedGetter(def) {
+        if (typeof def === 'function') {
+            return def;
+        }
+        return def.get;
+    }
+    /**
+     * Extracts the setter function from a computed property definition, if any.
+     * Returns undefined for read-only (function-form) computed properties.
+     */
+    static #getComputedSetter(def) {
+        if (typeof def === 'function') {
+            return undefined;
+        }
+        return def.set;
+    }
     /**
      * Computes dependent identifiers for a given computed property and value.
      * This is used to track dependencies in directives like v-for.
@@ -13324,6 +13376,20 @@ class VApplication {
                 }
             }
         }
+        // Register setters for writable computed properties so that assignments to them
+        // (e.g. via v-model or direct mutation through bindings.raw) route through the user-provided
+        // setter, which typically writes back to underlying reactive properties.
+        if (this.#options.computed) {
+            for (const [key, def] of Object.entries(this.#options.computed)) {
+                const setter = VApplication.#getComputedSetter(def);
+                if (setter) {
+                    const bindings = this.#bindings;
+                    this.#bindings.registerWritableComputed(key, (value) => {
+                        setter.call(bindings.raw, value);
+                    });
+                }
+            }
+        }
         // Add computed properties (initialization mode)
         this.#recomputeProperties(true);
     }
@@ -13482,7 +13548,7 @@ class VApplication {
                 return;
             }
             // Now compute this property
-            const computedFn = this.#options.computed[key];
+            const computedFn = VApplication.#getComputedGetter(this.#options.computed[key]);
             try {
                 const oldValue = this.#bindings?.get(key);
                 const newValue = computedFn.call(this.#bindings?.raw);