storion 0.10.2 → 0.11.0

package/dist/core/map.d.ts

@@ -0,0 +1,153 @@
+import { Focus, PickEquality } from '../types';
+import { FocusAutoDispose } from './disposalGroup';
+
+/**
+ * Options for the map helper.
+ */
+export interface MapOptions<T> {
+    /**
+     * Auto-dispose values when removed.
+     *
+     * - `false` / `undefined`: No auto-disposal (default)
+     * - `true`: Dispose immediately via microtask
+     * - `number`: Grace period in ms (e.g., `100` = 100ms delay)
+     * - `string`: Named disposal group (shared across collections)
+     * - `DisposalGroup`: Direct group instance
+     * - `{ group, gracePeriodMs }`: Full options
+     *
+     * @example
+     * ```ts
+     * // Simple auto-dispose
+     * map({ autoDispose: true })
+     *
+     * // With 100ms grace period
+     * map({ autoDispose: 100 })
+     *
+     * // Named group - values moving between maps with same group name won't be disposed
+     * map({ autoDispose: "cache" })
+     *
+     * // Named group with grace period
+     * map({ autoDispose: { group: "cache", gracePeriodMs: 100 } })
+     *
+     * // Direct group instance
+     * const group = disposalGroup();
+     * map({ autoDispose: group })
+     * ```
+     */
+    autoDispose?: FocusAutoDispose;
+    /**
+     * Called when value is added to the map.
+     */
+    onAdded?: (value: T, key: string) => void;
+    /**
+     * Called when value is removed from the map.
+     */
+    onRemoved?: (value: T, key: string) => void;
+}
+/**
+ * Map API returned by the map() helper.
+ */
+export interface FocusMap<T> {
+    /** Get the current record (returns empty object if undefined/null) */
+    get(): Record<string, T>;
+    /** Get value by key */
+    at(key: string): T | undefined;
+    /** Get number of entries */
+    size(): number;
+    /** Check if record is empty */
+    isEmpty(): boolean;
+    /** Check if key exists */
+    has(key: string): boolean;
+    /**
+     * Set value at key (auto-disposes old value if enabled).
+     * Accepts direct value, reducer, or immer-style updater.
+     *
+     * @example
+     * cache.set('count', 10);                    // Direct value
+     * cache.set('count', prev => prev + 1);      // Reducer (returns new value)
+     * cache.set('user', draft => { draft.age++ }); // Updater (mutates draft)
+     */
+    set(key: string, valueOrReducerOrUpdater: T | ((prev: T) => T | void)): void;
+    /**
+     * Get value at key, or create it if it doesn't exist.
+     *
+     * @example
+     * const user = users.tryGet('user-123', () => ({ id: 'user-123', name: 'New' }));
+     */
+    tryGet(key: string, create: () => T): T;
+    /**
+     * Swap values at two keys.
+     *
+     * @example
+     * cache.swap('a', 'b'); // Swap values at keys 'a' and 'b'
+     */
+    swap(keyA: string, keyB: string): void;
+    /** Delete key(s) (auto-disposes values if enabled) */
+    delete(...keys: string[]): number;
+    /** Delete keys matching predicate (auto-disposes values if enabled) */
+    deleteWhere(predicate: (value: T, key: string) => boolean): number;
+    /** Clear all entries (auto-disposes all values if enabled) */
+    clear(): void;
+    /** Replace entire record (auto-disposes old values if enabled) */
+    replace(record: Record<string, T>): void;
+    /** Get all keys */
+    keys(): string[];
+    /** Get all values */
+    values(): T[];
+    /** Get all entries */
+    entries(): [string, T][];
+    /** Create a pick selector for fine-grained reactivity */
+    pick(equality?: PickEquality<Record<string, T> | undefined | null>): Record<string, T>;
+}
+/**
+ * Create a map helper for object/record focus.
+ * Handles undefined/null records gracefully.
+ *
+ * @example
+ * ```ts
+ * const cacheStore = store({
+ *   name: 'cache',
+ *   state: { users: {} as Record<string, User> },
+ *   setup({ focus }) {
+ *     const users = focus('users').as(map());
+ *     return {
+ *       setUser: (id: string, user: User) => users.set(id, user),
+ *       getUser: (id: string) => users.at(id),
+ *       removeUser: (id: string) => users.delete(id),
+ *       hasUser: (id: string) => users.has(id),
+ *       clearUsers: () => users.clear(),
+ *     };
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With named disposal group for cross-collection moves
+ * const cacheStore = store({
+ *   name: 'cache',
+ *   state: {
+ *     active: {} as Record<string, Session>,
+ *     archived: {} as Record<string, Session>,
+ *   },
+ *   setup({ focus }) {
+ *     // Same group name = values moving between won't be disposed
+ *     const active = focus('active').as(map({ autoDispose: "sessions" }));
+ *     const archived = focus('archived').as(map({ autoDispose: "sessions" }));
+ *
+ *     return {
+ *       archiveSession: (id: string) => {
+ *         const session = active.at(id);
+ *         if (session) {
+ *           active.delete(id);         // Schedules disposal
+ *           archived.set(id, session); // Cancels disposal - same group!
+ *         }
+ *       },
+ *     };
+ *   },
+ * });
+ * ```
+ */
+export declare function map<T>(options?: MapOptions<T>): (focus: Focus<Record<string, T> | undefined | null> | Focus<Record<string, T> | undefined> | Focus<Record<string, T> | null> | Focus<Record<string, T>>) => FocusMap<T>;
+export { disposalGroup, getNamedGroup, type DisposalGroup, type FocusAutoDispose, type FocusAutoDisposeOptions, } from './disposalGroup';
+//# sourceMappingURL=map.d.ts.map

