storion 0.7.9 → 0.8.0

package/dist/meta/meta.d.ts

@@ -0,0 +1,71 @@
+import { MetaType } from '../types';
+
+/**
+ * Create a metadata builder for decorating stores with custom metadata.
+ *
+ * Meta allows libraries and users to attach arbitrary typed metadata to:
+ * - Store level: `myMeta(value)` - applies to the entire store
+ * - Field level: `myMeta.for("fieldName", value)` - applies to specific state field
+ *
+ * Retrieve meta via `ctx.meta(type)` which returns first value (default),
+ * or use `ctx.meta.all(type)` for all values.
+ *
+ * @example Store-level meta (boolean flag)
+ * ```ts
+ * const persist = meta();
+ *
+ * const userStore = store({
+ *   state: { name: "" },
+ *   meta: [persist()],
+ * });
+ *
+ * ctx.meta(persist).store;           // true (first value)
+ * ctx.meta.all(persist).store;       // [true] (all values)
+ * ```
+ *
+ * @example Store-level meta (with value)
+ * ```ts
+ * const priority = meta((level: number) => level);
+ *
+ * const criticalStore = store({
+ *   state: { data: null },
+ *   meta: [priority(1), priority(2)],
+ * });
+ *
+ * ctx.meta(priority).store;           // 1 (first)
+ * ctx.meta.all(priority).store;       // [1, 2] (all)
+ * ```
+ *
+ * @example Field-level meta
+ * ```ts
+ * const validate = meta((rule: string) => rule);
+ *
+ * const formStore = store({
+ *   state: { email: "", age: 0 },
+ *   meta: [
+ *     validate.for("email", "email-format"),
+ *     validate.for("age", "positive-number"),
+ *   ],
+ * });
+ *
+ * formStore.meta(validate).fields.email;  // "email-format"
+ * formStore.meta(validate).fields.age;    // "positive-number"
+ * ```
+ *
+ * @example Check meta existence
+ * ```ts
+ * const persist = meta();
+ * const sync = meta();
+ *
+ * userStore.meta.any(persist);        // true
+ * userStore.meta.any(sync);           // false
+ * userStore.meta.any(persist, sync);  // true (has at least one)
+ * ```
+ *
+ * @param builder - Optional function to transform arguments into meta value.
+ *                  If omitted, meta value defaults to `true`.
+ * @returns A MetaType that creates MetaEntry objects
+ */
+export declare function meta(): MetaType<any, [], true>;
+export declare function meta<TValue, TArgs extends any[]>(builder: (...args: TArgs) => TValue): MetaType<any, TArgs, TValue>;
+//# sourceMappingURL=meta.d.ts.map

package/dist/meta/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/meta/meta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,UAAU,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,IAAI,IAAI,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;AAChD,wBAAgB,IAAI,CAAC,MAAM,EAAE,KAAK,SAAS,GAAG,EAAE,EAC9C,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,MAAM,GAClC,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC"}

package/dist/meta/withMeta.d.ts

