storion 0.8.2 → 0.9.0

package/CHANGELOG.md

@@ -8,23 +8,64 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+
 - `MetaEntry.fields` now supports arrays for applying meta to multiple fields at once
   ```ts
-  meta: [notPersisted.for(["password", "token"])]
+  meta: [notPersisted.for(["password", "token"])];
   ```
 - `MetaQuery.fields(type, predicate?)` method to get field names with a specific meta type
   ```ts
-  const sessionFields = ctx.meta.fields(sessionStore);  // ['token', 'userId']
-  const highPriority = ctx.meta.fields(priority, v => v > 5);
+  const sessionFields = ctx.meta.fields(sessionStore); // ['token', 'userId']
+  const highPriority = ctx.meta.fields(priority, (v) => v > 5);
   ```
-- `persistMiddleware` `fields` option for multi-storage patterns
+- `applyFor` now supports object form to map patterns to different middleware
+  ```ts
+  applyFor({
+    userStore: loggingMiddleware,
+    "auth*": [authMiddleware, securityMiddleware],
+    "*Cache": cacheMiddleware,
+  });
+  ```
+
+### Changed
+
+- **BREAKING**: `persistMiddleware` API refactored for better encapsulation
+
+  - New `handler` option replaces `load`/`save` callbacks
+  - Handler receives `PersistContext` (extends `StoreMiddlewareContext` with `store` instance)
+  - Handler returns `{ load, save }` object (can be sync or async)
+  - `onError` signature changed to `(error, operation)` where operation is `"init" | "load" | "save"`
+  - Enables encapsulated async initialization (e.g., IndexedDB)
+
   ```ts
-  // Split fields between session and local storage
+  // Before (old API)
   persistMiddleware({
-    filter: ({ meta }) => meta.any(sessionStore),
-    fields: ({ meta }) => meta.fields(sessionStore),
-    save: (ctx, state) => sessionStorage.setItem(ctx.displayName, JSON.stringify(state)),
-  })
+    load: (ctx) => localStorage.getItem(ctx.displayName),
+    save: (ctx, state) =>
+      localStorage.setItem(ctx.displayName, JSON.stringify(state)),
+  });
+
+  // After (new API)
+  persistMiddleware({
+    handler: (ctx) => {
+      const key = `app:${ctx.displayName}`;
+      return {
+        load: () => JSON.parse(localStorage.getItem(key) || "null"),
+        save: (state) => localStorage.setItem(key, JSON.stringify(state)),
+      };
+    },
+  });
+
+  // Async handler (IndexedDB)
+  persistMiddleware({
+    handler: async (ctx) => {
+      const db = await openDB("app-db");
+      return {
+        load: () => db.get("stores", ctx.displayName),
+        save: (state) => db.put("stores", state, ctx.displayName),
+      };
+    },
+  });
   ```
 
 ---
@@ -32,6 +73,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.8.0] - 2024-12-21
 
 ### Added
+
 - **Persist Module** (`storion/persist`)
   - `persistMiddleware(options)` for automatic state persistence
   - `notPersisted` meta for excluding stores or fields from persistence
@@ -50,6 +92,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `store.hydrate(state, { force })` - force option to override dirty properties
 
 ### Changed
+
 - `StoreMiddlewareContext` now includes `meta` property for querying store metadata
 - `FactoryMiddlewareContext` now includes `meta` property for querying factory metadata
 
@@ -58,6 +101,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.7.0] - 2024-12-15
 
 ### Added
+
 - **DevTools Module** (`storion/devtools`)
   - `devtoolsMiddleware()` for state inspection
   - `__revertState` and `__takeSnapshot` injected actions
@@ -71,6 +115,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `create()` shorthand for single-store apps returning `[instance, useHook, withStore]`
 
 ### Changed
+
 - Improved TypeScript inference for store actions
 
 ---
@@ -78,6 +123,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.6.0] - 2024-12-01
 
 ### Added
+
 - **Async Module** (`storion/async`)
   - `async.fresh<T>()` - throws during loading (Suspense-compatible)
   - `async.stale<T>(initialData)` - returns stale data during loading
@@ -87,6 +133,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `trigger(action, deps, ...args)` for declarative data fetching in components
 
 ### Changed
+
 - Effects now require synchronous functions (use `ctx.safe()` for async)
 
 ---
@@ -94,6 +141,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.5.0] - 2024-11-15
 
 ### Added
+
 - **Focus (Lens-like Access)**
   - `focus(path)` for nested state access
   - Returns `[getter, setter]` tuple
@@ -111,6 +159,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.4.0] - 2024-11-01
 
 ### Added
