storion 0.9.0 → 0.10.1

package/dist/react/index.js

@@ -1,11 +1,12 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { memo, useRef, useMemo, createElement, createContext, useContext, useReducer, useEffect, useLayoutEffect, useState, forwardRef } from "react";
-import { c as container, i as isSpec, S as STORION_TYPE, r as resolveEquality, s as store } from "../index-C8B6Mo8r.js";
-import { n, m, l, u, q, o, g, a, h, d, f, k, e, j, b, z, p, t, v, w, y, A, x } from "../index-C8B6Mo8r.js";
-import { P as ProviderMissingError, L as LocalStoreDependencyError, w as withHooks, A as AsyncFunctionError } from "../effect-C6h0PDDI.js";
-import { E, H, I, c, a as a2, d as d2, S, b as b2, e as e2, u as u2 } from "../effect-C6h0PDDI.js";
+import { memo, useRef, useMemo, createElement, createContext, useContext, useId, useReducer, useState, useEffect, useLayoutEffect, forwardRef } from "react";
+import { container } from "../storion.js";
+import { append, applyExcept, applyFor, clamp, decrement, divide, forStores, increment, list, map, merge, multiply, prepend, reset, resolver, toggle, trigger, withMeta } from "../storion.js";
+import { P as ProviderMissingError, w as withHooks, d as AsyncFunctionError, t as tryStabilize, h as strictEqual, j as ScopedOutsideSelectorError, s as storeTuple, i as isSpec, k as STORION_TYPE, l as resolveEquality, a as store } from "../effect-BDQU8Voz.js";
+import { E, H, I, L, z, S, y, x, n, v, e, o, m, p, B, q, u } from "../effect-BDQU8Voz.js";
+import { e as emitter } from "../emitter-j4rC71vY.js";
 import { jsx } from "react/jsx-runtime";
 import { m as m2 } from "../meta-40r-AZfe.js";
 const StoreContext = createContext(null);
@@ -35,185 +36,28 @@ function useContainer() {
   }
   return ctx;
 }