@@ -0,0 +1,48 @@
+import { Factory, MetaEntry } from '../types';
+
+/**
+ * Attach metadata to a service or factory function.
+ *
+ * This allows middleware to access meta information for any factory,
+ * not just stores. Meta is queried via `ctx.meta` in middleware context.
+ *
+ * @example Basic usage
+ * ```ts
+ * const persist = meta();
+ * const priority = meta((level: number) => level);
+ *
+ * // Attach meta to a service factory
+ * const apiService = withMeta(
+ *   (resolver) => ({ fetch: () => {} }),
+ *   [persist(), priority(1)]
+ * );
+ *
+ * // In middleware, query via ctx.meta
+ * const middleware: Middleware = (ctx) => {
+ *   if (ctx.meta.any(persist)) {
+ *     console.log("This factory should be persisted");
+ *   }
+ *   return ctx.next();
+ * };
+ * ```
+ *
+ * @example Combined with store meta
+ * ```ts
+ * // Factory meta and store spec meta are merged in ctx.meta
+ * const userStore = store({
+ *   name: "user",
+ *   state: { name: "" },
+ *   meta: [persist()], // spec meta
+ * });
+ *
+ * // In middleware, ctx.meta includes both factory.meta and spec.meta
+ * ```
+ *
+ * @param factory - The factory function to attach meta to
+ * @param meta - Single MetaEntry or array of MetaEntry
+ * @returns The same factory function with `.meta` property attached
+ */
+export declare function withMeta<TFactory extends Factory, TField extends ReturnType<TFactory> extends object ? keyof ReturnType<TFactory> : any>(factory: TFactory, meta: MetaEntry<TField, any> | MetaEntry<TField, any>[]): TFactory & {
+    meta: MetaEntry<TField, any>[];
+};
+//# sourceMappingURL=withMeta.d.ts.map

package/dist/meta/withMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withMeta.d.ts","sourceRoot":"","sources":["../../src/meta/withMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,SAAS,OAAO,EACxB,MAAM,SAAS,UAAU,CAAC,QAAQ,CAAC,SAAS,MAAM,GAC9C,MAAM,UAAU,CAAC,QAAQ,CAAC,GAC1B,GAAG,EAEP,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GACtD,QAAQ,GAAG;IACZ,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;CAChC,CAIA"}

package/dist/meta-u3yOx5Kh.js

@@ -0,0 +1,29 @@
+function meta(builder) {
+  const metaType = Object.assign(
+    // Store-level meta: myMeta(...args)
+    (...args) => {
+      return {
+        fields: void 0,
+        value: (builder == null ? void 0 : builder(...args)) ?? true,
+        type: metaType
+        // reference the MetaType itself
+      };
+    },
+    {
+      // Field-level meta: myMeta.for("fieldName", ...args) or myMeta.for(["f1", "f2"], ...args)
+      for(fieldOrFields, ...args) {
+        const fields = Array.isArray(fieldOrFields) ? fieldOrFields : [fieldOrFields];
+        return {
+          fields,
+          value: (builder == null ? void 0 : builder(...args)) ?? true,
+          type: metaType
+          // reference the MetaType itself
+        };
+      }
+    }
+  );
+  return metaType;
+}
+export {
+  meta as m
+};

package/dist/persist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Storion Persist Module
+ *
+ * Provides middleware for persisting store state to external storage.
+ *
+ * @packageDocumentation
+ */
+export { persistMiddleware, notPersisted, type PersistOptions, type PersistLoadResult, } from './persist';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/persist/index.js

@@ -0,0 +1,70 @@
+import { m as meta } from "../meta-u3yOx5Kh.js";
+import { i as isPromiseLike } from "../isPromiseLike-bFkfHAbm.js";
+const notPersisted = meta();
+function persistMiddleware(options) {
+  const { filter, load, save, onError, force = false } = options;
+  return ({ spec, next, meta: meta2 }) => {
+    const instance = next();
+    if (filter && !filter(spec)) {
+      return instance;
+    }
+    const notPersistedInfo = meta2(notPersisted);
+    if (notPersistedInfo.store === true) {
+      return instance;
+    }
+    const excludedFields = new Set(
+      Object.keys(notPersistedInfo.fields).filter(
+        (field) => notPersistedInfo.fields[field] === true
+      )
+    );
+    const filterState = (state) => {
+      if (excludedFields.size === 0) return state;
+      const filtered = {};
+      for (const key in state) {
+        if (!excludedFields.has(key)) {
+          filtered[key] = state[key];
+        }
+      }
+      return filtered;
+    };
+    const hydrateWithState = (state) => {
+      if (state != null) {
+        try {
+          instance.hydrate(filterState(state), { force });
+        } catch (error) {
+          onError == null ? void 0 : onError(spec, error, "load");
+        }
+      }
+    };
+    try {
+      const loadResult = load == null ? void 0 : load(spec);
+      if (loadResult) {
+        if (isPromiseLike(loadResult)) {
+          loadResult.then(
+            (state) => hydrateWithState(state),
+            (error) => onError == null ? void 0 : onError(spec, error, "load")
+          );
+        } else {
+          hydrateWithState(loadResult);
+        }
+      }
+    } catch (error) {
+      onError == null ? void 0 : onError(spec, error, "load");
+    }
+    if (save) {
+      instance.subscribe(() => {
+        try {
+          const state = instance.dehydrate();
+          save(spec, filterState(state));
+        } catch (error) {
+          onError == null ? void 0 : onError(spec, error, "save");
+        }
+      });
+    }
+    return instance;
+  };
+}
+export {
+  notPersisted,
+  persistMiddleware
+};