package/dist/core/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/core/map.ts"],"names":[],"mappings":"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"}

package/dist/dev.d.ts

@@ -1,47 +1,52 @@
 /**
  * Development-only utilities.
  *
- * These use the __DEV__ flag which should be defined by the consuming application's bundler.
+ * Uses `process.env.NODE_ENV` which bundlers (Vite, Webpack, Rollup) replace at build time.
+ * In production builds, all code inside `if (process.env.NODE_ENV !== 'production')` blocks
+ * is completely removed via dead code elimination.
+ *
+ * **How it works:**
+ * 1. Bundler replaces `process.env.NODE_ENV` with `"production"` or `"development"`
+ * 2. Condition becomes `if ("production" !== 'production')` → `if (false)`
+ * 3. Minifier removes the entire dead code block
  *
- * **For consuming applications:**
- * Add this to your Vite config:
+ * @example
  * ```ts
- * export default defineConfig({
- *   define: {
- *     __DEV__: JSON.stringify(process.env.NODE_ENV !== 'production'),
- *   },
- * });
+ * // Development build (after bundling):
+ * if ("development" !== 'production') {
+ *   console.warn('Warning'); // ✅ Included
+ * }
+ *
+ * // Production build (after bundling + minification):
+ * // The entire block is removed - zero runtime cost
  * ```
+ */
+/**
+ * Check if running in development mode.
  *
- * In production builds with __DEV__ = false, all code inside `if (__DEV__)` blocks
- * is completely removed via dead code elimination.
+ * **Note:** For tree-shaking to work, use the inline pattern directly:
+ * ```ts
+ * if (process.env.NODE_ENV !== 'production') {
+ *   // dev-only code
+ * }
+ * ```
  *
- * If __DEV__ is not defined, these utilities fall back to checking process.env.NODE_ENV.
+ * @returns `true` if in development mode, `false` in production
  */
