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

package/dist/lib/store/store.cjs

@@ -1 +1,658 @@
-"use strict";var h=Object.defineProperty;var C=Object.getOwnPropertyDescriptor;var F=Object.getOwnPropertyNames;var X=Object.prototype.hasOwnProperty;var q=(e,t)=>{for(var n in t)h(e,n,{get:t[n],enumerable:!0})},L=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of F(t))!X.call(e,o)&&o!==n&&h(e,o,{get:()=>t[o],enumerable:!(r=C(t,o))||r.enumerable});return e};var V=e=>L(h({},"__esModule",{value:!0}),e);var at={};q(at,{$HAS:()=>O,$NAME:()=>Y,$NODE:()=>f,$RAW:()=>T,$SELF:()=>g,$STORE:()=>B,$TRACK:()=>x,Store:()=>y,StoreAPI:()=>it,createComputedStore:()=>Z,createMutableStore:()=>H,createStore:()=>W,createStoreEffect:()=>k,createStoreMemo:()=>tt,getNode:()=>rt,getStoreNode:()=>ot,isStore:()=>nt,isStoreProxy:()=>P,modifiable:()=>st,untrackStore:()=>z,unwrap:()=>p,wrap:()=>et});module.exports=V(at);var s=require("@fluixi/reactive/signal"),T=Symbol("store-raw"),f=Symbol("store-node"),O=Symbol("store-has"),g=Symbol("store-self"),x=Symbol("store-track"),Y=Symbol("store-name"),B=Symbol("store-store"),U=new WeakMap,v=new WeakMap;function R(e){let[t,n]=(0,s.createSignal)(e),r=t;return r.$=n,r}function m(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=R(n)),r}function $(e){let t=m(e);(t.all||(t.all=R()))()}function D(e,t){e.$(typeof t=="function"?()=>t:t)}function E(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 b(e){if(!E(e))return e;let t=v.get(e);if(t)return t;let n=new Proxy(e,G);return v.set(e,n),n}var G={get(e,t,n){if(t===T||t===f)return e;if(t===s.$PROXY)return n;if(t===O)return a=>a in e;if(t==="__proxy")return!0;if(t===x||t===g)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 i=I(m(e),t,r)();return E(i)?b(i):i},set(){return!0},deleteProperty(e,t){return t in e&&l(e,t,void 0),!0},has(e,t){return t===T||t===s.$PROXY||t===f||t===O||t===g||t===x?!0:(I(m(e),t,e[t])(),t in e)},ownKeys(e){return $(e),Reflect.ownKeys(e)},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e,t)}};function l(e,t,n){if(e[t]===n&&(n!==void 0||t in e))return;let o=Array.isArray(e),i=o?e.length:0;n===void 0?delete e[t]:e[t]=n;let a=m(e),c=a.keys.get(t);if(c&&D(c,n),o&&e.length!==i){let d=a.keys.get("length");d&&D(d,e.length)}a.all&&a.all.$(void 0)}function M(e,t){return typeof e=="function"?e(t):e}function j(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)?j(o,r):l(e,n,r)}}function N(e){let t=[],n=e.replace(/\[([^\]]*)\]/g,".$1");for(let r of n.split("."))r.length&&t.push(r);return t}function K(e,t,n){let r=t.length-1;for(let i=0;i<r;i++){let a=t[i];if(a==="*"){let d=t.slice(i+1);if(Array.isArray(e))for(let S=0;S<e.length;S++)K(e[S],d,n);return}let c=e[a];(c==null||typeof c!="object")&&(c=/^\d+$/.test(t[i+1])?[]:{},l(e,a,c)),e=c}let o=t[r];if(o==="*"){if(Array.isArray(e))for(let i=0;i<e.length;i++)l(e,i,M(n,e[i]));return}l(e,o,M(n,e[o]))}function A(e,t,n){K(e,N(t),n)}function J(e,t){let n=t[0];if(typeof n=="function"&&t.length===1){let r=n(e);r&&r!==e&&j(e,r);return}if(Array.isArray(n)&&t.length===1){for(let r of n)Array.isArray(r)&&A(e,r[0],r[1]);return}if(n&&typeof n=="object"&&!Array.isArray(n)&&t.length===1){j(e,n);return}if(Array.isArray(t[1])&&t.length>=3){A(e,`${n}.${t[1].join(".")}`,t[2]);return}A(e,String(n),t[1])}function w(e){if(e==null||typeof e!="object")return e;if(Array.isArray(e))return e.map(w);let t={};for(let n of Object.keys(e))t[n]=w(e[n]);return t}function u(e,t){let n=e;for(let r of N(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)=>(0,s.batch)(()=>J(this.root,r)))}get state(){return b(this.root)}get proxy(){return b(this.root)}get accessor(){return(()=>b(this.root))}unwrap(){return this.root}getNode(t){return this.root&&this.root[t]}get(t){if(t==null||t==="")return p(this.state);let n=this.state;for(let r of N(t)){if(n==null)return;n=n[r]}return p(n)}select(t){return(0,s.createMemo)(()=>t(this.state))}subscribe(t){return(0,s.createEffect)(()=>t(this.state))}watch(t,n){let r;return(0,s.createEffect)(()=>{let o=t(this.state);Object.is(o,r)||(n(o,r),r=o)})}reactive(t){return(0,s.createMemo)(()=>this.state[t])}produce(t){this.set((n=>{let r=w(n);return t(r),r}))}reconcile(t,n={}){this.set(t)}push(t,...n){let r=u(this.root,t);this.set(t,r.concat(n))}pop(t){let n=u(this.root,t).slice(),r=n.pop();return this.set(t,n),r}shift(t){let n=u(this.root,t).slice(),r=n.shift();return this.set(t,n),r}splice(t,n,r,...o){let i=u(this.root,t).slice(),a=i.splice(n,r,...o);return this.set(t,i),a}insert(t,n,r){let o=u(this.root,t).slice();o.splice(n,0,r),this.set(t,o)}removeAt(t,n){let r=u(this.root,t).slice(),o=r.splice(n,1);return this.set(t,r),o}toObservable(){let[t]=(0,s.createSignal)(this.state);return t.toObservable()}dispose(){}},Q=["get","select","watch","subscribe","produce","reconcile","push","pop","shift","splice","insert","removeAt","unwrap","toObservable"];function _(e,t){for(let n of Q)e[n]=t[n].bind(t);e.$=t.reactive.bind(t)}function W(e,t={immutable:!0}){let n=new y(e,t);return _(n.set,n),[n.proxy,n.set]}function H(e,t={}){return new y(e,{...t,immutable:!1})}function Z(e,t={}){let n=new y(e(),t);return(0,s.createEffect)(()=>n.set(e())),n}function k(e,t,n){return(0,s.createEffect)(()=>n(t(e)))}function tt(e,t,n){return(0,s.createMemo)(()=>t(e),void 0,n)}function et(e,t={}){let n=new y(e,t),r=(()=>n.proxy);return _(r,n),r}function p(e){if(e==null||typeof e!="object")return e;let t=e[T];return t!==void 0?t:e}function z(e){return(0,s.untrack)(()=>p(e))}function nt(e){return P(e)}function rt(e){return P(e)?e[f]:null}function ot(e){return e&&typeof e=="object"&&f in e?e[f]:null}function P(e){return!!e&&typeof e=="object"&&(s.$PROXY in e||e.__proxy===!0)}function st(e){return e}var it=Object.freeze({createStore:W,createMutableStore:H,batch:s.batch,unwrap:p,untrackStore:z});
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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/store.ts
+var store_exports = {};
+__export(store_exports, {
+  $HAS: () => $HAS,
+  $NAME: () => $NAME,
+  $NODE: () => $NODE,
+  $RAW: () => $RAW,
+  $SELF: () => $SELF,
+  $STORE: () => $STORE,
+  $TRACK: () => $TRACK,
+  Store: () => Store,
+  StoreAPI: () => StoreAPI,
+  createComputedStore: () => createComputedStore,
+  createMutableStore: () => createMutableStore,
+  createStore: () => createStore,
+  createStoreEffect: () => createStoreEffect,
+  createStoreMemo: () => createStoreMemo,
+  getNode: () => getNode,
+  getStoreNode: () => getStoreNode,
+  isStore: () => isStore,
+  isStoreProxy: () => isStoreProxy,
+  modifiable: () => modifiable,
+  untrackStore: () => untrackStore,
+  unwrap: () => unwrap,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(store_exports);
+var import_signal = require("@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,
+    () => (0, import_signal.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 === import_signal.$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 === import_signal.$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) => (0, import_signal.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 (0, import_signal.createMemo)(() => selector(this.state));
+  }
+  subscribe(listener) {
+    return (0, import_signal.createEffect)(() => listener(this.state));
+  }
+  watch(selector, effect) {
+    let prev;
+    return (0, import_signal.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 (0, import_signal.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] = (0, import_signal.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);
+  (0, import_signal.createEffect)(() => store.set(fn()));
+  return store;
+}
+function createStoreEffect(state, selector, effect) {
+  return (0, import_signal.createEffect)(() => effect(selector(state)));
+}
+function createStoreMemo(store, selector, options) {
+  return (0, import_signal.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 (0, import_signal.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" && (import_signal.$PROXY in value || value.__proxy === true);
+}
+function modifiable(value) {
+  return value;
+}
+var StoreAPI = Object.freeze({
+  createStore,
+  createMutableStore,
+  batch: import_signal.batch,
+  unwrap,
+  untrackStore
+});