@umituz/react-native-storage 2.4.5 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-storage",
-  "version": "2.4.5",
+  "version": "2.5.0",
   "description": "Zustand state management with AsyncStorage persistence and type-safe storage operations for React Native",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domain/factories/StoreFactory.ts

@@ -1,6 +1,19 @@
 /**
  * Store Factory
- * Create Zustand stores with AsyncStorage persistence
+ * Create Zustand stores with AsyncStorage persistence and actions
+ *
+ * @example
+ * ```typescript
+ * const useCounterStore = createStore({
+ *   name: 'counter',
+ *   initialState: { count: 0 },
+ *   actions: (set, get) => ({
+ *     increment: () => set({ count: get().count + 1 }),
+ *     reset: () => set({ count: 0 }),
+ *   }),
+ *   persist: true,
+ * });
+ * ```
  */
 
 import { create } from 'zustand';
@@ -8,26 +21,51 @@ import { persist, createJSONStorage } from 'zustand/middleware';
 import type { StoreConfig } from '../types/Store';
 import { storageService } from '../../infrastructure/adapters/StorageService';
 
-export function createStore<T extends object>(config: StoreConfig<T>) {
+/**
+ * Create a Zustand store with optional persistence and actions
+ */
+export function createStore<
+  TState extends object,
+  TActions extends object = object
+>(config: StoreConfig<TState, TActions>) {
+  type Store = TState & TActions;
+
+  const stateCreator = (
+    set: (partial: Partial<Store>) => void,
+    get: () => Store
+  ): Store => {
+    const state = config.initialState as Store;
+    const actions = config.actions ? config.actions(set as any, get as any) : ({} as TActions);
+    return { ...state, ...actions };
+  };
+
   if (!config.persist) {
-    return create<T>(() => config.initialState);
+    return create<Store>(stateCreator);
   }
 
-  return create<T>()(
-    persist(
-      () => config.initialState,
-      {
-        name: config.name,
-        storage: createJSONStorage(() => storageService),
-        version: config.version || 1,
-        partialize: config.partialize,
-        onRehydrateStorage: () => (state) => {
-          if (state && config.onRehydrate) {
-            config.onRehydrate(state);
-          }
-        },
-        migrate: config.migrate as any,
-      }
-    )
+  return create<Store>()(
+    persist(stateCreator, {
+      name: config.name,
+      storage: createJSONStorage(() => storageService),
+      version: config.version || 1,
+      partialize: config.partialize
+        ? (state) => config.partialize!(state) as Store
+        : (state) => {
+            // By default, exclude functions (actions) from persistence
+            const persisted: Record<string, unknown> = {};
+            for (const key of Object.keys(state)) {
+              if (typeof state[key as keyof Store] !== 'function') {
+                persisted[key] = state[key as keyof Store];
+              }
+            }
+            return persisted as Store;
+          },
+      onRehydrateStorage: () => (state) => {
+        if (state && config.onRehydrate) {
+          config.onRehydrate(state);
+        }
+      },
+      migrate: config.migrate as any,
+    })
   );
 }

package/src/domain/types/Store.ts

@@ -1,17 +1,43 @@
 /**
  * Store Types
+ * Zustand store configuration with actions support
  */
 
-export interface StoreConfig<T> {
+import type { StoreApi } from 'zustand';
+
+/** Set function type for Zustand */
+export type SetState<T> = StoreApi<T>['setState'];
+
+/** Get function type for Zustand */
+export type GetState<T> = StoreApi<T>['getState'];
+
+/** Actions creator function */
+export type ActionsCreator<TState, TActions> = (
+  set: SetState<TState & TActions>,
+  get: GetState<TState & TActions>
+) => TActions;
+
+/** Store configuration */
+export interface StoreConfig<TState extends object, TActions extends object = object> {
+  /** Unique store name (used as storage key) */
   name: string;
-  initialState: T;
+  /** Initial state */
+  initialState: TState;
+  /** Actions creator function */
+  actions?: ActionsCreator<TState, TActions>;
+  /** Enable AsyncStorage persistence */
   persist?: boolean;
+  /** State version for migrations */
   version?: number;
-  partialize?: (state: T) => Partial<T>;
-  onRehydrate?: (state: T) => void;
-  migrate?: (persistedState: unknown, version: number) => T;
+  /** Select which state to persist */
+  partialize?: (state: TState & TActions) => Partial<TState>;
+  /** Callback after rehydration */
+  onRehydrate?: (state: TState & TActions) => void;
+  /** Migration function for version changes */
+  migrate?: (persistedState: unknown, version: number) => TState;
 }
 
+/** Persisted state wrapper */
 export interface PersistedState<T> {
   state: T;
   version: number;

package/src/index.ts

@@ -88,7 +88,13 @@ export { isDev, devWarn, devError, devLog } from './domain/utils/devUtils';
 // DOMAIN LAYER - Store Types
 // =============================================================================
 
-export type { StoreConfig, PersistedState } from './domain/types/Store';
+export type {
+  StoreConfig,
+  PersistedState,
+  SetState,
+  GetState,
+  ActionsCreator,
+} from './domain/types/Store';
 
 // =============================================================================
 // DOMAIN LAYER - Store Factory