package/dist/persist/persist.d.ts

@@ -0,0 +1,128 @@
+import { StoreSpec, StoreMiddleware } from '../types';
+
+/**
+ * Mark stores or fields as not persisted.
+ *
+ * When called without arguments, marks the entire store as not persisted.
+ * When called with a field name, marks that specific field as not persisted.
+ *
+ * @example Store-level exclusion
+ * ```ts
+ * import { notPersisted } from 'storion/persist';
+ *
+ * const tempStore = store({
+ *   name: 'temp',
+ *   state: { sessionData: {} },
+ *   setup: () => ({}),
+ *   meta: [notPersisted()],  // entire store skipped
+ * });
+ * ```
+ *
+ * @example Field-level exclusion
+ * ```ts
+ * import { notPersisted } from 'storion/persist';
+ *
+ * const userStore = store({
+ *   name: 'user',
+ *   state: { name: '', password: '', token: '' },
+ *   setup: () => ({}),
+ *   meta: [
+ *     notPersisted('password'),
+ *     notPersisted('token'),
+ *   ],
+ * });
+ * ```
+ */
+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>;
+/**
+ * Options for persist middleware
+ */
+export interface PersistOptions {
+    /**
+     * Filter which stores should be persisted.
+     * If not provided, all stores are persisted.
+     *
+     * @param spec - The store specification
+     * @returns true to persist, false to skip
+     */
+    filter?: (spec: StoreSpec) => boolean;
+    /**
+     * Load persisted state for a store.
+     * Can return sync or async result.
+     *
+     * @param spec - The store specification
+     * @returns The persisted state, null/undefined if not found, or a Promise
+     */
+    load?: (spec: StoreSpec) => PersistLoadResult;
+    /**
+     * Save state to persistent storage.
+     *
+     * @param spec - The store specification
+     * @param state - The dehydrated state to save
+     */
+    save?: (spec: StoreSpec, state: Record<string, unknown>) => void;
+    /**
+     * Called when an error occurs during load or save.
+     *
+     * @param spec - The store specification
+     * @param error - The error that occurred
+     * @param operation - Whether the error occurred during 'load' or 'save'
+     */
+    onError?: (spec: StoreSpec, error: unknown, operation: "load" | "save") => void;
+    /**
+     * Force hydration to overwrite dirty (modified) state properties.
+     *
+     * By default (false), hydrate() skips properties that have been modified
+     * since initialization to avoid overwriting fresh data with stale persisted data.
+     *
+     * Set to true to always apply persisted data regardless of dirty state.
+     *
+     * @default false
+     */
+    force?: boolean;
+}
+/**
+ * Creates a persist middleware that automatically saves and restores store state.
+ *
+ * @example
+ * ```ts
+ * import { container } from "storion";
+ * import { persistMiddleware } from "storion/persist";
+ *
+ * const app = container({
+ *   middleware: persistMiddleware({
+ *     load: (spec) => {
+ *       const key = `storion:${spec.displayName}`;
+ *       const data = localStorage.getItem(key);
+ *       return data ? JSON.parse(data) : null;
+ *     },
+ *     save: (spec, state) => {
+ *       const key = `storion:${spec.displayName}`;
+ *       localStorage.setItem(key, JSON.stringify(state));
+ *     },
+ *     onError: (spec, error, op) => {
+ *       console.error(`Persist ${op} error for ${spec.displayName}:`, error);
+ *     },
+ *   }),
+ * });
+ * ```
+ *
+ * @example Async load (e.g., IndexedDB)
+ * ```ts
+ * persistMiddleware({
+ *   load: async (spec) => {
+ *     const db = await openDB();
+ *     return db.get('stores', spec.displayName);
+ *   },
+ *   save: (spec, state) => {
+ *     openDB().then(db => db.put('stores', state, spec.displayName));
+ *   },
+ * });
+ * ```
+ */
+export declare function persistMiddleware(options: PersistOptions): StoreMiddleware;
+//# sourceMappingURL=persist.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../src/persist/persist.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAI3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC;IAEtC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,iBAAiB,CAAC;IAE9C;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAEjE;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CACR,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAAG,MAAM,KACvB,IAAI,CAAC;IAEV;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAmG1E"}

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

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/react/context.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,EAAE,EAGR,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAU/C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,kBAAkB,CAShD,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,IAAI,cAAc,CAO7C"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/react/context.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,EAAE,EAIR,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAU/C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,kBAAkB,CAoBhD,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,IAAI,cAAc,CAO7C"}