-function checkIsDev() {
-  if (typeof __DEV__ !== "undefined") {
-    return __DEV__;
-  }
-  try {
-    return process.env.NODE_ENV !== "production";
-  } catch {
-    return false;
-  }
-}
-function dev(fn) {
-  const isDev = checkIsDev();
-  if (fn) {
-    if (isDev) {
-      fn();
-    }
-    return isDev;
-  }
-  return isDev;
-}
-((dev2) => {
-  function log(message, ...args) {
-    if (checkIsDev()) {
-      console.log(`[rextive] ${message}`, ...args);
-    }
-  }
-  dev2.log = log;
-  function warn(message, ...args) {
-    if (checkIsDev()) {
-      console.warn(`[rextive] ${message}`, ...args);
-    }
-  }
-  dev2.warn = warn;
-  function error(message, ...args) {
-    if (checkIsDev()) {
-      console.error(`[rextive] ${message}`, ...args);
-    }
-  }
-  dev2.error = error;
-  function assert(condition, message) {
-    if (checkIsDev()) {
-      if (!condition) {
-        throw new Error(`[rextive] Assertion failed: ${message}`);
-      }
-    }
-  }
-  dev2.assert = assert;
-})(dev || (dev = {}));
-const isServer = typeof window === "undefined";
-const useIsomorphicLayoutEffect = isServer ? useEffect : useLayoutEffect;
-const shouldScheduleDispose = !isServer && typeof useLayoutEffect === "function" && dev();
-function useLocalStore(spec) {
-  var _a;
-  const [, forceUpdate] = useReducer((x2) => x2 + 1, 0);
-  const prevControllerRef = useRef(null);
-  const controller = useMemo(() => new LocalStoreController(spec), [spec]);
-  if (prevControllerRef.current !== controller) {
-    (_a = prevControllerRef.current) == null ? void 0 : _a.dispose();
-    prevControllerRef.current = controller;
-  }
-  const store2 = controller.getStore();
-  useIsomorphicLayoutEffect(() => {
-    controller.commit();
-    const unsubscribe = store2.subscribe(() => forceUpdate());
-    return () => {
-      unsubscribe();
-      controller.uncommit();
-    };
-  }, [controller, store2]);
-  return useMemo(
-    () => [
-      store2.state,
-      store2.actions,
-      { dirty: store2.dirty, reset: store2.reset }
-    ],
-    [store2]
-  );
-}
-class LocalStoreController {
-  constructor(spec) {
-    /** Whether the effect has committed (is active) */
-    __publicField(this, "_committed", false);
-    /** Whether this controller has been disposed */
-    __publicField(this, "_disposed", false);
-    /** Isolated container for this local store */
-    __publicField(this, "_container");
-    /** The store instance */
-    __publicField(this, "_store");
-    /**
-     * Dispose the controller and its store.
-     * Safe to call multiple times.
-     */
-    __publicField(this, "dispose", () => {
-      var _a, _b;
-      if (this._disposed) return;
-      this._disposed = true;
-      (_a = this._store) == null ? void 0 : _a.dispose();
-      (_b = this._container) == null ? void 0 : _b.clear();
-      this._store = void 0;
-      this._container = void 0;
-    });
-    /**
-     * Schedule disposal check via microtask.
-     *
-     * This deferred check is crucial for StrictMode:
-     * - StrictMode runs cleanup then effect again synchronously
-     * - The microtask runs AFTER the re-commit, so store survives
-     * - On real unmount, no re-commit happens, so disposal proceeds
-     */
-    __publicField(this, "_disposeIfUnused", () => {
-      if (this._committed || this._disposed) return;
-      if (shouldScheduleDispose) {
-        Promise.resolve().then(() => {
-          if (!this._committed) {
-            this.dispose();
-          }
-        });
-      } else {
-        this.dispose();
-      }
-    });
-    /**
-     * Get or create the store instance.
-     * Throws if the store has dependencies (local stores must be isolated).
-     */
-    __publicField(this, "getStore", () => {
-      var _a, _b;
-      if (this._store) return this._store;
-      if (!this._container) {
-        this._container = container();
-      }
-      this._store = this._container.get(this.spec);
-      const depsCount = ((_b = (_a = this._store) == null ? void 0 : _a.deps) == null ? void 0 : _b.length) ?? 0;
-      if (depsCount > 0) {
-        this.dispose();
-        throw new LocalStoreDependencyError(
-          this.spec.displayName,
-          depsCount
-        );
-      }
-      if (shouldScheduleDispose) {
-        this._disposeIfUnused();
-      }
-      return this._store;
-    });
-    /**
-     * Mark as committed (effect is active).
-     * Called at the start of useLayoutEffect.
-     */
-    __publicField(this, "commit", () => {
-      this._committed = true;
-    });
-    /**
-     * Mark as uncommitted (effect cleaned up).
-     * Schedules deferred disposal check.
-     */
-    __publicField(this, "uncommit", () => {
-      this._committed = false;
-      this._disposeIfUnused();
-    });
-    this.spec = spec;
-  }
-}
 function useStoreWithContainer(selector, container2) {
+  const id = useId();
   const [, forceUpdate] = useReducer((x2) => x2 + 1, 0);
   const [refs] = useState(() => ({
-    fresh: void 0,
-    stableFns: /* @__PURE__ */ new Map(),
+    prevValues: /* @__PURE__ */ new Map(),
     trackedDeps: /* @__PURE__ */ new Map(),
     subscriptions: /* @__PURE__ */ new Map(),
-    id: {},
+    id,
     onceRan: false
   }));
+  const [scopeController] = useState(
+    () => new ScopeController(container2)
+  );
+  const [selectorExecution] = useState(() => ({ active: false }));
+  const [scheduledEffects] = useState(() => []);
   refs.trackedDeps.clear();
   const shouldRunOnce = !refs.onceRan;
   const selectorContext = useMemo(() => {
     const ctx = {
       [STORION_TYPE]: "selector.context",
       id: refs.id,
+      container: container2,
       // Implementation handles both StoreSpec and Factory overloads
       get(specOrFactory) {
         if (!isSpec(specOrFactory)) {
@@ -226,10 +70,6 @@ function useStoreWithContainer(selector, container2) {
           actions: instance.actions
         });
       },
-      // Create a fresh instance from a parameterized factory (bypasses cache)
-      create(factory, ...args) {
-        return container2.create(factory, ...args);
-      },
       mixin(mixin, ...args) {
         return mixin(ctx, ...args);
       },
@@ -237,42 +77,65 @@ function useStoreWithContainer(selector, container2) {
         if (shouldRunOnce) {
           callback();
         }
+      },
+      scoped(spec) {
+        if (!selectorExecution.active) {
+          throw new ScopedOutsideSelectorError();
+        }
+        const instance = scopeController.get(spec);
+        return storeTuple(instance);
       }
     };
     return ctx;
-  }, [container2, shouldRunOnce]);
-  const result = withHooks(
-    {
-      onRead: (event) => {
-        refs.trackedDeps.set(event.key, event);
+  }, [container2, shouldRunOnce, scopeController]);
+  let output;
+  selectorExecution.active = true;
+  try {
+    output = withHooks(
+      {
+        onRead: (event) => {
+          refs.trackedDeps.set(event.key, event);
+        },
+        // Collect effects to run in useEffect (not immediately)
+        // This enables effect() calls in selector to access component scope
+        scheduleEffect: (runEffect) => {
+          scheduledEffects.push(runEffect);
+        }
+      },
+      () => {
+        const result = selector(selectorContext);
+        if (result && typeof result.then === "function") {
+          throw new AsyncFunctionError(
+            "useStore selector",
+            "Do not return a Promise from the selector function."
+          );
+        }
+        const out = Array.isArray(result) ? [] : {};
+        for (const [key, value] of Object.entries(result)) {
+          const prev = refs.prevValues.get(key);
+          const [stableValue] = tryStabilize(prev, value, strictEqual);
+          out[key] = stableValue;
+          if (prev) {
+            prev.value = stableValue;
+          } else {
+            refs.prevValues.set(key, { value: stableValue });
+          }
+        }
+        return out;
       }
-    },
-    () => selector(selectorContext)
-  );
-  if (shouldRunOnce) {
-    refs.onceRan = true;
-  }
-  if (result && typeof result.then === "function") {
-    throw new AsyncFunctionError(
-      "useStore selector",
-      "Do not return a Promise from the selector function."
     );
+  } finally {
+    selectorExecution.active = false;
   }
-  refs.fresh = result;
-  const output = Array.isArray(result) ? [] : {};
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "function") {
-      if (!refs.stableFns.has(key)) {
-        refs.stableFns.set(key, (...args) => {
-          var _a, _b;
-          return (_b = (_a = refs.fresh) == null ? void 0 : _a[key]) == null ? void 0 : _b.call(_a, ...args);
-        });
-      }
-      output[key] = refs.stableFns.get(key);
-    } else {
-      output[key] = value;
-    }
+  if (shouldRunOnce) {
+    refs.onceRan = true;
   }
+  useIsomorphicLayoutEffect(() => {
+    scopeController.commit();
+    return () => {
+      scopeController.uncommit();
+    };
+  }, [scopeController]);
   const trackedKeysToken = [...refs.trackedDeps.keys()].sort().join("|");
   useEffect(() => {
     var _a;
@@ -297,15 +160,107 @@ function useStoreWithContainer(selector, container2) {
       refs.subscriptions.clear();
     };
   }, [trackedKeysToken]);
+  useEffect(() => {
+    const disposers = emitter();
+    try {
+      for (const runEffect of scheduledEffects) {
+        disposers.on(runEffect());
+      }
+    } catch (ex) {
+      disposers.emitAndClear();
+      throw ex;
+    }
+    return () => {
+      disposers.emitAndClear();
+    };
+  });
   return output;
 }