+
 - **Middleware System**
   - `container({ middleware: [...] })` for middleware injection
   - Middleware receives `MiddlewareContext` with `type`, `next`, `resolver`
@@ -119,6 +168,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `createValidationMiddleware()` built-in middleware
 
 ### Changed
+
 - Container now uses middleware chain pattern
 
 ---
@@ -126,6 +176,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.3.0] - 2024-10-15
 
 ### Added
+
 - **Store Lifecycle**
   - `lifetime: "keepAlive"` (default) - persists until container disposal
   - `lifetime: "autoDispose"` - disposes when no subscribers
@@ -137,6 +188,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `store.reset()` to restore initial state
 
 ### Changed
+
 - Stores now track dirty state automatically
 
 ---
@@ -144,6 +196,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.2.0] - 2024-10-01
 
 ### Added
+
 - **Dependency Injection**
   - `container()` for managing store instances
   - `get(factory)` for resolving dependencies
@@ -153,6 +206,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `useContainer()` hook
 
 ### Changed
+
 - Stores are now lazily instantiated via container
 
 ---
@@ -160,6 +214,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.0] - 2024-09-15
 
 ### Added
+
 - **Core Store**
   - `store(options)` factory function
   - `state` - reactive state object
@@ -187,22 +242,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Migrating to 0.8.0
 
 #### Meta System Changes
+
 If you were using internal meta APIs, update to the new public API:
 
 ```ts
 // Before (internal)
-spec.meta // was MetaEntry[]
+spec.meta; // was MetaEntry[]
 
 // After (0.8.0)
-ctx.meta(persistMeta).store    // query store-level
-ctx.meta(persistMeta).fields   // query field-level
-ctx.meta.all(type)             // get all values
-ctx.meta.any(type1, type2)     // check existence
+ctx.meta(persistMeta).store; // query store-level
+ctx.meta(persistMeta).fields; // query field-level
+ctx.meta.all(type); // get all values
+ctx.meta.any(type1, type2); // check existence
 ```
 
 ### Migrating to 0.6.0
 
 #### Async Effects
+
 Effects must now be synchronous:
 
 ```ts
@@ -231,4 +288,3 @@ effect((ctx) => {
 [0.3.0]: https://github.com/linq2js/storion/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/linq2js/storion/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/linq2js/storion/releases/tag/v0.1.0
-

package/dist/core/middleware.d.ts

@@ -2,6 +2,8 @@ import { Middleware, MiddlewareContext, StoreMiddleware } from '../types';
 
 /** Pattern type for matching displayName */
 export type SpecPattern = string | RegExp;
+/** Mapping of patterns to middleware */
+export type MiddlewareMap = Record<string, StoreMiddleware | StoreMiddleware[]>;
 /**
  * Conditionally apply middleware based on a predicate or pattern(s).
  *
@@ -13,6 +15,9 @@ export type SpecPattern = string | RegExp;
  * @param patterns - Pattern or array of patterns to match displayName
  * @param middleware - Middleware or array of middleware to apply
  *
+ * @overload Apply different middleware for different patterns (object form)
+ * @param middlewareMap - Object mapping patterns to middleware
+ *
  * Pattern types:
  * - `"userStore"` - exact match
  * - `"user*"` - startsWith
@@ -44,10 +49,18 @@ export type SpecPattern = string | RegExp;
  *
  * // Multiple middleware
  * applyFor("counterStore", [loggingMiddleware, devtoolsMiddleware]);
+ *
+ * // Object form - map patterns to middleware
+ * applyFor({
+ *   "userStore": loggingMiddleware,
+ *   "auth*": [authMiddleware, securityMiddleware],
+ *   "*Cache": cacheMiddleware,
+ * });
  * ```
  */
 export declare function applyFor(predicate: (ctx: MiddlewareContext) => boolean, middleware: Middleware | Middleware[]): Middleware;
 export declare function applyFor(patterns: SpecPattern | SpecPattern[], middleware: StoreMiddleware | StoreMiddleware[]): Middleware;