package/dist/react/create.d.ts

@@ -1,4 +1,5 @@
-import { StateBase, ActionsBase, StoreOptions, StoreInstance, StableResult } from '../types';
+import { StateBase, ActionsBase, StoreOptions, StoreInstance, StableResult, ContainerOptions } from '../types';
+import { BoundWithStore } from './withStore';
 
 /**
  * Selector for create() hook.
@@ -9,19 +10,30 @@ export type CreateSelector<TState extends StateBase, TActions extends ActionsBas
  * Custom hook returned by create().
  */
 export type UseCreatedStore<TState extends StateBase, TActions extends ActionsBase> = <T extends object>(selector: CreateSelector<TState, TActions, T>) => StableResult<T>;
+/**
+ * Context type for withStore hooks created by create().
+ * Receives [state, actions] tuple directly.
+ */
+export type CreatedStoreContext<TState extends StateBase, TActions extends ActionsBase> = readonly [Readonly<TState>, TActions];
+/**
+ * WithStore function bound to a specific store created by create().
+ * Hook receives [state, actions] tuple directly instead of SelectorContext.
+ */
+export type WithCreatedStore<TState extends StateBase, TActions extends ActionsBase> = BoundWithStore<CreatedStoreContext<TState, TActions>>;
 /**
  * Result of create() call.
  */
 export type CreateResult<TState extends StateBase, TActions extends ActionsBase> = readonly [
     StoreInstance<TState, TActions>,
-    UseCreatedStore<TState, TActions>
+    UseCreatedStore<TState, TActions>,
+    WithCreatedStore<TState, TActions>
 ];
 /**
- * Create a store instance and custom hook for single-store apps.
+ * Create a store instance, custom hook, and bound withStore for single-store apps.
  *
  * @example
  * ```ts
- * const [counter, useCounter] = create({
+ * const [counter, useCounter, withCounter] = create({
  *   state: { count: 0 },
  *   setup({ state }) {
  *     return {
@@ -44,10 +56,28 @@ export type CreateResult<TState extends StateBase, TActions extends ActionsBase>
  *
  *   return <button onClick={increment}>{count}</button>;
  * }
+ *
+ * // Use withStore for separation of concerns
+ * const CounterDisplay = withCounter(
+ *   ([state, actions], props: { multiplier: number }) => ({
+ *     count: state.count * props.multiplier,
+ *     increment: actions.increment,
+ *   }),
+ *   ({ count, increment }) => (
+ *     <button onClick={increment}>{count}</button>
+ *   )
+ * );
+ *
+ * // HOC mode
+ * const withCounterData = withCounter(([state]) => ({
+ *   count: state.count,
+ * }));
+ * const DisplayValue = withCounterData(({ count }) => <span>{count}</span>);
  * ```
  *
- * @param options - Store options (state, setup, etc.)
- * @returns Tuple of [instance, hook]
+ * @param storeOptions - Store options (state, setup, etc.)
+ * @param containerOptions - Optional container options (middleware, etc.)
+ * @returns Tuple of [instance, hook, withStore]
  */
