@fluixi/reactive 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/lib/store/store.mjs

@@ -1 +1,644 @@
-import{$PROXY as h,batch as R,createEffect as d,createMemo as A,createSignal as E,untrack as C}from"@fluixi/reactive/signal";var O=Symbol("store-raw"),f=Symbol("store-node"),w=Symbol("store-has"),N=Symbol("store-self"),P=Symbol("store-track"),G=Symbol("store-name"),J=Symbol("store-store"),U=new WeakMap,v=new WeakMap;function K(e){let[t,n]=E(e),r=t;return r.$=n,r}function b(e){let t=U.get(e);return t||U.set(e,t={keys:new Map}),t}function I(e,t,n){let r=e.keys.get(t);return r||e.keys.set(t,r=K(n)),r}function $(e){let t=b(e);(t.all||(t.all=K()))()}function D(e,t){e.$(typeof t=="function"?()=>t:t)}function _(e){if(e==null||typeof e!="object")return!1;if(Array.isArray(e))return!0;let t=Object.getPrototypeOf(e);return t===Object.prototype||t===null}function p(e){if(!_(e))return e;let t=v.get(e);if(t)return t;let n=new Proxy(e,F);return v.set(e,n),n}var F={get(e,t,n){if(t===O||t===f)return e;if(t===h)return n;if(t===w)return i=>i in e;if(t==="__proxy")return!0;if(t===P||t===N)return $(e),n;let r=e[t];if(typeof r=="function"&&!Object.prototype.hasOwnProperty.call(e,t))return r;let o=Object.getOwnPropertyDescriptor(e,t);if(o&&o.get)return o.get.call(n);let s=I(b(e),t,r)();return _(s)?p(s):s},set(){return!0},deleteProperty(e,t){return t in e&&u(e,t,void 0),!0},has(e,t){return t===O||t===h||t===f||t===w||t===N||t===P?!0:(I(b(e),t,e[t])(),t in e)},ownKeys(e){return $(e),Reflect.ownKeys(e)},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e,t)}};function u(e,t,n){if(e[t]===n&&(n!==void 0||t in e))return;let o=Array.isArray(e),s=o?e.length:0;n===void 0?delete e[t]:e[t]=n;let i=b(e),a=i.keys.get(t);if(a&&D(a,n),o&&e.length!==s){let l=i.keys.get("length");l&&D(l,e.length)}i.all&&i.all.$(void 0)}function M(e,t){return typeof e=="function"?e(t):e}function g(e,t){for(let n of Object.keys(t)){let r=t[n],o=e[n];r&&typeof r=="object"&&!Array.isArray(r)&&o&&typeof o=="object"&&!Array.isArray(o)?g(o,r):u(e,n,r)}}function j(e){let t=[],n=e.replace(/\[([^\]]*)\]/g,".$1");for(let r of n.split("."))r.length&&t.push(r);return t}function W(e,t,n){let r=t.length-1;for(let s=0;s<r;s++){let i=t[s];if(i==="*"){let l=t.slice(s+1);if(Array.isArray(e))for(let m=0;m<e.length;m++)W(e[m],l,n);return}let a=e[i];(a==null||typeof a!="object")&&(a=/^\d+$/.test(t[s+1])?[]:{},u(e,i,a)),e=a}let o=t[r];if(o==="*"){if(Array.isArray(e))for(let s=0;s<e.length;s++)u(e,s,M(n,e[s]));return}u(e,o,M(n,e[o]))}function S(e,t,n){W(e,j(t),n)}function X(e,t){let n=t[0];if(typeof n=="function"&&t.length===1){let r=n(e);r&&r!==e&&g(e,r);return}if(Array.isArray(n)&&t.length===1){for(let r of n)Array.isArray(r)&&S(e,r[0],r[1]);return}if(n&&typeof n=="object"&&!Array.isArray(n)&&t.length===1){g(e,n);return}if(Array.isArray(t[1])&&t.length>=3){S(e,`${n}.${t[1].join(".")}`,t[2]);return}S(e,String(n),t[1])}function x(e){if(e==null||typeof e!="object")return e;if(Array.isArray(e))return e.map(x);let t={};for(let n of Object.keys(e))t[n]=x(e[n]);return t}function c(e,t){let n=e;for(let r of j(t)){if(n==null)return;n=n[r]}return n}var y=class{constructor(t,n={immutable:!0}){this.options=n;this.root=t,this.set=((...r)=>R(()=>X(this.root,r)))}get state(){return p(this.root)}get proxy(){return p(this.root)}get accessor(){return(()=>p(this.root))}unwrap(){return this.root}getNode(t){return this.root&&this.root[t]}get(t){if(t==null||t==="")return T(this.state);let n=this.state;for(let r of j(t)){if(n==null)return;n=n[r]}return T(n)}select(t){return A(()=>t(this.state))}subscribe(t){return d(()=>t(this.state))}watch(t,n){let r;return d(()=>{let o=t(this.state);Object.is(o,r)||(n(o,r),r=o)})}reactive(t){return A(()=>this.state[t])}produce(t){this.set((n=>{let r=x(n);return t(r),r}))}reconcile(t,n={}){this.set(t)}push(t,...n){let r=c(this.root,t);this.set(t,r.concat(n))}pop(t){let n=c(this.root,t).slice(),r=n.pop();return this.set(t,n),r}shift(t){let n=c(this.root,t).slice(),r=n.shift();return this.set(t,n),r}splice(t,n,r,...o){let s=c(this.root,t).slice(),i=s.splice(n,r,...o);return this.set(t,s),i}insert(t,n,r){let o=c(this.root,t).slice();o.splice(n,0,r),this.set(t,o)}removeAt(t,n){let r=c(this.root,t).slice(),o=r.splice(n,1);return this.set(t,r),o}toObservable(){let[t]=E(this.state);return t.toObservable()}dispose(){}},q=["get","select","watch","subscribe","produce","reconcile","push","pop","shift","splice","insert","removeAt","unwrap","toObservable"];function H(e,t){for(let n of q)e[n]=t[n].bind(t);e.$=t.reactive.bind(t)}function L(e,t={immutable:!0}){let n=new y(e,t);return H(n.set,n),[n.proxy,n.set]}function V(e,t={}){return new y(e,{...t,immutable:!1})}function Q(e,t={}){let n=new y(e(),t);return d(()=>n.set(e())),n}function Z(e,t,n){return d(()=>n(t(e)))}function k(e,t,n){return A(()=>t(e),void 0,n)}function tt(e,t={}){let n=new y(e,t),r=(()=>n.proxy);return H(r,n),r}function T(e){if(e==null||typeof e!="object")return e;let t=e[O];return t!==void 0?t:e}function Y(e){return C(()=>T(e))}function et(e){return z(e)}function nt(e){return z(e)?e[f]:null}function rt(e){return e&&typeof e=="object"&&f in e?e[f]:null}function z(e){return!!e&&typeof e=="object"&&(h in e||e.__proxy===!0)}function ot(e){return e}var st=Object.freeze({createStore:L,createMutableStore:V,batch:R,unwrap:T,untrackStore:Y});export{w as $HAS,G as $NAME,f as $NODE,O as $RAW,N as $SELF,J as $STORE,P as $TRACK,y as Store,st as StoreAPI,Q as createComputedStore,V as createMutableStore,L as createStore,Z as createStoreEffect,k as createStoreMemo,nt as getNode,rt as getStoreNode,et as isStore,z as isStoreProxy,ot as modifiable,Y as untrackStore,T as unwrap,tt as wrap};
+// src/lib/store/store.ts
+import {
+  $PROXY,
+  batch,
+  createEffect,
+  createMemo,
+  createSignal,
+  untrack
+} from "@fluixi/reactive/signal";
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.84";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function withReactiveOrigin(owner, fn) {
+  if (!G.observer) return fn();
+  const previous = origin;
+  origin = owner;
+  try {
+    return fn();
+  } finally {
+    origin = previous;
+  }
+}
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin } : report
+    );
+  }
+}
+function reportReactiveMove(node, origin2, name) {
+  G.observer?.moved?.(node, origin2, name);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+
+// src/lib/store/store.ts
+var $RAW = /* @__PURE__ */ Symbol("store-raw");
+var $NODE = /* @__PURE__ */ Symbol("store-node");
+var $HAS = /* @__PURE__ */ Symbol("store-has");
+var $SELF = /* @__PURE__ */ Symbol("store-self");
+var $TRACK = /* @__PURE__ */ Symbol("store-track");
+var $NAME = /* @__PURE__ */ Symbol("store-name");
+var $STORE = /* @__PURE__ */ Symbol("store-store");
+var NODES = /* @__PURE__ */ new WeakMap();
+var PROXIES = /* @__PURE__ */ new WeakMap();
+var OWNERS = /* @__PURE__ */ new WeakMap();
+var ROOTS = /* @__PURE__ */ new WeakMap();
+function forgetReplaced(dead, state) {
+  if (!isTrackable(dead) || !isObserved()) return;
+  const alive = /* @__PURE__ */ new Set();
+  const keep = (value) => {
+    if (!isTrackable(value) || alive.has(value)) return;
+    alive.add(value);
+    for (const child of Object.values(value)) keep(child);
+  };
+  keep(ROOTS.get(state) ?? state);
+  const seen = /* @__PURE__ */ new Set();
+  const drop = (value) => {
+    if (!isTrackable(value)) return;
+    const target = value;
+    if (alive.has(target) || seen.has(target)) return;
+    seen.add(target);
+    const ns = NODES.get(target);
+    if (ns) {
+      for (const node of ns.keys.values()) reportReactiveDispose(node);
+      if (ns.all) reportReactiveDispose(ns.all);
+      NODES.delete(target);
+      OWNERS.delete(target);
+      PROXIES.delete(target);
+    }
+    for (const child of Object.values(target)) drop(child);
+  };
+  drop(dead);
+}
+var pathOf = (base, key, array) => array ? `${base}[${String(key)}]` : `${base}.${String(key)}`;
+function createDataNode(initial, ns, key) {
+  const owner = ns?.owner;
+  const label = owner && key !== void 0 ? pathOf(owner.name, key, ns?.array) : void 0;
+  const [get, set] = withReactiveOrigin(
+    owner?.store,
+    () => createSignal(initial, label ? { name: label } : void 0)
+  );
+  const node = get;
+  node.$ = set;
+  return node;
+}
+function nodesOf(target) {
+  let ns = NODES.get(target);
+  if (!ns) NODES.set(target, ns = { keys: /* @__PURE__ */ new Map(), owner: OWNERS.get(target), array: Array.isArray(target) });
+  else if (!ns.owner) ns.owner = OWNERS.get(target);
+  return ns;
+}
+function keyNode(ns, key, seed) {
+  let node = ns.keys.get(key);
+  if (!node) ns.keys.set(key, node = createDataNode(seed, ns, key));
+  return node;
+}
+function claim2(target, holder, name, parent) {
+  const was = OWNERS.get(target);
+  if (was && was.store === holder && was.name === name) return;
+  const owner = { store: holder, name };
+  OWNERS.set(target, owner);
+  ROOTS.set(target, ROOTS.get(parent) ?? parent);
+  const ns = NODES.get(target);
+  if (!ns) return;
+  ns.owner = owner;
+  if (!isObserved()) return;
+  for (const [key, node] of ns.keys) reportReactiveMove(node, holder, pathOf(name, key, ns.array));
+  if (ns.all) reportReactiveMove(ns.all, holder, pathOf(name, "*", ns.array));
+}
+function trackKeys(target) {
+  const ns = nodesOf(target);
+  (ns.all || (ns.all = createDataNode(void 0, ns, "*")))();
+}
+function pokeNode(node, value) {
+  node.$(typeof value === "function" ? () => value : value);
+}
+function isTrackable(value) {
+  if (value == null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function box(value) {
+  if (!isTrackable(value)) return value;
+  const existing = PROXIES.get(value);
+  if (existing) return existing;
+  const proxy = new Proxy(value, handler);
+  PROXIES.set(value, proxy);
+  return proxy;
+}
+var handler = {
+  get(target, key, receiver) {
+    if (key === $RAW) return target;
+    if (key === $NODE) return target;
+    if (key === $PROXY) return receiver;
+    if (key === $HAS) return (k) => k in target;
+    if (key === "__proxy") return true;
+    if (key === $TRACK || key === $SELF) {
+      trackKeys(target);
+      return receiver;
+    }
+    const value = target[key];
+    if (typeof value === "function" && !Object.prototype.hasOwnProperty.call(target, key)) {
+      return value;
+    }
+    const desc = Object.getOwnPropertyDescriptor(target, key);
+    if (desc && desc.get) return desc.get.call(receiver);
+    const ns = nodesOf(target);
+    const holder = keyNode(ns, key, value);
+    const current = holder();
+    if (!isTrackable(current)) return current;
+    if (ns.owner) claim2(current, holder, pathOf(ns.owner.name, key, ns.array), target);
+    return box(current);
+  },
+  set() {
+    return true;
+  },
+  deleteProperty(target, key) {
+    if (key in target) writeKey(target, key, void 0);
+    return true;
+  },
+  has(target, key) {
+    if (key === $RAW || key === $PROXY || key === $NODE || key === $HAS || key === $SELF || key === $TRACK)
+      return true;
+    keyNode(nodesOf(target), key, target[key])();
+    return key in target;
+  },
+  ownKeys(target) {
+    trackKeys(target);
+    return Reflect.ownKeys(target);
+  },
+  getOwnPropertyDescriptor(target, key) {
+    return Reflect.getOwnPropertyDescriptor(target, key);
+  }
+};
+function rawValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value == null || typeof value !== "object") return value;
+  const raw = value[$RAW] ?? value;
+  if (seen.has(raw) || !isTrackable(raw)) return raw;
+  seen.add(raw);
+  let changed = false;
+  const swap = (v) => {
+    const next = rawValue(v, seen);
+    if (next !== v) changed = true;
+    return next;
+  };
+  if (Array.isArray(raw)) {
+    const out2 = raw.map(swap);
+    return changed ? out2 : raw;
+  }
+  const out = {};
+  for (const k of Object.keys(raw)) out[k] = swap(raw[k]);
+  return changed ? out : raw;
+}
+function writeKey(state, key, rawInput) {
+  const value = rawValue(rawInput);
+  const prev = state[key];
+  if (prev === value && (value !== void 0 || key in state)) return;
+  const isArray = Array.isArray(state);
+  const len = isArray ? state.length : 0;
+  if (value === void 0) delete state[key];
+  else state[key] = value;
+  const ns = nodesOf(state);
+  const node = ns.keys.get(key);
+  if (node) pokeNode(node, value);
+  forgetReplaced(prev, state);
+  if (isArray && state.length !== len) {
+    const lengthNode = ns.keys.get("length");
+    if (lengthNode) pokeNode(lengthNode, state.length);
+  }
+  if (ns.all) ns.all.$(void 0);
+}
+function nextValue(value, prev) {
+  return typeof value === "function" ? value(prev) : value;
+}
+function mergeInto(state, value) {
+  for (const key of Object.keys(value)) {
+    const next = value[key];
+    const prev = state[key];
+    if (next && typeof next === "object" && !Array.isArray(next) && prev && typeof prev === "object" && !Array.isArray(prev)) {
+      mergeInto(prev, next);
+    } else {
+      writeKey(state, key, next);
+    }
+  }
+}
+function parsePath(path) {
+  const out = [];
+  const normalized = path.replace(/\[([^\]]*)\]/g, ".$1");
+  for (const part of normalized.split(".")) if (part.length) out.push(part);
+  return out;
+}
+function applyAt(current, segs, value) {
+  const last = segs.length - 1;
+  for (let i = 0; i < last; i++) {
+    const seg = segs[i];
+    if (seg === "*") {
+      const rest = segs.slice(i + 1);
+      if (Array.isArray(current))
+        for (let idx = 0; idx < current.length; idx++)
+          applyAt(current[idx], rest, value);
+      return;
+    }
+    let next = current[seg];
+    if (next == null || typeof next !== "object") {
+      next = /^\d+$/.test(segs[i + 1]) ? [] : {};
+      writeKey(current, seg, next);
+    }
+    current = next;
+  }
+  const term = segs[last];
+  if (term === "*") {
+    if (Array.isArray(current))
+      for (let idx = 0; idx < current.length; idx++)
+        writeKey(current, idx, nextValue(value, current[idx]));
+    return;
+  }
+  writeKey(current, term, nextValue(value, current[term]));
+}
+function applyPath(root, path, value) {
+  applyAt(root, parsePath(path), value);
+}
+function isPathBatch(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((e) => Array.isArray(e) && e.length >= 2 && typeof e[0] === "string");
+}
+function replaceArray(target, next) {
+  for (let i = target.length - 1; i >= next.length; i--) writeKey(target, String(i), void 0);
+  if (target.length !== next.length) writeKey(target, "length", next.length);
+  for (let i = 0; i < next.length; i++) writeKey(target, String(i), next[i]);
+}
+function applySet(root, args) {
+  const first = args[0];
+  if (typeof first === "function" && args.length === 1) {
+    const next = first(root);
+    if (next && next !== root) mergeInto(root, next);
+    return;
+  }
+  if (Array.isArray(first) && args.length === 1) {
+    if (isPathBatch(first)) {
+      for (const entry of first) applyPath(root, entry[0], entry[1]);
+      return;
+    }
+    if (Array.isArray(root)) {
+      replaceArray(root, first);
+      return;
+    }
+    if (first.length === 0) return;
+    throw new TypeError(
+      "[fluixi] set() was given an array that is neither a batch of [path, value] pairs nor a replacement for an array root. Name the path you meant, as in set('items', [...])."
+    );
+  }
+  if (first && typeof first === "object" && !Array.isArray(first) && args.length === 1) {
+    mergeInto(root, first);
+    return;
+  }
+  if (Array.isArray(args[1]) && args.length >= 3) {
+    applyPath(root, `${first}.${args[1].join(".")}`, args[2]);
+    return;
+  }
+  applyPath(root, String(first), args[1]);
+}
+function clone(value) {
+  if (value == null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(clone);
+  const out = {};
+  for (const key of Object.keys(value)) out[key] = clone(value[key]);
+  return out;
+}
+function rawAt(root, path) {
+  let cur = root;
+  for (const seg of parsePath(path)) {
+    if (cur == null) return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+var Store = class {
+  constructor(initialState, options = { immutable: true }) {
+    this.options = options;
+    this.root = initialState;
+    this.set = ((...args) => batch(() => applySet(this.root, args)));
+    if (initialState && typeof initialState === "object") {
+      OWNERS.set(initialState, { store: this, name: options.name ?? "store" });
+      ROOTS.set(initialState, initialState);
+    }
+    reportReactiveNode({
+      kind: "store",
+      node: this,
+      handle: () => this.root,
+      name: options.name
+    });
+  }
+  get state() {
+    return box(this.root);
+  }
+  get proxy() {
+    return box(this.root);
+  }
+  get accessor() {
+    return (() => box(this.root));
+  }
+  unwrap() {
+    return this.root;
+  }
+  getNode(key) {
+    return this.root && this.root[key];
+  }
+  // Tracked read at a path. Empty path returns the whole (unwrapped) state.
+  get(path) {
+    if (path == null || path === "") return unwrap(this.state);
+    let cur = this.state;
+    for (const seg of parsePath(path)) {
+      if (cur == null) return void 0;
+      cur = cur[seg];
+    }
+    return unwrap(cur);
+  }
+  select(selector) {
+    return createMemo(() => selector(this.state));
+  }
+  subscribe(listener) {
+    return createEffect(() => listener(this.state));
+  }
+  watch(selector, effect) {
+    let prev;
+    return createEffect(() => {
+      const cur = selector(this.state);
+      if (!Object.is(cur, prev)) {
+        effect(cur, prev);
+        prev = cur;
+      }
+    });
+  }
+  // Reactive accessor for a top-level key.
+  reactive(key) {
+    return createMemo(() => this.state[key]);
+  }
+  produce(producer) {
+    this.set(((prev) => {
+      const draft = clone(prev);
+      producer(draft);
+      return draft;
+    }));
+  }
+  reconcile(value, _options = {}) {
+    this.set(value);
+  }
+  push(path, ...items) {
+    const arr = rawAt(this.root, path);
+    this.set(path, arr.concat(items));
+  }
+  pop(path) {
+    const arr = rawAt(this.root, path).slice();
+    const item = arr.pop();
+    this.set(path, arr);
+    return item;
+  }
+  shift(path) {
+    const arr = rawAt(this.root, path).slice();
+    const item = arr.shift();
+    this.set(path, arr);
+    return item;
+  }
+  splice(path, start, deleteCount, ...items) {
+    const arr = rawAt(this.root, path).slice();
+    const removed = arr.splice(start, deleteCount, ...items);
+    this.set(path, arr);
+    return removed;
+  }
+  insert(path, index, value) {
+    const arr = rawAt(this.root, path).slice();
+    arr.splice(index, 0, value);
+    this.set(path, arr);
+  }
+  removeAt(path, index) {
+    const arr = rawAt(this.root, path).slice();
+    const removed = arr.splice(index, 1);
+    this.set(path, arr);
+    return removed;
+  }
+  /**
+   * Swap a whole value, rather than merging into it.
+   *
+   * `set(partial)` merges per key, which is what you want for an object and never what
+   * you want for an array. This replaces: `replace(value)` at the root, or
+   * `replace(path, value)` further down.
+   *
+   * @example
+   * ```ts
+   * const [items, set] = createStore([1, 2, 3]);
+   * set.replace([]);            // now empty
+   * set.replace(['a', 'b']);    // now two entries
+   * ```
+   */
+  replace(pathOrValue, maybeValue) {
+    if (arguments.length >= 2) {
+      const target = rawAt(this.root, String(pathOrValue));
+      const next = maybeValue;
+      if (Array.isArray(target) && Array.isArray(next)) {
+        replaceArray(target, next);
+        return;
+      }
+      this.set(pathOrValue, next);
+      return;
+    }
+    const root = this.root;
+    if (Array.isArray(root) && Array.isArray(pathOrValue)) {
+      replaceArray(root, pathOrValue);
+      return;
+    }
+    this.set(pathOrValue);
+  }
+  /**
+   * Empty an array, at the root or at a path.
+   *
+   * @example
+   * ```ts
+   * set.clear();          // the root array
+   * set.clear('todos');   // a nested one
+   * ```
+   */
+  clear(path) {
+    const target = path === void 0 ? this.root : rawAt(this.root, path);
+    if (Array.isArray(target)) {
+      replaceArray(target, []);
+      return;
+    }
+    if (target && typeof target === "object") {
+      for (const key of Object.keys(target)) writeKey(target, key, void 0);
+    }
+  }
+  toObservable() {
+    const [get] = createSignal(this.state);
+    return get.toObservable();
+  }
+  dispose() {
+  }
+};
+var SETTER_METHODS = [
+  "get",
+  "select",
+  "watch",
+  "subscribe",
+  "produce",
+  "reconcile",
+  "push",
+  "pop",
+  "shift",
+  "splice",
+  "insert",
+  "removeAt",
+  "replace",
+  "clear",
+  "unwrap",
+  "toObservable"
+];
+function attachStoreMethods(target, store) {
+  for (const name of SETTER_METHODS) target[name] = store[name].bind(store);
+  target.$ = store.reactive.bind(store);
+}
+function createStore(initialState, options = { immutable: true }) {
+  const store = new Store(initialState, options);
+  attachStoreMethods(store.set, store);
+  return [store.proxy, store.set];
+}
+function createMutableStore(initialState, options = {}) {
+  return new Store(initialState, { ...options, immutable: false });
+}
+function createComputedStore(fn, options = {}) {
+  const store = new Store(fn(), options);
+  createEffect(() => store.set(fn()));
+  return store;
+}
+function createStoreEffect(state, selector, effect) {
+  return createEffect(() => effect(selector(state)));
+}
+function createStoreMemo(store, selector, options) {
+  return createMemo(() => selector(store), void 0, options);
+}
+function wrap(value, options = {}) {
+  const store = new Store(value, options);
+  const accessor = (() => store.proxy);
+  attachStoreMethods(accessor, store);
+  return accessor;
+}
+function unwrap(item) {
+  if (item == null || typeof item !== "object") return item;
+  const raw = item[$RAW];
+  return raw !== void 0 ? raw : item;
+}
+function untrackStore(store) {
+  return untrack(() => unwrap(store));
+}
+function isStore(store) {
+  return isStoreProxy(store);
+}
+function getNode(store) {
+  return isStoreProxy(store) ? store[$NODE] : null;
+}
+function getStoreNode(store) {
+  if (store && typeof store === "object" && $NODE in store)
+    return store[$NODE];
+  return null;
+}
+function isStoreProxy(value) {
+  return !!value && typeof value === "object" && ($PROXY in value || value.__proxy === true);
+}
+function modifiable(value) {
+  return value;
+}
+var StoreAPI = Object.freeze({
+  createStore,
+  createMutableStore,
+  batch,
+  unwrap,
+  untrackStore
+});
+export {
+  $HAS,
+  $NAME,
+  $NODE,
+  $RAW,
+  $SELF,
+  $STORE,
+  $TRACK,
+  Store,
+  StoreAPI,
+  createComputedStore,
+  createMutableStore,
+  createStore,
+  createStoreEffect,
+  createStoreMemo,
+  getNode,
+  getStoreNode,
+  isStore,
+  isStoreProxy,
+  modifiable,
+  untrackStore,
+  unwrap,
+  wrap
+};

package/dist/lib/store/types.cjs

@@ -1 +1,18 @@
-"use strict";var s=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var x=Object.prototype.hasOwnProperty;var a=(n,e,T,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of i(e))!x.call(n,t)&&t!==T&&s(n,t,{get:()=>e[t],enumerable:!(r=d(e,t))||r.enumerable});return n};var y=n=>a(s({},"__esModule",{value:!0}),n);var K={};module.exports=y(K);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/store/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/lib/store/types.d.ts

@@ -6,7 +6,7 @@ export interface ReconcileOptions {
 }
 export type Producer<T> = (draft: T) => void;
 export type Primitive = string | number | boolean | undefined | null | symbol | bigint;
-/** Convert a dot-path "a.b.0.c" → ["a","b",0,"c"] */
+/** Convert a dot-path "a.b.0.c" -> ["a","b",0,"c"] */
 export type SinglePath<T, Prev extends string = '', Depth extends number = 4> = Depth extends 0 ? never : T extends Primitive ? Prev : T extends Array<infer U> ? SinglePath<U, Prev, Decrement[Depth]> : {
     [K in keyof T]: SinglePath<T[K], Prev extends '' ? `${Extract<K, string>}` : `${Prev}.${Extract<K, string>}`, Decrement[Depth]>;
 }[keyof T];