storion 0.8.3 → 0.9.0

package/CHANGELOG.md

@@ -8,31 +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);
-  ```
-- `persistMiddleware` `fields` option for multi-storage patterns
-  ```ts
-  // Split fields between session and local storage
-  persistMiddleware({
-    filter: ({ meta }) => meta.any(sessionStore),
-    fields: ({ meta }) => meta.fields(sessionStore),
-    save: (ctx, state) => sessionStorage.setItem(ctx.displayName, JSON.stringify(state)),
-  })
+  const sessionFields = ctx.meta.fields(sessionStore); // ['token', 'userId']
+  const highPriority = ctx.meta.fields(priority, (v) => v > 5);
   ```
 - `applyFor` now supports object form to map patterns to different middleware
   ```ts
   applyFor({
-    "userStore": loggingMiddleware,
+    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
+  // Before (old API)
+  persistMiddleware({
+    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),
+      };
+    },
+  });
   ```
 
 ---
@@ -40,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
@@ -58,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
 
@@ -66,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
@@ -79,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
 
 ---
@@ -86,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
@@ -95,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)
 
 ---
@@ -102,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
@@ -119,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`
@@ -127,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
 
 ---
@@ -134,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
@@ -145,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
 
 ---
@@ -152,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
@@ -161,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
 
 ---
@@ -168,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
@@ -195,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
@@ -239,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/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/package.json

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