-function useStore(selectorOrSpec) {
-  const isSpec2 = typeof selectorOrSpec === "object" && selectorOrSpec !== null && "options" in selectorOrSpec;
-  if (isSpec2) {
-    return useLocalStore(selectorOrSpec);
-  }
+function useStore(selector) {
   const container2 = useContainer();
-  return useStoreWithContainer(selectorOrSpec, container2);
+  return useStoreWithContainer(selector, container2);
+}
+const isServer = typeof window === "undefined";
+const useIsomorphicLayoutEffect = isServer ? useEffect : useLayoutEffect;
+const shouldScheduleDispose = !isServer && typeof useLayoutEffect === "function";
+class ScopeController {
+  constructor(container2) {
+    /** Whether the effect has committed (is active) */
+    __publicField(this, "_committed", false);
+    /** Whether this controller has been disposed */
+    __publicField(this, "_disposed", false);
+    /** Whether a disposal check microtask is pending */
+    __publicField(this, "_pendingDisposalCheck", false);
+    __publicField(this, "_stores", /* @__PURE__ */ new Map());
+    /**
+     * Dispose the controller and its store.
+     * Safe to call multiple times.
+     */
+    __publicField(this, "dispose", () => {
+      if (this._disposed) return;
+      this._disposed = true;
+      for (const store2 of this._stores.values()) {
+        store2.dispose();
+      }
+      this._stores.clear();
+    });
+    /**
+     * Schedule disposal check via microtask.
+     *
+     * This deferred check is crucial for StrictMode:
+     * - StrictMode runs cleanup then effect again synchronously
+     * - The microtask runs AFTER the re-commit, so store survives
+     * - On real unmount, no re-commit happens, so disposal proceeds
+     */
+    __publicField(this, "_disposeIfUnused", () => {
+      if (this._committed || this._disposed || this._pendingDisposalCheck) return;
+      if (shouldScheduleDispose) {
+        this._pendingDisposalCheck = true;
+        Promise.resolve().then(() => {
+          this._pendingDisposalCheck = false;
+          if (!this._committed) {
+            this.dispose();
+          }
+        });
+      } else {
+        this.dispose();
+      }
+    });
+    /**
+     * Get or create the store instance.
+     */
+    __publicField(this, "get", (spec) => {
+      if (this._disposed) {
+        throw new Error("ScopeController has been disposed");
+      }
+      let store2 = this._stores.get(spec);
+      if (!store2) {
+        store2 = this.container.create(spec);
+        this._stores.set(spec, store2);
+      }
+      if (shouldScheduleDispose && !this._committed) {
+        this._disposeIfUnused();
+      }
+      return store2;
+    });
+    /**
+     * Mark as committed (effect is active).
+     * Called at the start of useLayoutEffect.
+     */
+    __publicField(this, "commit", () => {
+      this._committed = true;
+      this._pendingDisposalCheck = false;
+    });
+    /**
+     * Mark as uncommitted (effect cleaned up).
+     * Schedules deferred disposal check.
+     */
+    __publicField(this, "uncommit", () => {
+      this._committed = false;
+      this._disposeIfUnused();
+    });
+    this.container = container2;
+  }
 }
 function createWithStore(useContextHook) {
   return function boundWithStore2(hook, renderOrOptions, maybeOptions) {
@@ -380,7 +335,9 @@ function createWithStore(useContextHook) {
     return hoc;
   };
 }
-const boundWithStore = createWithStore(useStore);
+const boundWithStore = createWithStore(
+  useStore
+);
 function withStore(hook, renderOrOptions, maybeOptions) {
   return boundWithStore(hook, renderOrOptions, maybeOptions);
 }
@@ -403,52 +360,96 @@ function create(storeOptions, containerOptions) {
   const withStore2 = createWithStore(useCreatedStoreContext);
   return [instance, useCreatedStore, withStore2];
 }
+function stable(Component, customEquality) {
+  const isForwardRefComponent = Component.$$typeof === Symbol.for("react.forward_ref");
+  const expectsRef = isForwardRefComponent || typeof Component === "function" && Component.length >= 2;
+  const StableComponent = forwardRef((props, ref) => {
+    const inputProps = props;
+    const [refs] = useState(() => ({
+      prevValues: /* @__PURE__ */ new Map(),
+      equalityFns: /* @__PURE__ */ new Map()
+    }));
+    const stableProps = {};
+    for (const key of Object.keys(inputProps)) {
+      const keyStr = key;
+      const value = inputProps[key];
+      if (!refs.equalityFns.has(keyStr)) {
+        const equalityConfig = customEquality == null ? void 0 : customEquality[key];
+        refs.equalityFns.set(keyStr, resolveEquality(equalityConfig));
+      }
+      const equalityFn = refs.equalityFns.get(keyStr);
+      const prev = refs.prevValues.get(keyStr);
+      const [stableValue] = tryStabilize(prev, value, equalityFn);
+      stableProps[key] = stableValue;
+      if (prev) {
+        prev.value = stableValue;
+      } else {
+        refs.prevValues.set(keyStr, { value: stableValue });
+      }
+    }
+    if (isForwardRefComponent) {
+      return /* @__PURE__ */ jsx(Component, { ...stableProps, ref });
+    }
+    if (expectsRef) {
+      return Component(
+        stableProps,
+        ref
+      );
+    }
+    const Comp = Component;
+    return /* @__PURE__ */ jsx(Comp, { ...stableProps });
+  });
+  const componentName = Component.displayName || Component.name || "Component";
+  StableComponent.displayName = `Stable(${componentName})`;
+  return StableComponent;
+}
 export {
   AsyncFunctionError,
   E as EffectRefreshError,
   H as HooksContextError,
   I as InvalidActionError,
-  c as LifetimeMismatchError,
-  LocalStoreDependencyError,
+  L as LifetimeMismatchError,
+  z as LocalStoreDependencyError,
   ProviderMissingError,
   STORION_TYPE,
-  a2 as SetupPhaseError,
-  d2 as StoreDisposedError,
+  S as SetupPhaseError,
+  y as StoreDisposedError,
   StoreProvider,
-  S as StorionError,
-  n as applyExcept,
-  m as applyFor,
-  b2 as batch,
+  x as StorionError,
+  append,
+  applyExcept,
+  applyFor,
+  n as batch,
+  clamp,
   container,
   create,
-  l as createResolver,
-  createWithStore,
-  u as deepEqual,
-  e2 as effect,
-  q as equality,
-  o as forStores,
-  g as getKind,
-  a as is,
-  h as isAction,
-  d as isContainer,
-  f as isFocus,
-  k as isSelectorContext,
-  isSpec,
-  e as isStore,
-  j as isStoreContext,
-  b as isStorion,
-  z as isWrappedFn,
+  decrement,
+  v as deepEqual,
+  divide,
+  e as effect,
+  o as equality,
+  forStores,
+  increment,
+  m as is,
+  list,
+  map,
+  merge,
   m2 as meta,
+  multiply,
   p as pick,
-  t as shallowEqual,
+  B as pool,
+  prepend,
+  reset,
+  resolver,
+  q as shallowEqual,
+  stable,
   store,
-  v as strictEqual,
-  w as trigger,
-  u2 as untrack,
-  y as unwrapFn,
+  strictEqual,
+  toggle,
+  trigger,
+  u as untrack,
   useContainer,
   useStore,
-  A as withMeta,
-  withStore,
-  x as wrapFn
+  withMeta,
+  withStore
 };

package/dist/react/stable.d.ts

@@ -0,0 +1,27 @@
+import { ComponentType, ForwardRefExoticComponent, RefAttributes, ForwardRefRenderFunction } from 'react';
+import { Equality } from '../types';
+
+/**
+ * Configuration for per-prop equality checking.
+ *
+ * @example
+ * ```tsx
+ * stable(Component, {
+ *   data: "shallow",           // Use shallow equality
+ *   items: "deep",             // Use deep equality
+ *   config: (a, b) => a.id === b.id,  // Custom equality
+ * })
+ * ```
+ */
+export type PropEqualityConfig<TProps extends object> = {
+    [K in keyof TProps]?: Equality<TProps[K]>;
+};
+/**
+ * Wrap a component with automatic prop stabilization.
+ *
+ * @param Component - The component to wrap (function component, forwardRef, or render function)
+ * @param customEquality - Optional per-prop equality configuration
+ * @returns A forwardRef component with stabilized props
+ */
+export declare function stable<TProps extends object, TRef = unknown>(Component: ComponentType<TProps> | ForwardRefRenderFunction<TRef, TProps>, customEquality?: PropEqualityConfig<NoInfer<TProps>>): ForwardRefExoticComponent<TProps & RefAttributes<TRef>>;
+//# sourceMappingURL=stable.d.ts.map

package/dist/react/stable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stable.d.ts","sourceRoot":"","sources":["../../src/react/stable.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AAEH,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,yBAAyB,EAC9B,KAAK,aAAa,EAClB,KAAK,wBAAwB,EAE9B,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAOzC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,CAAC,MAAM,SAAS,MAAM,IAAI;KACrD,CAAC,IAAI,MAAM,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC1C,CAAC;AAiBF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,MAAM,EAAE,IAAI,GAAG,OAAO,EAC1D,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,wBAAwB,CAAC,IAAI,EAAE,MAAM,CAAC,EACzE,cAAc,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GACnD,yBAAyB,CAAC,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,CA+EzD"}

package/dist/react/useStore.d.ts

@@ -1,5 +1,4 @@
-import { StateBase, ActionsBase, StoreSpec, StoreContainer, Selector, StableResult } from '../types';
-import { LocalStoreResult } from './useLocalStore';
+import { StoreContainer, Selector, StableResult } from '../types';
 
 /**
  * Core hook implementation that accepts container as parameter.
@@ -9,24 +8,50 @@ export declare function useStoreWithContainer<T extends object>(selector: Select
 /**
  * React hook to consume stores with automatic optimization.
  *
- * @overload With selector - Uses the container from React context (StoreProvider).
- * Access multiple stores, compute derived values, with fine-grained re-renders.
+ * Features:
+ * - Multi-store access via `get()` for global stores
+ * - Component-local stores via `scoped()` (auto-disposed on unmount)
+ * - Component-scoped effects via `effect()` with access to external values
+ * - Auto-stable functions (never cause re-renders)
+ * - Fine-grained updates (only re-renders when selected values change)
  *
- * @overload With spec - Creates a component-local store instance (like useLocalStore).
- * The store is isolated, disposed on unmount, and cannot have dependencies.
- *
- * @example
+ * @example Basic usage
  * ```tsx
- * // With selector - access global stores
  * const { count, increment } = useStore(({ get }) => {
- *   const [state, actions] = get(counterSpec);
+ *   const [state, actions] = get(counterStore);
  *   return { count: state.count, increment: actions.increment };
  * });
+ * ```
+ *
+ * @example Component-local stores
+ * ```tsx
+ * const { form } = useStore(({ scoped }) => {
+ *   const [formState, formActions] = scoped(formStore);
+ *   return { form: { ...formState, ...formActions } };
+ * });
+ * ```
+ *
+ * @example Effects with access to external values (refs, props, hooks)
+ * ```tsx
+ * function SearchPage() {
+ *   const inputRef = useRef<HTMLInputElement>(null);
+ *   const location = useLocation();
+ *
+ *   const { query } = useStore(({ get }) => {
+ *     const [state] = get(searchStore);
+ *
+ *     // Effect runs in useEffect - has access to refs, props, and hooks
+ *     // Auto-tracks store state, re-runs when tracked values change
+ *     effect(() => {
+ *       if (location.pathname === '/search' && state.isReady) {
+ *         inputRef.current?.focus();
+ *       }
+ *     });
  *
- * // With spec - local store (shorthand for useLocalStore)
- * const [state, actions, { dirty, reset }] = useStore(formSpec);
+ *     return { query: state.query };
+ *   });
+ * }
  * ```
  */
 export declare function useStore<T extends object>(selector: Selector<T>): StableResult<T>;
-export declare function useStore<TState extends StateBase, TActions extends ActionsBase>(spec: StoreSpec<TState, TActions>): LocalStoreResult<TState, TActions>;
 //# sourceMappingURL=useStore.d.ts.map

package/dist/react/useStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStore.d.ts","sourceRoot":"","sources":["../../src/react/useStore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,cAAc,EAEnB,KAAK,QAAQ,EACb,KAAK,YAAY,EAClB,MAAM,UAAU,CAAC;AAIlB,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAuBvE;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,EACpD,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,cAAc,GACxB,YAAY,CAAC,CAAC,CAAC,CAmJjB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACpB,YAAY,CAAC,CAAC,CAAC,CAAC;AACnB,wBAAgB,QAAQ,CACtB,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,EAC5B,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,gBAAgB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC"}
+{"version":3,"file":"useStore.d.ts","sourceRoot":"","sources":["../../src/react/useStore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH,OAAO,EAKL,KAAK,cAAc,EAEnB,KAAK,QAAQ,EACb,KAAK,YAAY,EAElB,MAAM,UAAU,CAAC;AA6BlB;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,EACpD,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,cAAc,GACxB,YAAY,CAAC,CAAC,CAAC,CAyNjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACpB,YAAY,CAAC,CAAC,CAAC,CAKjB"}