storion 0.8.3 → 0.10.0

package/dist/errors.d.ts

@@ -65,4 +65,10 @@ export declare class LocalStoreDependencyError extends StorionError {
 export declare class EffectRefreshError extends StorionError {
     constructor();
 }
+/**
+ * Thrown when scoped() is called outside of a selector function.
+ */
+export declare class ScopedOutsideSelectorError extends StorionError {
+    constructor();
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAI5B;AAMD;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBAE7C,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM;CAShB;AAMD;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBAEnD,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,WAAW,GAAG,QAAQ;CAUpC;AAMD;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAI1C;AAMD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAQnD;AAMD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;gBACrC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM;CAOpD;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;gBACxC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAI3C;AAMD;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,YAAY;gBAC7C,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM;CAOvD;AAMD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;;CAKnD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAI5B;AAMD;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBAE7C,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM;CAShB;AAMD;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBAEnD,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,WAAW,GAAG,QAAQ;CAUpC;AAMD;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAI1C;AAMD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAQnD;AAMD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;gBACrC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM;CAOpD;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;gBACxC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAI3C;AAMD;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,YAAY;gBAC7C,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM;CAOvD;AAMD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;;CAKnD;AAKD;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,YAAY;;CAQ3D"}

package/dist/index.d.ts

@@ -3,19 +3,20 @@
  *
  * @packageDocumentation
  */
-export { STORION_TYPE, type StorionKind, type StorionObject, type StateBase, type ActionsBase, type Equality, type EqualityMap, type Lifetime, type DispatchEvent, type ActionDispatchEvent, type ReactiveAction, type ReactiveActions, type StoreSpec, type StoreContext, type StoreMixin, type StoreOptions, type StoreInstance, type StoreContainer, type ContainerOptions, type StoreMiddleware, type SelectorContext, type SelectorMixin, type Selector, type StoreTuple, type StableResult, type PickEquality, type StatePath, type PathValue, type Focus, type FocusOptions, type FocusChangeEvent, type NonNullish, type Factory, type Middleware, type MiddlewareContext, type Resolver, type ResolverOptions, type MetaType, type MetaInfo, } from './types';
-export { is, isStorion, getKind, isSpec, isContainer, isStore, isFocus, isAction, isStoreContext, isSelectorContext, } from './is';
+export * from './types';
+export { is } from './is';
 export { store } from './core/store';
 export { container } from './core/container';
 export { batch, untrack } from './core/tracking';
-export { createResolver } from './core/createResolver';
+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 { 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';
 export { trigger, type TriggerOptions } from './trigger';
-export { wrapFn as wrapFn, unwrapFn, isWrappedFn } from './core/fnWrapper';
 export { StorionError, SetupPhaseError, LifetimeMismatchError, AsyncFunctionError, StoreDisposedError, InvalidActionError, HooksContextError, ProviderMissingError, LocalStoreDependencyError, EffectRefreshError, } from './errors';
 export { meta } from './meta/meta';
 export { withMeta } from './meta/withMeta';
+export { pool } from './pool';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,YAAY,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,EAEjB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAEf,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACb,KAAK,QAAQ,GACd,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,EAAE,EACF,SAAS,EACT,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,OAAO,EACP,QAAQ,EACR,cAAc,EACd,iBAAiB,GAClB,MAAM,MAAM,CAAC;AAGd,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,EAAE,MAAM,uBAAuB,CAAC;AAGvD,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,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,EAAE,MAAM,IAAI,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG3E,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"}
+{"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"}

package/dist/network/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Network connectivity module.
+ *
+ * Provides platform-agnostic network state management:
+ * - `networkStore` - Reactive store with `online` state for React components
+ * - `networkService` - Provides `isOnline()`, `waitForOnline()`, and `offlineRetry()` wrapper
+ * - `onlineService` - Customizable online/offline event subscription
+ * - `pingService` - Customizable network reachability check
+ *
+ * @example
+ * ```ts
+ * import { networkStore, networkService } from 'storion/network';
+ * import { abortable, retry } from 'storion/async';
+ *
+ * // React component - use store for reactive state
+ * function NetworkBanner() {
+ *   const { online } = useStore(({ get }) => {
+ *     const [state] = get(networkStore);
+ *     return { online: state.online };
+ *   });
+ *   return online ? null : <div>You are offline</div>;
+ * }
+ *
+ * // In store setup - use service for logic
+ * setup({ get, focus }) {
+ *   const network = get(networkService);
+ *
+ *   const fetchUsers = abortable(async ({ signal }) => {
+ *     const res = await fetch('/api/users', { signal });
+ *     return res.json();
+ *   });
+ *
+ *   // Chain wrappers: retry 3 times, then wait for network
+ *   const robustFetch = fetchUsers
+ *     .use(retry(3))
+ *     .use(network.offlineRetry());
+ *
+ *   const usersQuery = async.action(focus("users"), robustFetch);
+ *
+ *   return { fetchUsers: usersQuery.dispatch };
+ * }
+ *
+ * // Wait for connectivity
+ * const network = get(networkService);
+ * await network.waitForOnline();
+ * await uploadData();
+ *
+ * // Override for React Native
+ * container.set(onlineService, () => ({
+ *   isOnline: () => true,
+ *   subscribe: (listener) => NetInfo.addEventListener(s => listener(!!s.isConnected)),
+ * }));
+ *
+ * // Override for real connectivity check
+ * container.set(pingService, () => ({
+ *   ping: async () => {
+ *     try {
+ *       await fetch('/api/health', { method: 'HEAD' });
+ *       return true;
+ *     } catch { return false; }
+ *   },
+ * }));
+ * ```
+ */
+export { pingService, onlineService, type PingService, type OnlineService, } from './services';
+export { networkStore } from './store';
+export { isNetworkError } from './utils';
+export { networkService, type NetworkService } from './retry';
+//# sourceMappingURL=index.d.ts.map

package/dist/network/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/network/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAGH,OAAO,EACL,WAAW,EACX,aAAa,EACb,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGvC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGzC,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC"}

package/dist/network/retry.d.ts

@@ -0,0 +1,53 @@
+import { Resolver } from '../types';
+import { IdentityWrapper } from '../async';
+
+/**
+ * Service for handling network detection and retry logic.
+ *
+ * Provides:
+ * - `isOnline()` - Check current connectivity
+ * - `subscribe()` - Listen to online/offline changes
+ * - `waitForOnline()` - Promise that resolves when online
+ * - `offlineRetry()` - Wrapper for automatic retry on reconnection
+ *
+ * @example
+ * ```ts
+ * import { abortable, retry } from "storion/async";
+ * import { networkService } from "storion/network";
+ *
+ * setup({ get, focus }) {
+ *   const network = get(networkService);
+ *
+ *   const fetchUsers = abortable(async ({ signal }) => {
+ *     const res = await fetch("/api/users", { signal });
+ *     return res.json();
+ *   });
+ *
+ *   // Chain wrappers: retry 3 times, then wait for network
+ *   const robustFetch = fetchUsers
+ *     .use(retry(3))
+ *     .use(network.offlineRetry());
+ *
+ *   const usersQuery = async.action(focus("users"), robustFetch);
+ *
+ *   return { fetchUsers: usersQuery.dispatch };
+ * }
+ * ```
+ */
+export declare const networkService: ({ get }: Resolver) => {
+    isOnline: () => boolean;
+    subscribe: {
+        (listeners: import('..').SingleOrMultipleListeners<boolean>): VoidFunction;
+        <TValue>(map: (value: boolean) => {
+            value: TValue;
+        } | undefined, listeners: import('..').SingleOrMultipleListeners<TValue>): VoidFunction;
+    };
+    waitForOnline: () => Promise<void>;
+    offlineRetry: () => IdentityWrapper;
+    dispose: () => void;
+};
+/**
+ * Type of the network service instance.
+ */
+export type NetworkService = ReturnType<typeof networkService>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/network/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/network/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAShD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,QAAQ;oBAuCzB,OAAO;;;;;;;yBAoCF,OAAO,CAAC,IAAI,CAAC;wBAkCd,eAAe;mBAmBpB,IAAI;CAWzB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/network/services.d.ts

@@ -0,0 +1,58 @@
+import { Factory } from '../types';
+
+export interface PingService {
+    /**
+     * Check if the network is reachable.
+     * Default: 300ms delay, returns true (optimistic).
+     */
+    ping(): Promise<boolean>;
+}
+export interface OnlineService {
+    /**
+     * Get current online status.
+     * Default: uses navigator.onLine if available.
+     */
+    isOnline(): boolean;
+    /**
+     * Subscribe to online/offline events.
+     * Default: uses window 'online'/'offline' events.
+     *
+     * @returns Unsubscribe function
+     */
+    subscribe(listener: (online: boolean) => void): VoidFunction;
+}
+/**
+ * Service for checking network reachability.
+ *
+ * Default implementation: 300ms delay, always returns true (optimistic).
+ *
+ * Override for real connectivity check:
+ * ```ts
+ * container.set(pingService, () => ({
+ *   ping: async () => {
+ *     try {
+ *       await fetch('/api/health', { method: 'HEAD' });
+ *       return true;
+ *     } catch { return false; }
+ *   },
+ * }));
+ * ```
+ */
+export declare const pingService: Factory<PingService>;
+/**
+ * Service for online/offline event subscription.
+ *
+ * Default implementation: uses browser's navigator.onLine and window events.
+ *
+ * Override for React Native:
+ * ```ts
+ * import NetInfo from '@react-native-community/netinfo';
+ *
+ * container.set(onlineService, () => ({
+ *   isOnline: () => true,
+ *   subscribe: (listener) => NetInfo.addEventListener(s => listener(!!s.isConnected)),
+ * }));
+ * ```
+ */
+export declare const onlineService: Factory<OnlineService>;
+//# sourceMappingURL=services.d.ts.map

package/dist/network/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/network/services.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAOxC,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,QAAQ,IAAI,OAAO,CAAC;IAEpB;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,YAAY,CAAC;CAC9D;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,EAAE,OAAO,CAAC,WAAW,CAO5C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,aAAa,CAwBhD,CAAC"}

package/dist/network/store.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Reactive network state store.
+ *
+ * This store consumes `networkService` to provide reactive state for React components.
+ * The actual logic lives in `networkService` - this store only syncs the state.
+ */
+/**
+ * Reactive network state store.
+ *
+ * Provides reactive `state.online` for UI components.
+ * For logic (waitForOnline, offlineRetry), use `networkService` directly.
+ *
+ * @example
+ * ```ts
+ * // React component - use store for reactive state
+ * function NetworkIndicator() {
+ *   const { online } = useStore(({ get }) => {
+ *     const [state] = get(networkStore);
+ *     return { online: state.online };
+ *   });
+ *   return online ? '🟢 Online' : '🔴 Offline';
+ * }
+ *
+ * // In store setup - use service for logic
+ * setup({ get, focus }) {
+ *   const network = get(networkService);
+ *   await network.waitForOnline();
+ *   const robustFetch = fetchUsers.use(network.offlineRetry());
+ * }
+ * ```
+ */
+export declare const networkStore: import('..').StoreSpec<{
+    /** Whether the network is currently online */
+    online: boolean;
+}, {}>;
+//# sourceMappingURL=store.d.ts.map

package/dist/network/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/network/store.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,YAAY;IAGrB,8CAA8C;;MAoBhD,CAAC"}

package/dist/network/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Network utility functions.
+ */
+/**
+ * Check if an error is a network connectivity error.
+ * Works across Chrome, Firefox, Safari, React Native, and Apollo Client.
+ */
+export declare function isNetworkError(error: unknown): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/network/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/network/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAuDtD"}

package/dist/persist/index.d.ts

@@ -5,5 +5,5 @@
  *
  * @packageDocumentation
  */
-export { persistMiddleware, notPersisted, type PersistOptions, type PersistLoadResult, } from './persist';
+export { persist, notPersisted, type PersistOptions, type PersistLoadResult, } from './persist';
 //# sourceMappingURL=index.d.ts.map

package/dist/persist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/persist/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,KAAK,cAAc,EACnB,KAAK,iBAAiB,GACvB,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/persist/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,OAAO,EACP,YAAY,EACZ,KAAK,cAAc,EACnB,KAAK,iBAAiB,GACvB,MAAM,WAAW,CAAC"}

package/dist/persist/index.js

@@ -1,12 +1,18 @@
 import { m as meta } from "../meta-40r-AZfe.js";
-import { i as isPromiseLike } from "../isPromiseLike-bFkfHAbm.js";
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
 const notPersisted = meta();
-function persistMiddleware(options) {
-  const { filter, fields, load, save, onError, force = false } = options;
+function persist(options) {
+  const { filter, fields, handler, onError, force = false } = options;
   return (context) => {
     const { next, meta: meta2 } = context;
     const instance = next();
-    if (filter && !filter(context)) {
+    const persistContext = {
+      ...context,
+      store: instance
+    };
+    if (filter && !filter(persistContext)) {
       return instance;
     }
     const notPersistedInfo = meta2(notPersisted);
@@ -18,7 +24,7 @@ function persistMiddleware(options) {
         (field) => notPersistedInfo.fields[field] === true
       )
     );
-    const stateFields = (fields == null ? void 0 : fields(context)) ?? context.spec.fields;
+    const stateFields = (fields == null ? void 0 : fields(persistContext)) ?? context.spec.fields;
     if (stateFields.length === 0) {
       return instance;
     }
@@ -38,44 +44,62 @@ function persistMiddleware(options) {
       }
       return filtered;
     };
-    const hydrateWithState = (state) => {
-      if (state != null) {
+    const setupPersistence = (persistHandler) => {
+      const { load, save } = persistHandler;
+      const hydrateWithState = (state) => {
+        if (state != null) {
+          try {
+            instance.hydrate(filterState(state), { force });
+          } catch (error) {
+            onError == null ? void 0 : onError(error, "load");
+          }
+        }
+      };
+      if (load) {
         try {
-          instance.hydrate(filterState(state), { force });
+          const loadResult = load();
+          if (loadResult) {
+            if (isPromiseLike(loadResult)) {
+              loadResult.then(
+                (state) => hydrateWithState(state),
+                (error) => onError == null ? void 0 : onError(error, "load")
+              );
+            } else {
+              hydrateWithState(loadResult);
+            }
+          }
         } catch (error) {
-          onError == null ? void 0 : onError(context, error, "load");
+          onError == null ? void 0 : onError(error, "load");
         }
       }
+      if (save) {
+        instance.subscribe(() => {
+          try {
+            const state = instance.dehydrate();
+            save(filterState(state));
+          } catch (error) {
+            onError == null ? void 0 : onError(error, "save");
+          }
+        });
+      }
     };
     try {
-      const loadResult = load == null ? void 0 : load(context);
-      if (loadResult) {
-        if (isPromiseLike(loadResult)) {
-          loadResult.then(
-            (state) => hydrateWithState(state),
-            (error) => onError == null ? void 0 : onError(context, error, "load")
-          );
-        } else {
-          hydrateWithState(loadResult);
-        }
+      const handlerResult = handler(persistContext);
+      if (isPromiseLike(handlerResult)) {
+        handlerResult.then(
+          (persistHandler) => setupPersistence(persistHandler),
+          (error) => onError == null ? void 0 : onError(error, "init")
+        );
+      } else {
+        setupPersistence(handlerResult);
       }
     } catch (error) {
-      onError == null ? void 0 : onError(context, error, "load");
-    }
-    if (save) {
-      instance.subscribe(() => {
-        try {
-          const state = instance.dehydrate();
-          save(context, filterState(state));
-        } catch (error) {
-          onError == null ? void 0 : onError(context, error, "save");
-        }
-      });
+      onError == null ? void 0 : onError(error, "init");
     }
     return instance;
   };
 }
 export {
   notPersisted,
-  persistMiddleware
+  persist
 };