+export declare function isDev(): boolean;
 /**
  * Development utilities namespace.
  *
- * **Usage:**
+ * **Important:** For optimal tree-shaking, prefer using inline checks:
  * ```ts
- * // Check if in dev mode
- * if (dev()) {
- *   // dev code
+ * if (process.env.NODE_ENV !== 'production') {
+ *   console.warn('[storion] Warning message');
  * }
- *
- * // Run function only in dev
- * dev(() => {
- *   validateSignalGraph();
- * });
- *
- * // Logging
- * dev.log("Signal created:", signal);
- * dev.warn("Deprecated API used");
- * dev.error("Invalid config:", config);
- *
- * // Assertions
- * dev.assert(value !== undefined, "Value cannot be undefined");
  * ```
  *
+ * The `dev.*` utilities are convenient but require the bundler to inline
+ * the `process.env.NODE_ENV` check within the function body.
+ *
  * @example
  * ```ts
  * // Check dev mode
@@ -68,7 +73,6 @@ export declare function dev(fn?: () => void): boolean;
 export declare namespace dev {
     /**
      * Log a message only in development.
-     * If __DEV__ is defined and is false, this is removed via dead code elimination.
      *
      * @param message - Message to log
      * @param args - Additional arguments
@@ -76,14 +80,13 @@ export declare namespace dev {
      * @example
      * ```ts
      * dev.log("Signal created:", signal);
-     * // Production (with __DEV__ defined): removed entirely
-     * // Development: console.log("[rextive] Signal created:", signal)
+     * // Production: removed entirely
+     * // Development: console.log("[storion] Signal created:", signal)
      * ```
      */
     function log(message: string, ...args: any[]): void;
     /**
      * Log a warning only in development.
-     * If __DEV__ is defined and is false, this is removed via dead code elimination.
      *
      * @param message - Warning message
      * @param args - Additional arguments
@@ -91,14 +94,13 @@ export declare namespace dev {
      * @example
      * ```ts
      * dev.warn("Deprecated API used");
-     * // Production (with __DEV__ defined): removed entirely
-     * // Development: console.warn("[rextive] Deprecated API used")
+     * // Production: removed entirely
+     * // Development: console.warn("[storion] Deprecated API used")
      * ```
      */
     function warn(message: string, ...args: any[]): void;
     /**
      * Log an error only in development.
-     * If __DEV__ is defined and is false, this is removed via dead code elimination.
      *
      * @param message - Error message
      * @param args - Additional arguments
@@ -106,14 +108,13 @@ export declare namespace dev {
      * @example
      * ```ts
      * dev.error("Invalid configuration:", config);
-     * // Production (with __DEV__ defined): removed entirely
-     * // Development: console.error("[rextive] Invalid configuration:", config)
+     * // Production: removed entirely
+     * // Development: console.error("[storion] Invalid configuration:", config)
      * ```
      */
     function error(message: string, ...args: any[]): void;
     /**
      * Assert a condition only in development.
-     * If __DEV__ is defined and is false, this is removed via dead code elimination.
      *
      * @param condition - Condition to assert
      * @param message - Error message if assertion fails
@@ -121,7 +122,7 @@ export declare namespace dev {
      * @example
      * ```ts
      * dev.assert(signal !== undefined, "Signal cannot be undefined");
-     * // Production (with __DEV__ defined): removed entirely
+     * // Production: removed entirely
      * // Development: throws if condition is false
      * ```
      */

package/dist/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAmCH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,GAAG,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAW5C;AAED;;GAEG;AACH,yBAAiB,GAAG,CAAC;IACnB;;;;;;;;;;;;;OAaG;IACH,SAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAIzD;IAED;;;;;;;;;;;;;OAaG;IACH,SAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAI1D;IAED;;;;;;;;;;;;;OAaG;IACH,SAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAI3D;IAED;;;;;;;;;;;;;OAaG;IACH,SAAgB,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAMhE;CACF"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAYH;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,IAAI,OAAO,CAE/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAU5C;AAED;;GAEG;AACH,yBAAiB,GAAG,CAAC;IACnB;;;;;;;;;;;;OAYG;IACH,SAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAIzD;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAI1D;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAI3D;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAMhE;CACF"}

package/dist/{effect-BDQU8Voz.js → effect-1beiYe_c.js}

@@ -1985,53 +1985,38 @@ function pick(selector, equality2) {
   });
   return currentValue;
 }