-export declare function create<TState extends StateBase, TActions extends ActionsBase>(options: StoreOptions<TState, TActions>): CreateResult<TState, TActions>;
+export declare function create<TState extends StateBase, TActions extends ActionsBase>(storeOptions: StoreOptions<TState, TActions>, containerOptions?: ContainerOptions): CreateResult<TState, TActions>;
 //# sourceMappingURL=create.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/react/create.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,YAAY,EACZ,aAAa,EAEb,YAAY,EACb,MAAM,UAAU,CAAC;AAKlB;;;GAGG;AACH,MAAM,MAAM,cAAc,CACxB,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,EAC5B,CAAC,IACC,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,KAAK,CAAC,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,eAAe,CACzB,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,IAC1B,CAAC,CAAC,SAAS,MAAM,EACnB,QAAQ,EAAE,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,KAC1C,YAAY,CAAC,CAAC,CAAC,CAAC;AAErB;;GAEG;AACH,MAAM,MAAM,YAAY,CACtB,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,IAC1B,SAAS;IACX,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC/B,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,SAAS,EAAE,QAAQ,SAAS,WAAW,EAC3E,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,GACtC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAsBhC"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/react/create.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAIlB,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,MAAM,MAAM,cAAc,CACxB,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,EAC5B,CAAC,IACC,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,KAAK,CAAC,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,eAAe,CACzB,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,IAC1B,CAAC,CAAC,SAAS,MAAM,EACnB,QAAQ,EAAE,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,KAC1C,YAAY,CAAC,CAAC,CAAC,CAAC;AAErB;;;GAGG;AACH,MAAM,MAAM,mBAAmB,CAC7B,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,IAC1B,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;AAE1C;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAC1B,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,IAC1B,cAAc,CAAC,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,YAAY,CACtB,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,IAC1B,SAAS;IACX,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC/B,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC;IACjC,gBAAgB,CAAC,MAAM,EAAE,QAAQ,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,SAAS,EAAE,QAAQ,SAAS,WAAW,EAC3E,YAAY,EAAE,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC5C,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAqChC"}

package/dist/react/index.d.ts

@@ -6,7 +6,7 @@
 export { StoreProvider, useContainer } from './context';
 export { useStore } from './useStore';
 export { type LocalStoreResult } from './useLocalStore';
-export { withStore, type WithStoreHook, type WithStoreRender, type WithStoreRenderWithRef, type WithStoreOptions, } from './withStore';
-export { create, type CreateSelector, type UseCreatedStore, type CreateResult, } from './create';
+export { withStore, createWithStore, type WithStoreHook, type WithStoreRender, type WithStoreRenderWithRef, type WithStoreOptions, type BoundWithStore, type GenericWithStoreHook, type UseContextHook, } from './withStore';
+export { create, type CreateSelector, type UseCreatedStore, type CreateResult, type CreatedStoreContext, type WithCreatedStore, } from './create';
 export * from '../index';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAGxD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,SAAS,EACT,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,GACtB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,MAAM,EACN,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,GAClB,MAAM,UAAU,CAAC;AAGlB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAGxD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,SAAS,EACT,eAAe,EACf,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,cAAc,GACpB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,MAAM,EACN,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC;AAGlB,cAAc,UAAU,CAAC"}