+export declare function applyFor(middlewareMap: MiddlewareMap): Middleware;
 /**
  * Apply middleware to all except those matching predicate or pattern(s).
  *

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

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/core/middleware.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAEV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,UAAU,CAAC;AAElB,4CAA4C;AAC5C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AA8F1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,EAC9C,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AACd,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EACrC,UAAU,EAAE,eAAe,GAAG,eAAe,EAAE,GAC9C,UAAU,CAAC;AA4Bd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CACzB,SAAS,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,EAC9C,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AACd,wBAAgB,WAAW,CACzB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EACrC,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AAmBd;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,eAAe,EAAE,eAAe,GAAG,eAAe,EAAE,GACnD,UAAU,CAWZ"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/core/middleware.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAEV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAEhB,MAAM,UAAU,CAAC;AAElB,4CAA4C;AAC5C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AA8F1C,wCAAwC;AACxC,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,EAAE,CAAC,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,EAC9C,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AACd,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EACrC,UAAU,EAAE,eAAe,GAAG,eAAe,EAAE,GAC9C,UAAU,CAAC;AACd,wBAAgB,QAAQ,CAAC,aAAa,EAAE,aAAa,GAAG,UAAU,CAAC;AAwDnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CACzB,SAAS,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,EAC9C,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AACd,wBAAgB,WAAW,CACzB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EACrC,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AAmBd;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,eAAe,EAAE,eAAe,GAAG,eAAe,EAAE,GACnD,UAAU,CAWZ"}

package/dist/{index-BsdNVe8q.js → index-C8B6Mo8r.js}

@@ -2868,8 +2868,23 @@ function compose(...middlewares) {
     return executeNext();
   };
 }
-function applyFor(predicateOrPatterns, middleware) {
-  const predicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
+function applyFor(predicateOrPatternsOrMap, middleware) {
+  if (typeof predicateOrPatternsOrMap === "object" && !Array.isArray(predicateOrPatternsOrMap) && !(predicateOrPatternsOrMap instanceof RegExp)) {
+    const entries = Object.entries(predicateOrPatternsOrMap);
+    const pairs = entries.map(([pattern, mw]) => ({
+      predicate: patternsToPredicate(pattern),
+      middleware: Array.isArray(mw) ? compose(...mw) : mw
+    }));
+    return (ctx) => {
+      for (const { predicate: predicate2, middleware: middleware2 } of pairs) {
+        if (predicate2(ctx)) {
+          return middleware2(ctx);
+        }
+      }
+      return ctx.next();
+    };
+  }
+  const predicate = typeof predicateOrPatternsOrMap === "function" ? predicateOrPatternsOrMap : patternsToPredicate(predicateOrPatternsOrMap);
   const composedMiddleware = Array.isArray(middleware) ? compose(...middleware) : middleware;
   return (ctx) => {
     if (predicate(ctx)) {

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { batch, untrack } from './core/tracking';
 export { createResolver } from './core/createResolver';
 export { pick } from './core/pick';
 export { effect, type EffectFn, type EffectContext, type EffectOptions, type EffectErrorStrategy, type EffectErrorContext, type EffectRetryConfig, } from './core/effect';
-export { applyFor, applyExcept, forStores, type SpecPattern, } from './core/middleware';
+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';

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,GACjB,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,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"}

package/dist/persist/index.js

@@ -2,7 +2,7 @@ import { m as meta } from "../meta-40r-AZfe.js";
 import { i as isPromiseLike } from "../isPromiseLike-bFkfHAbm.js";
 const notPersisted = meta();
 function persistMiddleware(options) {
-  const { filter, fields, load, save, onError, force = false } = options;
+  const { filter, fields, handler, onError, force = false } = options;
   return (context) => {
     const { next, meta: meta2 } = context;
     const instance = next();
@@ -38,39 +38,61 @@ function persistMiddleware(options) {
       }
       return filtered;
     };
-    const hydrateWithState = (state) => {
-      if (state != null) {
+    const persistContext = {
+      ...context,
+      store: instance
+    };
+    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;
   };

package/dist/persist/persist.d.ts

@@ -1,4 +1,4 @@
-import { StoreMiddleware, StoreMiddlewareContext } from '../types';
+import { StoreMiddleware, StoreMiddlewareContext, StoreInstance } from '../types';
 
 /**
  * Mark stores or fields as not persisted.
@@ -27,8 +27,8 @@ import { StoreMiddleware, StoreMiddlewareContext } from '../types';
  *   state: { name: '', password: '', token: '' },
  *   setup: () => ({}),
  *   meta: [
- *     notPersisted('password'),
- *     notPersisted('token'),
+ *     notPersisted.for('password'),
+ *     notPersisted.for('token'),
  *   ],
  * });
  * ```
@@ -38,6 +38,33 @@ export declare const notPersisted: import('..').MetaType<any, [], true>;
  * Result from load function - can be sync or async
  */
 export type PersistLoadResult = Record<string, unknown> | null | undefined | Promise<Record<string, unknown> | null | undefined>;
