@mmstack/primitives 20.0.0 → 20.0.1

package/fesm2022/mmstack-primitives.mjs

@@ -136,25 +136,112 @@ function debounce(source, opt) {
     return writable;
 }
 
+const { is } = Object;
+function mutable(initial, opt) {
+    const baseEqual = opt?.equal ?? is;
+    let trigger = false;
+    const equal = (a, b) => {
+        if (trigger)
+            return false;
+        return baseEqual(a, b);
+    };
+    const sig = signal(initial, {
+        ...opt,
+        equal,
+    });
+    const internalUpdate = sig.update;
+    sig.mutate = (updater) => {
+        trigger = true;
+        internalUpdate(updater);
+        trigger = false;
+    };
+    sig.inline = (updater) => {
+        sig.mutate((prev) => {
+            updater(prev);
+            return prev;
+        });
+    };
+    return sig;
+}
+/**
+ * Type guard function to check if a given `WritableSignal` is a `MutableSignal`.  This is useful
+ * for situations where you need to conditionally use the `mutate` or `inline` methods.
+ *
+ * @typeParam T - The type of the signal's value (optional, defaults to `any`).
+ * @param value - The `WritableSignal` to check.
+ * @returns `true` if the signal is a `MutableSignal`, `false` otherwise.
+ *
+ * @example
+ * const mySignal = signal(0);
+ * const myMutableSignal = mutable(0);
+ *
+ * if (isMutable(mySignal)) {
+ *   mySignal.mutate(x => x + 1); // This would cause a type error, as mySignal is not a MutableSignal.
+ * }
+ *
+ * if (isMutable(myMutableSignal)) {
+ *   myMutableSignal.mutate(x => x + 1); // This is safe.
+ * }
+ */
+function isMutable(value) {
+    return 'mutate' in value && typeof value.mutate === 'function';
+}
+
 function derived(source, optOrKey, opt) {
     const isArray = Array.isArray(untracked(source)) && typeof optOrKey === 'number';
     const from = typeof optOrKey === 'object' ? optOrKey.from : (v) => v[optOrKey];
     const onChange = typeof optOrKey === 'object'
         ? optOrKey.onChange
         : isArray
-            ? (next) => {
-                source.update((cur) => {
-                    const newArray = [...cur];
-                    newArray[optOrKey] = next;
-                    return newArray;
-                });
-            }
-            : (next) => {
-                source.update((cur) => ({ ...cur, [optOrKey]: next }));
-            };
+            ? isMutable(source)
+                ? (next) => {
+                    source.mutate((cur) => {
+                        cur[optOrKey] = next;
+                        return cur;
+                    });
+                }
+                : (next) => {
+                    source.update((cur) => {
+                        const newArray = [...cur];
+                        newArray[optOrKey] = next;
+                        return newArray;
+                    });
+                }
+            : isMutable(source)
+                ? (next) => {
+                    source.mutate((cur) => {
+                        cur[optOrKey] = next;
+                        return cur;
+                    });
+                }
+                : (next) => {
+                    source.update((cur) => ({ ...cur, [optOrKey]: next }));
+                };
     const rest = typeof optOrKey === 'object' ? optOrKey : opt;
-    const sig = toWritable(computed(() => from(source()), rest), (newVal) => onChange(newVal));
+    let baseEqual = rest?.equal ?? Object.is;
+    let trigger = false;
+    const equal = isMutable(source)
+        ? (a, b) => {
+            if (trigger)
+                return false;
+            return baseEqual(a, b);
+        }
+        : baseEqual;
+    const sig = toWritable(computed(() => from(source()), { ...rest, equal }), (newVal) => onChange(newVal));
     sig.from = from;
+    if (isMutable(source)) {
+        sig.mutate = (updater) => {
+            trigger = true;
+            sig.update(updater);
+            trigger = false;
+        };
+        sig.inline = (updater) => {
+            sig.mutate((prev) => {
+                updater(prev);
+                return prev;
+            });
+        };
+    }
     return sig;
 }
 /**
@@ -387,57 +474,6 @@ function mapArray(source, map, opt) {
     });
 }
 
-const { is } = Object;
-function mutable(initial, opt) {
-    const baseEqual = opt?.equal ?? is;
-    let trigger = false;
-    const equal = (a, b) => {
-        if (trigger)
-            return false;
-        return baseEqual(a, b);
-    };
-    const sig = signal(initial, {
-        ...opt,
-        equal,
-    });
-    const internalUpdate = sig.update;
-    sig.mutate = (updater) => {
-        trigger = true;
-        internalUpdate(updater);
-        trigger = false;
-    };
-    sig.inline = (updater) => {
-        sig.mutate((prev) => {
-            updater(prev);
-            return prev;
-        });
-    };
-    return sig;
-}
-/**
- * Type guard function to check if a given `WritableSignal` is a `MutableSignal`.  This is useful
- * for situations where you need to conditionally use the `mutate` or `inline` methods.
- *
- * @typeParam T - The type of the signal's value (optional, defaults to `any`).
- * @param value - The `WritableSignal` to check.
- * @returns `true` if the signal is a `MutableSignal`, `false` otherwise.
- *
- * @example
- * const mySignal = signal(0);
- * const myMutableSignal = mutable(0);
- *
- * if (isMutable(mySignal)) {
- *   mySignal.mutate(x => x + 1); // This would cause a type error, as mySignal is not a MutableSignal.
- * }
- *
- * if (isMutable(myMutableSignal)) {
- *   myMutableSignal.mutate(x => x + 1); // This is safe.
- * }
- */
-function isMutable(value) {
-    return 'mutate' in value && typeof value.mutate === 'function';
-}
-
 /**
  * Creates a read-only signal that reactively tracks whether a CSS media query
  * string currently matches.