-function checkIsDev() {
-  var _a;
-  if (typeof __DEV__ !== "undefined") {
-    return __DEV__;
-  }
-  try {
-    const p = globalThis.process;
-    if ((_a = p == null ? void 0 : p.env) == null ? void 0 : _a.NODE_ENV) {
-      return p.env.NODE_ENV !== "production";
-    }
-  } catch {
-  }
-  return false;
-}
 function dev(fn) {
-  const isDev = checkIsDev();
+  if (process.env.NODE_ENV === "production") {
+    return false;
+  }
   if (fn) {
-    if (isDev) {
-      fn();
-    }
-    return isDev;
+    fn();
   }
-  return isDev;
+  return true;
 }
 ((dev2) => {
   function log(message, ...args) {
-    if (checkIsDev()) {
-      console.log(`[rextive] ${message}`, ...args);
+    if (process.env.NODE_ENV !== "production") {
+      console.log(`[storion] ${message}`, ...args);
     }
   }
   dev2.log = log;
   function warn(message, ...args) {
-    if (checkIsDev()) {
-      console.warn(`[rextive] ${message}`, ...args);
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(`[storion] ${message}`, ...args);
     }
   }
   dev2.warn = warn;
   function error(message, ...args) {
-    if (checkIsDev()) {
-      console.error(`[rextive] ${message}`, ...args);
+    if (process.env.NODE_ENV !== "production") {
+      console.error(`[storion] ${message}`, ...args);
     }
   }
   dev2.error = error;
   function assert(condition, message) {
-    if (checkIsDev()) {
+    if (process.env.NODE_ENV !== "production") {
       if (!condition) {
-        throw new Error(`[rextive] Assertion failed: ${message}`);
+        throw new Error(`[storion] Assertion failed: ${message}`);
       }
     }
   }
@@ -2962,7 +2947,8 @@ function createAbortableContext(controller, pauseState, takeState, setStatus) {
     race: baseSafe.race,
     settled: baseSafe.settled,
     any: baseSafe.any,
-    callback: baseSafe.callback
+    callback: baseSafe.callback,
+    delay: baseSafe.delay
   });
   const take = (key) => {
     const takeKey = String(key ?? "__checkpoint__");
@@ -3311,12 +3297,24 @@ function createSafe(getSignal, isCancelled) {
       cb(...args);
     };
   };
+  const delay = (ms, resolved) => {
+    if (isCancelled()) {
+      return new Promise(() => {
+      });
+    }
+    return wrapPromise(
+      new Promise((resolve) => {
+        setTimeout(() => resolve(resolved), ms);
+      })
+    );
+  };
   return Object.assign(safe, {
     all,
     race,
     settled,
     any,
-    callback
+    callback,
+    delay
   });
 }
 const retryStrategy = {
@@ -3615,10 +3613,11 @@ function effect(fn, options) {
 }
 export {
   AsyncNotReadyError as A,
-  pool as B,
-  tryDispose as C,
-  unwrapFn as D,
+  LocalStoreDependencyError as B,
+  pool as C,
+  tryDispose as D,
   EffectRefreshError as E,
+  unwrapFn as F,
   HooksContextError as H,
   InvalidActionError as I,
   LifetimeMismatchError as L,
@@ -3635,19 +3634,19 @@ export {
   isSpec as i,
   ScopedOutsideSelectorError as j,
   STORION_TYPE as k,
-  resolveEquality as l,
-  is$1 as m,
-  batch as n,
-  equality as o,
+  dev as l,
+  resolveEquality as m,
+  is$1 as n,
+  batch as o,
   pick as p,
-  shallowEqual as q,
+  equality as q,
   retryStrategy as r,
   storeTuple as s,
   tryStabilize as t,
   untrack as u,
-  deepEqual as v,
+  shallowEqual as v,
   withHooks as w,
-  StorionError as x,
-  StoreDisposedError as y,
-  LocalStoreDependencyError as z
+  deepEqual as x,
+  StorionError as y,
+  StoreDisposedError as z
 };

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export { container } from './core/container';
 export { batch, untrack } from './core/tracking';
 export { createResolver as resolver } from './core/createResolver';
 export { pick } from './core/pick';
-export { list, map, toggle, increment, decrement, multiply, divide, clamp, append, prepend, merge, reset, type ListOptions, type MapOptions, type FocusList, type FocusMap, } from './core/focusHelpers';
+export { list, map, disposalGroup, getNamedGroup, toggle, increment, decrement, multiply, divide, clamp, append, prepend, merge, reset, type ListOptions, type MapOptions, type FocusList, type FocusMap, type DisposalGroup, type FocusAutoDispose, type FocusAutoDisposeOptions, } from './core/focusHelpers';
 export { effect, type EffectFn, type EffectContext, type EffectOptions, type EffectErrorStrategy, type EffectErrorContext, type EffectRetryConfig, } from './core/effect';
 export { applyFor, applyExcept, forStores, type SpecPattern, type MiddlewareMap, } from './core/middleware';
 export { equality, shallowEqual, deepEqual, strictEqual, } from './core/equality';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAG1B,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAAE,cAAc,IAAI,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGnE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGnC,OAAO,EACL,IAAI,EACJ,GAAG,EAEH,MAAM,EACN,SAAS,EACT,SAAS,EACT,QAAQ,EACR,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,KAAK,EACL,KAAK,EAEL,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,QAAQ,GACd,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,MAAM,EACN,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EACR,WAAW,EACX,SAAS,EACT,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAGzD,OAAO,EACL,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAG1B,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAAE,cAAc,IAAI,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGnE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGnC,OAAO,EACL,IAAI,EACJ,GAAG,EACH,aAAa,EACb,aAAa,EAEb,MAAM,EACN,SAAS,EACT,SAAS,EACT,QAAQ,EACR,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,KAAK,EACL,KAAK,EAEL,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,GAC7B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,MAAM,EACN,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EACR,WAAW,EACX,SAAS,EACT,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAGzD,OAAO,EACL,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC"}

package/dist/react/index.js

@@ -3,12 +3,12 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 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 { append, applyExcept, applyFor, clamp, decrement, disposalGroup, divide, forStores, getNamedGroup, 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 dev, m as resolveEquality, a as store } from "../effect-1beiYe_c.js";
+import { E, H, I, L, B, S, z, y, o, x, e, q, n, p, C, v, u } from "../effect-1beiYe_c.js";
 import { e as emitter } from "../emitter-j4rC71vY.js";
 import { jsx } from "react/jsx-runtime";
-import { m as m2 } from "../meta-40r-AZfe.js";
+import { m } from "../meta-40r-AZfe.js";
 const StoreContext = createContext(null);
 const StoreProvider = memo(
   ({ container: value, children }) => {
@@ -181,8 +181,8 @@ function useStore(selector) {
   return useStoreWithContainer(selector, container2);
 }
 const isServer = typeof window === "undefined";
-const useIsomorphicLayoutEffect = isServer ? useEffect : useLayoutEffect;
-const shouldScheduleDispose = !isServer && typeof useLayoutEffect === "function";
+const useIsomorphicLayoutEffect = isServer || !dev() ? useEffect : useLayoutEffect;
+const shouldScheduleDispose = !isServer && dev() && typeof useLayoutEffect === "function";
 class ScopeController {
   constructor(container2) {
     /** Whether the effect has committed (is active) */
@@ -409,39 +409,41 @@ export {
   H as HooksContextError,
   I as InvalidActionError,
   L as LifetimeMismatchError,
-  z as LocalStoreDependencyError,
+  B as LocalStoreDependencyError,
   ProviderMissingError,
   STORION_TYPE,
   S as SetupPhaseError,
-  y as StoreDisposedError,
+  z as StoreDisposedError,
   StoreProvider,
-  x as StorionError,
+  y as StorionError,
   append,
   applyExcept,
   applyFor,
-  n as batch,
+  o as batch,
   clamp,
   container,
   create,
   decrement,
-  v as deepEqual,
+  x as deepEqual,
+  disposalGroup,
   divide,
   e as effect,
-  o as equality,
+  q as equality,
   forStores,
+  getNamedGroup,
   increment,
-  m as is,
+  n as is,
   list,
   map,
   merge,
-  m2 as meta,
+  m as meta,
   multiply,
   p as pick,
-  B as pool,
+  C as pool,
   prepend,
   reset,
   resolver,
-  q as shallowEqual,
+  v as shallowEqual,
   stable,
   store,
   strictEqual,

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;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"}
+{"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;AA8BlB;;;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"}