+/**
+ * Context passed to the handler function.
+ * Extends StoreMiddlewareContext with the created store instance.
+ */
+export interface PersistContext extends StoreMiddlewareContext {
+    /** The store instance being persisted */
+    store: StoreInstance;
+}
+/**
+ * Handler returned by the handler function.
+ * Contains the load and save operations for a specific store.
+ */
+export interface PersistHandler {
+    /**
+     * Load persisted state for the store.
+     * Can return sync or async result.
+     *
+     * @returns The persisted state, null/undefined if not found, or a Promise
+     */
+    load?: () => PersistLoadResult;
+    /**
+     * Save state to persistent storage.
+     *
+     * @param state - The dehydrated state to save
+     */
+    save?: (state: Record<string, unknown>) => void;
+}
 /**
  * Options for persist middleware
  */
@@ -59,28 +86,43 @@ export interface PersistOptions {
      */
     fields?: (context: StoreMiddlewareContext) => string[];
     /**
-     * Load persisted state for a store.
-     * Can return sync or async result.
+     * Handler factory that creates load/save operations for each store.
+     * Receives context with store instance, returns handler with load/save.
+     * Can be sync or async (e.g., for IndexedDB initialization).
      *
-     * @param context - The middleware context
-     * @returns The persisted state, null/undefined if not found, or a Promise
-     */
-    load?: (context: StoreMiddlewareContext) => PersistLoadResult;
-    /**
-     * Save state to persistent storage.
+     * @param context - The persist context with store instance
+     * @returns Handler with load/save operations, or Promise of handler
      *
-     * @param context - The middleware context
-     * @param state - The dehydrated state to save
+     * @example Sync handler (localStorage)
+     * ```ts
+     * handler: (ctx) => {
+     *   const key = `app:${ctx.displayName}`;
+     *   return {
+     *     load: () => JSON.parse(localStorage.getItem(key) || 'null'),
+     *     save: (state) => localStorage.setItem(key, JSON.stringify(state)),
+     *   };
+     * }
+     * ```
+     *
+     * @example Async handler (IndexedDB)
+     * ```ts
+     * handler: async (ctx) => {
+     *   const db = await openDB('app-db');
+     *   return {
+     *     load: () => db.get('stores', ctx.displayName),
+     *     save: (state) => db.put('stores', state, ctx.displayName),
+     *   };
+     * }
+     * ```
      */
-    save?: (context: StoreMiddlewareContext, state: Record<string, unknown>) => void;
+    handler: (context: PersistContext) => PersistHandler | PromiseLike<PersistHandler>;
     /**
-     * Called when an error occurs during load or save.
+     * Called when an error occurs during init, load, or save.
      *
-     * @param context - The middleware context
      * @param error - The error that occurred
-     * @param operation - Whether the error occurred during 'load' or 'save'
+     * @param operation - Whether the error occurred during 'init', 'load', or 'save'
      */
-    onError?: (context: StoreMiddlewareContext, error: unknown, operation: "load" | "save") => void;
+    onError?: (error: unknown, operation: "init" | "load" | "save") => void;
     /**
      * Force hydration to overwrite dirty (modified) state properties.
      *
@@ -96,59 +138,74 @@ export interface PersistOptions {
 /**
  * Creates a persist middleware that automatically saves and restores store state.
  *
- * @example
+ * @example localStorage (sync handler)
  * ```ts
- * import { container } from "storion";
+ * import { container, forStores } from "storion";
  * import { persistMiddleware } from "storion/persist";
  *
  * const app = container({
- *   middleware: [persistMiddleware({
- *     load: (ctx) => {
- *       const key = `storion:${ctx.spec.displayName}`;
- *       const data = localStorage.getItem(key);
- *       return data ? JSON.parse(data) : null;
- *     },
- *     save: (ctx, state) => {
- *       const key = `storion:${ctx.spec.displayName}`;
- *       localStorage.setItem(key, JSON.stringify(state));
- *     },
- *     onError: (ctx, error, op) => {
- *       console.error(`Persist ${op} error for ${ctx.spec.displayName}:`, error);
- *     },
- *   })],
+ *   middleware: forStores([
+ *     persistMiddleware({
+ *       handler: (ctx) => {
+ *         const key = `app:${ctx.displayName}`;
+ *         return {
+ *           load: () => JSON.parse(localStorage.getItem(key) || 'null'),
+ *           save: (state) => localStorage.setItem(key, JSON.stringify(state)),
+ *         };
+ *       },
+ *       onError: (error, op) => console.error(`Persist ${op} failed:`, error),
+ *     }),
+ *   ]),
  * });
  * ```
  *
- * @example Async load (e.g., IndexedDB)
+ * @example IndexedDB (async handler)
  * ```ts
  * persistMiddleware({
- *   load: async (ctx) => {
- *     const db = await openDB();
- *     return db.get('stores', ctx.spec.displayName);
- *   },
- *   save: (ctx, state) => {
- *     openDB().then(db => db.put('stores', state, ctx.spec.displayName));
+ *   handler: async (ctx) => {
+ *     const db = await openDB('app-db', 1, {
+ *       upgrade(db) { db.createObjectStore('stores'); },
+ *     });
+ *     return {
+ *       load: () => db.get('stores', ctx.displayName),
+ *       save: (state) => db.put('stores', state, ctx.displayName),
+ *     };
  *   },
  * });
  * ```
  *
- * @example Using meta in callbacks
+ * @example With shared debounce
  * ```ts
- * import { meta } from "storion";
+ * persistMiddleware({
+ *   handler: (ctx) => {
+ *     const key = `app:${ctx.displayName}`;
+ *     const debouncedSave = debounce(
+ *       (s) => localStorage.setItem(key, JSON.stringify(s)),
+ *       300
+ *     );
+ *     return {
+ *       load: () => JSON.parse(localStorage.getItem(key) || 'null'),
+ *       save: debouncedSave,
+ *     };
+ *   },
+ * });
+ * ```
  *
- * const persistKey = meta<string>();
+ * @example Multi-storage with meta
+ * ```ts
+ * const sessionStore = meta();
+ * const localStore = meta();
  *
+ * // Session storage middleware
  * persistMiddleware({
- *   load: (ctx) => {
- *     // Use custom key from meta, fallback to displayName
- *     const customKey = ctx.meta(persistKey).store;
- *     const key = customKey ?? ctx.spec.displayName;
- *     return JSON.parse(localStorage.getItem(key) || 'null');
- *   },
- *   save: (ctx, state) => {
- *     const customKey = ctx.meta(persistKey).store;
- *     const key = customKey ?? ctx.spec.displayName;
- *     localStorage.setItem(key, JSON.stringify(state));
+ *   filter: ({ meta }) => meta.any(sessionStore),
+ *   fields: ({ meta }) => meta.fields(sessionStore),
+ *   handler: (ctx) => {
+ *     const key = `session:${ctx.displayName}`;
+ *     return {
+ *       load: () => JSON.parse(sessionStorage.getItem(key) || 'null'),
+ *       save: (state) => sessionStorage.setItem(key, JSON.stringify(state)),
+ *     };
  *   },
  * });
  * ```

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

@@ -1 +1 @@
-{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../src/persist/persist.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAIxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,YAAY,sCAAS,CAAC;AAEnC;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,IAAI,GACJ,SAAS,GACT,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC;IAEtD;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,MAAM,EAAE,CAAC;IAEvD;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,iBAAiB,CAAC;IAE9D;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CACL,OAAO,EAAE,sBAAsB,EAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC3B,IAAI,CAAC;IAEV;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CACR,OAAO,EAAE,sBAAsB,EAC/B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAAG,MAAM,KACvB,IAAI,CAAC;IAEV;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAyH1E"}
+{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../src/persist/persist.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,sBAAsB,EACtB,aAAa,EACd,MAAM,UAAU,CAAC;AAIlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,YAAY,sCAAS,CAAC;AAEnC;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,IAAI,GACJ,SAAS,GACT,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAExD;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,sBAAsB;IAC5D,yCAAyC;IACzC,KAAK,EAAE,aAAa,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,iBAAiB,CAAC;IAE/B;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC;IAEtD;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,MAAM,EAAE,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,OAAO,EAAE,CACP,OAAO,EAAE,cAAc,KACpB,cAAc,GAAG,WAAW,CAAC,cAAc,CAAC,CAAC;IAElD;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;IAExE;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAkJ1E"}

package/dist/react/index.js

@@ -2,8 +2,8 @@ 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-BsdNVe8q.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-BsdNVe8q.js";
+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 { jsx } from "react/jsx-runtime";

package/dist/storion.js

@@ -1,4 +1,4 @@
-import { S, n, m, c, l, u, q, o, g, a, h, d, f, k, i, e, j, b, z, p, t, s, v, w, y, A, x } from "./index-BsdNVe8q.js";
+import { S, n, m, c, l, u, q, o, g, a, h, d, f, k, i, e, j, b, z, p, t, s, v, w, y, A, x } from "./index-C8B6Mo8r.js";
 import { A as A2, E, H, I, c as c2, L, P, a as a2, d as d2, S as S2, b as b2, e as e2, u as u2 } from "./effect-C6h0PDDI.js";
 import { m as m2 } from "./meta-40r-AZfe.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storion",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Reactive stores for modern apps. Type-safe. Auto-tracked. Effortlessly composable",
   "type": "module",
   "main": "./dist/storion.js",