@zeix/cause-effect 0.15.1 → 0.16.0

package/index.dev.js

@@ -1,380 +1,82 @@
-// src/scheduler.ts
-var active;
-var pending = new Set;
-var batchDepth = 0;
-var updateMap = new Map;
-var requestId;
-var updateDOM = () => {
-  requestId = undefined;
-  const updates = Array.from(updateMap.values());
-  updateMap.clear();
-  for (const update of updates) {
-    update();
+// src/errors.ts
+class CircularDependencyError extends Error {
+  constructor(where) {
+    super(`Circular dependency detected in ${where}`);
+    this.name = "CircularDependencyError";
   }
-};
-var requestTick = () => {
-  if (requestId)
-    cancelAnimationFrame(requestId);
-  requestId = requestAnimationFrame(updateDOM);
-};
-queueMicrotask(updateDOM);
-var watch = (notice) => {
-  const cleanups = new Set;
-  const w = notice;
-  w.off = (on) => {
-    cleanups.add(on);
-  };
-  w.cleanup = () => {
-    for (const cleanup of cleanups) {
-      cleanup();
-    }
-    cleanups.clear();
-  };
-  return w;
-};
-var subscribe = (watchers) => {
-  if (active && !watchers.has(active)) {
-    const watcher = active;
-    watchers.add(watcher);
-    active.off(() => {
-      watchers.delete(watcher);
-    });
+}
+
+class InvalidCallbackError extends TypeError {
+  constructor(where, value) {
+    super(`Invalid ${where} callback ${value}`);
+    this.name = "InvalidCallbackError";
   }
-};
-var notify = (watchers) => {
-  for (const watcher of watchers) {
-    if (batchDepth)
-      pending.add(watcher);
-    else
-      watcher();
+}
+
+class InvalidSignalValueError extends TypeError {
+  constructor(where, value) {
+    super(`Invalid signal value ${value} in ${where}`);
+    this.name = "InvalidSignalValueError";
   }
-};
-var flush = () => {
-  while (pending.size) {
-    const watchers = Array.from(pending);
-    pending.clear();
-    for (const watcher of watchers) {
-      watcher();
-    }
+}
+
+class NullishSignalValueError extends TypeError {
+  constructor(where) {
+    super(`Nullish signal values are not allowed in ${where}`);
+    this.name = "NullishSignalValueError";
   }
-};
-var batch = (fn) => {
-  batchDepth++;
-  try {
-    fn();
-  } finally {
-    flush();
-    batchDepth--;
+}
+
+class StoreKeyExistsError extends Error {
+  constructor(key, value) {
+    super(`Could not add store key "${key}" with value ${value} because it already exists`);
+    this.name = "StoreKeyExistsError";
   }
-};
-var observe = (run, watcher) => {
-  const prev = active;
-  active = watcher;
-  try {
-    run();
-  } finally {
-    active = prev;
+}
+
+class StoreKeyRangeError extends RangeError {
+  constructor(index) {
+    super(`Could not remove store index ${String(index)} because it is out of range`);
+    this.name = "StoreKeyRangeError";
   }
-};
-var enqueue = (fn, dedupe) => new Promise((resolve, reject) => {
-  updateMap.set(dedupe || Symbol(), () => {
-    try {
-      resolve(fn());
-    } catch (error) {
-      reject(error);
-    }
-  });
-  requestTick();
-});
+}
+
+class StoreKeyReadonlyError extends Error {
+  constructor(key, value) {
+    super(`Could not set store key "${key}" to ${value} because it is readonly`);
+    this.name = "StoreKeyReadonlyError";
+  }
+}
 
 // src/util.ts
+var UNSET = Symbol();
 var isString = (value) => typeof value === "string";
 var isNumber = (value) => typeof value === "number";
+var isSymbol = (value) => typeof value === "symbol";
 var isFunction = (fn) => typeof fn === "function";
 var isAsyncFunction = (fn) => isFunction(fn) && fn.constructor.name === "AsyncFunction";
 var isObjectOfType = (value, type) => Object.prototype.toString.call(value) === `[object ${type}]`;
 var isRecord = (value) => isObjectOfType(value, "Object");
+var isRecordOrArray = (value) => isRecord(value) || Array.isArray(value);
 var validArrayIndexes = (keys) => {
   if (!keys.length)
     return null;
   const indexes = keys.map((k) => isString(k) ? parseInt(k, 10) : isNumber(k) ? k : NaN);
   return indexes.every((index) => Number.isFinite(index) && index >= 0) ? indexes.sort((a, b) => a - b) : null;
 };
-var hasMethod = (obj, methodName) => (methodName in obj) && isFunction(obj[methodName]);
 var isAbortError = (error) => error instanceof DOMException && error.name === "AbortError";
 var toError = (reason) => reason instanceof Error ? reason : Error(String(reason));
-
-class CircularDependencyError extends Error {
-  constructor(where) {
-    super(`Circular dependency in ${where} detected`);
-    this.name = "CircularDependencyError";
-  }
-}
-
-// src/state.ts
-var TYPE_STATE = "State";
-var state = (initialValue) => {
-  const watchers = new Set;
-  let value = initialValue;
-  const s = {
-    [Symbol.toStringTag]: TYPE_STATE,
-    get: () => {
-      subscribe(watchers);
-      return value;
-    },
-    set: (v) => {
-      if (isEqual(value, v))
-        return;
-      value = v;
-      notify(watchers);
-      if (UNSET === value)
-        watchers.clear();
-    },
-    update: (fn) => {
-      s.set(fn(value));
-    }
-  };
-  return s;
-};
-var isState = (value) => isObjectOfType(value, TYPE_STATE);
-
-// src/effect.ts
-var effect = (callback) => {
-  const isAsync = isAsyncFunction(callback);
-  let running = false;
-  let controller;
-  const run = watch(() => observe(() => {
-    if (running)
-      throw new CircularDependencyError("effect");
-    running = true;
-    controller?.abort();
-    controller = undefined;
-    let cleanup;
-    try {
-      if (isAsync) {
-        controller = new AbortController;
-        const currentController = controller;
-        callback(controller.signal).then((cleanup2) => {
-          if (isFunction(cleanup2) && controller === currentController)
-            run.off(cleanup2);
-        }).catch((error) => {
-          if (!isAbortError(error))
-            console.error("Async effect error:", error);
-        });
-      } else {
-        cleanup = callback();
-        if (isFunction(cleanup))
-          run.off(cleanup);
-      }
-    } catch (error) {
-      if (!isAbortError(error))
-        console.error("Effect callback error:", error);
-    }
-    running = false;
-  }, run));
-  run();
-  return () => {
-    controller?.abort();
-    run.cleanup();
-  };
-};
-
-// src/store.ts
-var TYPE_STORE = "Store";
-var store = (initialValue) => {
-  const watchers = new Set;
-  const eventTarget = new EventTarget;
-  const signals = new Map;
-  const cleanups = new Map;
-  const size = state(0);
-  const current = () => {
-    const keys = Array.from(signals.keys());
-    const arrayIndexes = validArrayIndexes(keys);
-    if (arrayIndexes)
-      return arrayIndexes.map((index) => signals.get(String(index))?.get());
-    const record = {};
-    for (const [key, signal] of signals) {
-      record[key] = signal.get();
-    }
+var recordToArray = (record) => {
+  const indexes = validArrayIndexes(Object.keys(record));
+  if (indexes === null)
     return record;
-  };
-  const emit = (type, detail) => eventTarget.dispatchEvent(new CustomEvent(type, { detail }));
-  const addProperty = (key, value) => {
-    const stringKey = String(key);
-    const signal = toMutableSignal(value);
-    signals.set(stringKey, signal);
-    const cleanup = effect(() => {
-      const currentValue = signal.get();
-      if (currentValue != null)
-        emit("store-change", { [key]: currentValue });
-    });
-    cleanups.set(stringKey, cleanup);
-  };
-  const removeProperty = (key) => {
-    const stringKey = String(key);
-    signals.delete(stringKey);
-    const cleanup = cleanups.get(stringKey);
-    if (cleanup)
-      cleanup();
-    cleanups.delete(stringKey);
-  };
-  const reconcile = (oldValue, newValue) => {
-    const changes = diff(oldValue, newValue);
-    batch(() => {
-      if (Object.keys(changes.add).length) {
-        for (const key in changes.add) {
-          const value = changes.add[key];
-          if (value != null)
-            addProperty(key, value);
-        }
-        emit("store-add", changes.add);
-      }
-      if (Object.keys(changes.change).length) {
-        for (const key in changes.change) {
-          const signal = signals.get(key);
-          const value = changes.change[key];
-          if (signal && value != null && hasMethod(signal, "set"))
-            signal.set(value);
-        }
-        emit("store-change", changes.change);
-      }
-      if (Object.keys(changes.remove).length) {
-        for (const key in changes.remove) {
-          removeProperty(key);
-        }
-        emit("store-remove", changes.remove);
-      }
-      size.set(signals.size);
-    });
-    return changes.changed;
-  };
-  reconcile({}, initialValue);
-  setTimeout(() => {
-    const initialAdditionsEvent = new CustomEvent("store-add", {
-      detail: initialValue
-    });
-    eventTarget.dispatchEvent(initialAdditionsEvent);
-  }, 0);
-  const storeProps = [
-    "add",
-    "get",
-    "remove",
-    "set",
-    "update",
-    "addEventListener",
-    "removeEventListener",
-    "dispatchEvent",
-    "size"
-  ];
-  return new Proxy({}, {
-    get(_target, prop) {
-      switch (prop) {
-        case "add":
-          return (k, v) => {
-            if (!signals.has(k)) {
-              addProperty(k, v);
-              notify(watchers);
-              emit("store-add", {
-                [k]: v
-              });
-              size.set(signals.size);
-            }
-          };
-        case "get":
-          return () => {
-            subscribe(watchers);
-            return current();
-          };
-        case "remove":
-          return (k) => {
-            if (signals.has(k)) {
-              removeProperty(k);
-              notify(watchers);
-              emit("store-remove", { [k]: UNSET });
-              size.set(signals.size);
-            }
-          };
-        case "set":
-          return (v) => {
-            if (reconcile(current(), v)) {
-              notify(watchers);
-              if (UNSET === v)
-                watchers.clear();
-            }
-          };
-        case "update":
-          return (fn) => {
-            const oldValue = current();
-            const newValue = fn(oldValue);
-            if (reconcile(oldValue, newValue)) {
-              notify(watchers);
-              if (UNSET === newValue)
-                watchers.clear();
-            }
-          };
-        case "addEventListener":
-          return eventTarget.addEventListener.bind(eventTarget);
-        case "removeEventListener":
-          return eventTarget.removeEventListener.bind(eventTarget);
-        case "dispatchEvent":
-          return eventTarget.dispatchEvent.bind(eventTarget);
-        case "size":
-          return size;
-      }
-      if (prop === Symbol.toStringTag)
-        return TYPE_STORE;
-      if (prop === Symbol.iterator) {
-        return function* () {
-          for (const [key, signal] of signals) {
-            yield [key, signal];
-          }
-        };
-      }
-      return signals.get(String(prop));
-    },
-    has(_target, prop) {
-      const key = String(prop);
-      return signals.has(key) || storeProps.includes(key) || prop === Symbol.toStringTag || prop === Symbol.iterator;
-    },
-    ownKeys() {
-      return Array.from(signals.keys()).map((key) => String(key));
-    },
-    getOwnPropertyDescriptor(_target, prop) {
-      const signal = signals.get(String(prop));
-      return signal ? {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: signal
-      } : undefined;
-    }
-  });
+  const array = [];
+  for (const index of indexes) {
+    array.push(record[String(index)]);
+  }
+  return array;
 };
-var isStore = (value) => isObjectOfType(value, TYPE_STORE);
-
-// src/signal.ts
-var UNSET = Symbol();
-var isSignal = (value) => isState(value) || isComputed(value) || isStore(value);
-function toSignal(value) {
-  if (isSignal(value))
-    return value;
-  if (isComputedCallback(value))
-    return computed(value);
-  if (Array.isArray(value))
-    return store(value);
-  if (Array.isArray(value) || isRecord(value))
-    return store(value);
-  return state(value);
-}
-function toMutableSignal(value) {
-  if (isState(value) || isStore(value))
-    return value;
-  if (Array.isArray(value))
-    return store(value);
-  if (isRecord(value))
-    return store(value);
-  return state(value);
-}
+var valueString = (value) => isString(value) ? `"${value}"` : !!value && typeof value === "object" ? JSON.stringify(value) : String(value);
 
 // src/diff.ts
 var isEqual = (a, b, visited) => {
@@ -422,45 +124,118 @@ var isEqual = (a, b, visited) => {
   }
 };
 var diff = (oldObj, newObj) => {
-  const visited = new WeakSet;
-  const diffRecords = (oldRecord, newRecord) => {
-    const add = {};
-    const change = {};
-    const remove = {};
-    const oldKeys = Object.keys(oldRecord);
-    const newKeys = Object.keys(newRecord);
-    const allKeys = new Set([...oldKeys, ...newKeys]);
-    for (const key of allKeys) {
-      const oldHas = key in oldRecord;
-      const newHas = key in newRecord;
-      if (!oldHas && newHas) {
-        add[key] = newRecord[key];
-        continue;
-      } else if (oldHas && !newHas) {
-        remove[key] = UNSET;
-        continue;
-      }
-      const oldValue = oldRecord[key];
-      const newValue = newRecord[key];
-      if (!isEqual(oldValue, newValue, visited))
-        change[key] = newValue;
-    }
-    const changed = Object.keys(add).length > 0 || Object.keys(change).length > 0 || Object.keys(remove).length > 0;
+  const oldValid = isRecordOrArray(oldObj);
+  const newValid = isRecordOrArray(newObj);
+  if (!oldValid || !newValid) {
+    const changed2 = !Object.is(oldObj, newObj);
     return {
-      changed,
-      add,
-      change,
-      remove
+      changed: changed2,
+      add: changed2 && newValid ? newObj : {},
+      change: {},
+      remove: changed2 && oldValid ? oldObj : {}
     };
+  }
+  const visited = new WeakSet;
+  const add = {};
+  const change = {};
+  const remove = {};
+  const oldKeys = Object.keys(oldObj);
+  const newKeys = Object.keys(newObj);
+  const allKeys = new Set([...oldKeys, ...newKeys]);
+  for (const key of allKeys) {
+    const oldHas = key in oldObj;
+    const newHas = key in newObj;
+    if (!oldHas && newHas) {
+      add[key] = newObj[key];
+      continue;
+    } else if (oldHas && !newHas) {
+      remove[key] = UNSET;
+      continue;
+    }
+    const oldValue = oldObj[key];
+    const newValue = newObj[key];
+    if (!isEqual(oldValue, newValue, visited))
+      change[key] = newValue;
+  }
+  const changed = Object.keys(add).length > 0 || Object.keys(change).length > 0 || Object.keys(remove).length > 0;
+  return {
+    changed,
+    add,
+    change,
+    remove
   };
-  return diffRecords(oldObj, newObj);
+};
+
+// src/system.ts
+var activeWatcher;
+var pendingWatchers = new Set;
+var batchDepth = 0;
+var createWatcher = (watch) => {
+  const cleanups = new Set;
+  const w = watch;
+  w.unwatch = (cleanup) => {
+    cleanups.add(cleanup);
+  };
+  w.cleanup = () => {
+    for (const cleanup of cleanups)
+      cleanup();
+    cleanups.clear();
+  };
+  return w;
+};
+var subscribe = (watchers) => {
+  if (activeWatcher && !watchers.has(activeWatcher)) {
+    const watcher = activeWatcher;
+    watcher.unwatch(() => {
+      watchers.delete(watcher);
+    });
+    watchers.add(watcher);
+  }
+};
+var notify = (watchers) => {
+  for (const watcher of watchers) {
+    if (batchDepth)
+      pendingWatchers.add(watcher);
+    else
+      watcher();
+  }
+};
+var flush = () => {
+  while (pendingWatchers.size) {
+    const watchers = Array.from(pendingWatchers);
+    pendingWatchers.clear();
+    for (const watcher of watchers)
+      watcher();
+  }
+};
+var batch = (fn) => {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    flush();
+    batchDepth--;
+  }
+};
+var observe = (run, watcher) => {
+  const prev = activeWatcher;
+  activeWatcher = watcher;
+  try {
+    run();
+  } finally {
+    activeWatcher = prev;
+  }
 };
 
 // src/computed.ts
 var TYPE_COMPUTED = "Computed";
-var computed = (fn) => {
+var createComputed = (callback, initialValue = UNSET) => {
+  if (!isComputedCallback(callback))
+    throw new InvalidCallbackError("computed", valueString(callback));
+  if (initialValue == null)
+    throw new NullishSignalValueError("computed");
   const watchers = new Set;
-  let value = UNSET;
+  let value = initialValue;
   let error;
   let controller;
   let dirty = true;
@@ -485,29 +260,29 @@ var computed = (fn) => {
     value = UNSET;
     error = newError;
   };
-  const settle = (settleFn) => (arg) => {
+  const settle = (fn) => (arg) => {
     computing = false;
     controller = undefined;
-    settleFn(arg);
+    fn(arg);
     if (changed)
       notify(watchers);
   };
-  const mark = watch(() => {
+  const watcher = createWatcher(() => {
     dirty = true;
     controller?.abort();
     if (watchers.size)
       notify(watchers);
     else
-      mark.cleanup();
+      watcher.cleanup();
   });
-  mark.off(() => {
+  watcher.unwatch(() => {
     controller?.abort();
   });
   const compute = () => observe(() => {
     if (computing)
       throw new CircularDependencyError("computed");
     changed = false;
-    if (isAsyncFunction(fn)) {
+    if (isAsyncFunction(callback)) {
       if (controller)
         return value;
       controller = new AbortController;
@@ -522,7 +297,7 @@ var computed = (fn) => {
     let result;
     computing = true;
     try {
-      result = controller ? fn(controller.signal) : fn();
+      result = controller ? callback(value, controller.signal) : callback(value);
     } catch (e) {
       if (isAbortError(e))
         nil();
@@ -538,8 +313,8 @@ var computed = (fn) => {
     else
       ok(result);
     computing = false;
-  }, mark);
-  const c = {
+  }, watcher);
+  return {
     [Symbol.toStringTag]: TYPE_COMPUTED,
     get: () => {
       subscribe(watchers);
@@ -551,10 +326,51 @@ var computed = (fn) => {
       return value;
     }
   };
-  return c;
 };
 var isComputed = (value) => isObjectOfType(value, TYPE_COMPUTED);
-var isComputedCallback = (value) => isFunction(value) && value.length < 2;
+var isComputedCallback = (value) => isFunction(value) && value.length < 3;
+// src/effect.ts
+var createEffect = (callback) => {
+  if (!isFunction(callback) || callback.length > 1)
+    throw new InvalidCallbackError("effect", valueString(callback));
+  const isAsync = isAsyncFunction(callback);
+  let running = false;
+  let controller;
+  const watcher = createWatcher(() => observe(() => {
+    if (running)
+      throw new CircularDependencyError("effect");
+    running = true;
+    controller?.abort();
+    controller = undefined;
+    let cleanup;
+    try {
+      if (isAsync) {
+        controller = new AbortController;
+        const currentController = controller;
+        callback(controller.signal).then((cleanup2) => {
+          if (isFunction(cleanup2) && controller === currentController)
+            watcher.unwatch(cleanup2);
+        }).catch((error) => {
+          if (!isAbortError(error))
+            console.error("Async effect error:", error);
+        });
+      } else {
+        cleanup = callback();
+        if (isFunction(cleanup))
+          watcher.unwatch(cleanup);
+      }
+    } catch (error) {
+      if (!isAbortError(error))
+        console.error("Effect callback error:", error);
+    }
+    running = false;
+  }, watcher));
+  watcher();
+  return () => {
+    controller?.abort();
+    watcher.cleanup();
+  };
+};
 // src/match.ts
 function match(result, handlers) {
   try {
@@ -562,8 +378,8 @@ function match(result, handlers) {
       handlers.nil?.();
     else if (result.errors)
       handlers.err?.(result.errors);
-    else
-      handlers.ok?.(result.values);
+    else if (result.ok)
+      handlers.ok(result.values);
   } catch (error) {
     if (handlers.err && (!result.errors || !result.errors.includes(toError(error))))
       handlers.err(result.errors ? [...result.errors, toError(error)] : [toError(error)]);
@@ -574,42 +390,339 @@ function match(result, handlers) {
 // src/resolve.ts
 function resolve(signals) {
   const errors = [];
-  let pending2 = false;
+  let pending = false;
   const values = {};
   for (const [key, signal] of Object.entries(signals)) {
     try {
       const value = signal.get();
       if (value === UNSET)
-        pending2 = true;
+        pending = true;
       else
         values[key] = value;
     } catch (e) {
       errors.push(toError(e));
     }
   }
-  if (pending2)
+  if (pending)
     return { ok: false, pending: true };
   if (errors.length > 0)
     return { ok: false, errors };
   return { ok: true, values };
 }
+// src/state.ts
+var TYPE_STATE = "State";
+var createState = (initialValue) => {
+  if (initialValue == null)
+    throw new NullishSignalValueError("state");
+  const watchers = new Set;
+  let value = initialValue;
+  const state = {
+    [Symbol.toStringTag]: TYPE_STATE,
+    get: () => {
+      subscribe(watchers);
+      return value;
+    },
+    set: (newValue) => {
+      if (newValue == null)
+        throw new NullishSignalValueError("state");
+      if (isEqual(value, newValue))
+        return;
+      value = newValue;
+      notify(watchers);
+      if (UNSET === value)
+        watchers.clear();
+    },
+    update: (updater) => {
+      if (!isFunction(updater))
+        throw new InvalidCallbackError("state update", valueString(updater));
+      state.set(updater(value));
+    }
+  };
+  return state;
+};
+var isState = (value) => isObjectOfType(value, TYPE_STATE);
+
+// src/store.ts
+var TYPE_STORE = "Store";
+var createStore = (initialValue) => {
+  if (initialValue == null)
+    throw new NullishSignalValueError("store");
+  const watchers = new Set;
+  const listeners = {
+    add: new Set,
+    change: new Set,
+    remove: new Set,
+    sort: new Set
+  };
+  const signals = new Map;
+  const signalWatchers = new Map;
+  const isArrayLike = Array.isArray(initialValue);
+  const size = createState(0);
+  const current = () => {
+    const record = {};
+    for (const [key, signal] of signals) {
+      record[key] = signal.get();
+    }
+    return record;
+  };
+  const emit = (key, changes) => {
+    Object.freeze(changes);
+    for (const listener of listeners[key]) {
+      listener(changes);
+    }
+  };
+  const getSortedIndexes = () => Array.from(signals.keys()).map((k) => Number(k)).filter((n) => Number.isInteger(n)).sort((a, b) => a - b);
+  const isValidValue = (key, value) => {
+    if (value == null)
+      throw new NullishSignalValueError(`store for key "${key}"`);
+    if (value === UNSET)
+      return true;
+    if (isSymbol(value) || isFunction(value) || isComputed(value))
+      throw new InvalidSignalValueError(`store for key "${key}"`, valueString(value));
+    return true;
+  };
+  const addProperty = (key, value, single = false) => {
+    if (!isValidValue(key, value))
+      return false;
+    const signal = isState(value) || isStore(value) ? value : isRecord(value) || Array.isArray(value) ? createStore(value) : createState(value);
+    signals.set(key, signal);
+    const watcher = createWatcher(() => observe(() => {
+      emit("change", {
+        [key]: signal.get()
+      });
+    }, watcher));
+    watcher();
+    signalWatchers.set(key, watcher);
+    if (single) {
+      size.set(signals.size);
+      notify(watchers);
+      emit("add", {
+        [key]: value
+      });
+    }
+    return true;
+  };
+  const removeProperty = (key, single = false) => {
+    const ok = signals.delete(key);
+    if (ok) {
+      const watcher = signalWatchers.get(key);
+      if (watcher)
+        watcher.cleanup();
+      signalWatchers.delete(key);
+    }
+    if (single) {
+      size.set(signals.size);
+      notify(watchers);
+      emit("remove", {
+        [key]: UNSET
+      });
+    }
+    return ok;
+  };
+  const reconcile = (oldValue, newValue, initialRun) => {
+    const changes = diff(oldValue, newValue);
+    batch(() => {
+      if (Object.keys(changes.add).length) {
+        for (const key in changes.add) {
+          const value = changes.add[key] ?? UNSET;
+          addProperty(key, value);
+        }
+        if (initialRun) {
+          setTimeout(() => {
+            emit("add", changes.add);
+          }, 0);
+        } else {
+          emit("add", changes.add);
+        }
+      }
+      if (Object.keys(changes.change).length) {
+        for (const key in changes.change) {
+          const value = changes.change[key];
+          if (!isValidValue(key, value))
+            continue;
+          const signal = signals.get(key);
+          if (isMutableSignal(signal))
+            signal.set(value);
+          else
+            throw new StoreKeyReadonlyError(key, valueString(value));
+        }
+        emit("change", changes.change);
+      }
+      if (Object.keys(changes.remove).length) {
+        for (const key in changes.remove)
+          removeProperty(key);
+        emit("remove", changes.remove);
+      }
+      size.set(signals.size);
+    });
+    return changes.changed;
+  };
+  reconcile({}, initialValue, true);
+  const store = {
+    add: isArrayLike ? (v) => {
+      const nextIndex = signals.size;
+      const key = String(nextIndex);
+      addProperty(key, v, true);
+    } : (k, v) => {
+      if (!signals.has(k))
+        addProperty(k, v, true);
+      else
+        throw new StoreKeyExistsError(k, valueString(v));
+    },
+    get: () => {
+      subscribe(watchers);
+      return recordToArray(current());
+    },
+    remove: isArrayLike ? (index) => {
+      const currentArray = recordToArray(current());
+      const currentLength = signals.size;
+      if (!Array.isArray(currentArray) || index <= -currentLength || index >= currentLength)
+        throw new StoreKeyRangeError(index);
+      const newArray = [...currentArray];
+      newArray.splice(index, 1);
+      if (reconcile(currentArray, newArray))
+        notify(watchers);
+    } : (k) => {
+      if (signals.has(k))
+        removeProperty(k, true);
+    },
+    set: (v) => {
+      if (reconcile(current(), v)) {
+        notify(watchers);
+        if (UNSET === v)
+          watchers.clear();
+      }
+    },
+    update: (fn) => {
+      const oldValue = current();
+      const newValue = fn(recordToArray(oldValue));
+      if (reconcile(oldValue, newValue)) {
+        notify(watchers);
+        if (UNSET === newValue)
+          watchers.clear();
+      }
+    },
+    sort: (compareFn) => {
+      const entries = Array.from(signals.entries()).map(([key, signal]) => [key, signal.get()]).sort(compareFn ? (a, b) => compareFn(a[1], b[1]) : (a, b) => String(a[1]).localeCompare(String(b[1])));
+      const newOrder = entries.map(([key]) => String(key));
+      const newSignals = new Map;
+      entries.forEach(([key], newIndex) => {
+        const oldKey = String(key);
+        const newKey = isArrayLike ? String(newIndex) : String(key);
+        const signal = signals.get(oldKey);
+        if (signal)
+          newSignals.set(newKey, signal);
+      });
+      signals.clear();
+      newSignals.forEach((signal, key) => signals.set(key, signal));
+      notify(watchers);
+      emit("sort", newOrder);
+    },
+    on: (type, listener) => {
+      listeners[type].add(listener);
+      return () => listeners[type].delete(listener);
+    },
+    size
+  };
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === Symbol.toStringTag)
+        return TYPE_STORE;
+      if (prop === Symbol.isConcatSpreadable)
+        return isArrayLike;
+      if (prop === Symbol.iterator)
+        return isArrayLike ? function* () {
+          const indexes = getSortedIndexes();
+          for (const index of indexes) {
+            const signal = signals.get(String(index));
+            if (signal)
+              yield signal;
+          }
+        } : function* () {
+          for (const [key, signal] of signals)
+            yield [key, signal];
+        };
+      if (isSymbol(prop))
+        return;
+      if (prop in store)
+        return store[prop];
+      if (prop === "length" && isArrayLike) {
+        subscribe(watchers);
+        return size.get();
+      }
+      return signals.get(prop);
+    },
+    has(_target, prop) {
+      const stringProp = String(prop);
+      return stringProp && signals.has(stringProp) || Object.keys(store).includes(stringProp) || prop === Symbol.toStringTag || prop === Symbol.iterator || prop === Symbol.isConcatSpreadable || prop === "length" && isArrayLike;
+    },
+    ownKeys() {
+      return isArrayLike ? getSortedIndexes().map((key) => String(key)).concat(["length"]) : Array.from(signals.keys()).map((key) => String(key));
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const nonEnumerable = (value) => ({
+        enumerable: false,
+        configurable: true,
+        writable: false,
+        value
+      });
+      if (prop === "length" && isArrayLike)
+        return {
+          enumerable: true,
+          configurable: true,
+          writable: false,
+          value: size.get()
+        };
+      if (prop === Symbol.isConcatSpreadable)
+        return nonEnumerable(isArrayLike);
+      if (prop === Symbol.toStringTag)
+        return nonEnumerable(TYPE_STORE);
+      if (isSymbol(prop))
+        return;
+      if (Object.keys(store).includes(prop))
+        return nonEnumerable(store[prop]);
+      const signal = signals.get(prop);
+      return signal ? {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: signal
+      } : undefined;
+    }
+  });
+};
+var isStore = (value) => isObjectOfType(value, TYPE_STORE);
+
+// src/signal.ts
+var isSignal = (value) => isState(value) || isComputed(value) || isStore(value);
+var isMutableSignal = (value) => isState(value) || isStore(value);
+function toSignal(value) {
+  if (isSignal(value))
+    return value;
+  if (isComputedCallback(value))
+    return createComputed(value);
+  if (Array.isArray(value) || isRecord(value))
+    return createStore(value);
+  return createState(value);
+}
 export {
-  watch,
+  valueString,
   toSignal,
-  toMutableSignal,
   toError,
   subscribe,
-  store,
-  state,
   resolve,
   observe,
   notify,
   match,
+  isSymbol,
   isString,
   isStore,
   isState,
   isSignal,
+  isRecordOrArray,
+  isRecord,
   isNumber,
+  isMutableSignal,
   isFunction,
   isEqual,
   isComputedCallback,
@@ -617,14 +730,22 @@ export {
   isAsyncFunction,
   isAbortError,
   flush,
-  enqueue,
-  effect,
   diff,
-  computed,
+  createWatcher,
+  createStore,
+  createState,
+  createEffect,
+  createComputed,
   batch,
   UNSET,
   TYPE_STORE,
   TYPE_STATE,
   TYPE_COMPUTED,
+  StoreKeyReadonlyError,
+  StoreKeyRangeError,
+  StoreKeyExistsError,
+  NullishSignalValueError,
+  InvalidSignalValueError,
+  InvalidCallbackError,
   CircularDependencyError
 };