define-zustand 3.5.0 → 4.0.0

package/README.md

@@ -22,10 +22,10 @@ const useStore = defineStore({
         a: 1,
         b: 1
     }),
-    action: () => ({}),
     getter: {
         count: state => state.a + state.b
-    }
+    },
+    action: () => ({}),
 })
 
 // Use defineModelFactory
@@ -34,10 +34,10 @@ const stateFactory = defineStateFactory({
         a: 1,
         b: 1
     }),
-    action: () => ({}),
     getter: {
         count: state => state.a + state.b
-    }
+    },
+    action: () => ({}),
 })
 const useStore = defineStore(stateFactory())
 const { Provider, useContext } = defineContext(stateFactory())

package/dist/define.d.ts

@@ -1,10 +1,22 @@
 import { FunctionComponent, ReactNode } from 'react';
-import { gettersStateType, optionsType } from './types';
-export declare function defineStateFactory<S extends Record<string, any>, G extends gettersStateType<S>, Actions extends Record<string, any>>(options: optionsType<S, G, Actions>): () => optionsType<S, G, Actions>;
-export declare function defineStore<S extends Record<string, any>, G extends gettersStateType<S>, Actions extends Record<string, any>>(options: optionsType<S, G, Actions>): import("zustand").UseBoundStore<import("zustand").StoreApi<import("./types").modelStateType<S, G, Actions>>>;
-export declare function defineContext<S extends Record<string, any>, G extends gettersStateType<S>, Actions extends Record<string, any>>(options: optionsType<S, G, Actions>): {
+import { Options } from './types';
+export declare function defineStateFactory<S extends Record<string, any>, G extends Record<string, any>, Actions extends Record<string, any>>(options: Options<S, G, Actions>): () => Options<S, G, Actions>;
+export declare function defineStore<S extends Record<string, any>, G extends Record<string, any>, Actions extends Record<string, any>>(options: Options<S, G, Actions>): import("zustand").UseBoundStore<import("zustand").StoreApi<import("./types").ModelState<S, G, Actions>>>;
+export declare function defineQuery<F extends (params: any) => any>(options: {
+    queryFn: F;
+    params: Parameters<F>[0];
+}): import("zustand").UseBoundStore<import("zustand").StoreApi<import("./types").ModelState<{
+    params: Parameters<F>[0];
+    loading: boolean;
+    data: Awaited<ReturnType<F>> | undefined;
+    error: Error | undefined;
+}, {}, {
+    fetchData: F;
+    refetch: (params?: Partial<Parameters<F>[0]> | undefined) => Promise<void>;
+}>>>;
+export declare function defineContext<S extends Record<string, any>, G extends Record<string, any>, Actions extends Record<string, any>>(options: Options<S, G, Actions>): {
     Provider: FunctionComponent<{
         children?: ReactNode;
     } & Partial<S>>;
-    useContext: <T>(selector: (state: import("./types").modelStateType<S, G, Actions>) => T) => T;
+    useContext: <T>(selector: (state: import("./types").ModelState<S, G, Actions>) => T) => T;
 };

package/dist/define.js

@@ -9,6 +9,56 @@ function defineStateFactory(options) {
 function defineStore(options) {
   return create(storeMiddleware(options));
 }
+function defineQuery(options) {
+  return defineStore({
+    state: () => ({
+      params: options.params,
+      loading: false,
+      data: void 0,
+      error: void 0
+    }),
+    getters: () => ({}),
+    actions: (setState, getState) => {
+      async function fetchData(params) {
+        try {
+          const state = getState();
+          setState(state => {
+            state.loading = true;
+          });
+          const newParams = {
+            ...state.params,
+            ...params
+          };
+          const data = await options.queryFn(newParams);
+          setState(state => {
+            state.data = data;
+            state.params = newParams;
+          });
+          return data;
+        } catch (error) {
+          setState(state => {
+            state.error = new Error(error.message);
+          });
+        } finally {
+          setState(state => {
+            state.loading = false;
+          });
+        }
+      }
+      async function refetch(params) {
+        const state = getState();
+        await options.queryFn({
+          ...state.params,
+          ...params
+        });
+      }
+      return {
+        fetchData: fetchData,
+        refetch
+      };
+    }
+  });
+}
 function defineContext(options) {
   const creatorResult = storeMiddleware(options);
   const $createStore = () => createStore()(creatorResult);
@@ -38,4 +88,4 @@ function defineContext(options) {
   };
 }
 
-export { defineContext, defineStateFactory, defineStore };
+export { defineContext, defineQuery, defineStateFactory, defineStore };

package/dist/index.js

@@ -1,2 +1,2 @@
 export { storeMiddleware } from './store-middleware.js';
-export { defineContext, defineStateFactory, defineStore } from './define.js';
+export { defineContext, defineQuery, defineStateFactory, defineStore } from './define.js';

package/dist/store-middleware.d.ts

@@ -1,3 +1,3 @@
 import { StateCreator } from 'zustand';
-import { gettersStateType, optionsType, modelStateType } from './types';
-export declare function storeMiddleware<S extends Record<string, any>, G extends gettersStateType<S>, Actions extends Record<string, any>>(options: optionsType<S, G, Actions>): StateCreator<modelStateType<S, G, Actions>>;
+import { Options, ModelState } from './types';
+export declare function storeMiddleware<S extends Record<string, any>, G extends Record<string, any>, Actions extends Record<string, any>>(options: Options<S, G, Actions>): StateCreator<ModelState<S, G, Actions>>;

package/dist/store-middleware.js

@@ -4,8 +4,8 @@ import { forOwn, keys, pick, isEqualWith, some, isEqual } from 'lodash-es';
 function storeMiddleware(options) {
   return (set, get, store) => {
     const state = options.state();
-    forOwn(options.getters, (getter, k) => {
-      state[k] = getter(state);
+    forOwn(options.getters(state), (getter, k) => {
+      state[k] = getter;
     });
     // getterListener
     // ----------------------------------------------------------------------
@@ -16,12 +16,11 @@ function storeMiddleware(options) {
       const isUpdate = isEqualWith(normalState, pick(prevState, normalStateKeys), (current, prev) => some(current, (v, k) => v !== prev[k]));
       if (isUpdate) {
         const newGetterState = pick(state, getterKeys);
-        forOwn(options.getters, (getter, k) => {
-          const current = getter(normalState);
-          if (isEqual(newGetterState[k], current)) {
+        forOwn(options.getters(normalState), (getterState, k) => {
+          if (isEqual(newGetterState[k], getterState)) {
             return;
           }
-          newGetterState[k] = current;
+          newGetterState[k] = getterState;
         });
         set(newGetterState);
       }

package/dist/test.stories.d.ts

@@ -1,4 +1,4 @@
-import type { Meta, StoryObj } from '@storybook/react';
+import type { Meta, StoryObj } from '@storybook/react-vite';
 declare const meta: Meta;
 export default meta;
 type Story = StoryObj;

package/dist/types.d.ts

@@ -1,22 +1,18 @@
 import { StoreApi as ZStoreApi, ExtractState as ZExtractState } from 'zustand';
-export type gettersStateType<S> = Record<string, (state: S) => any>;
-export type ExtraGettersState<G extends gettersStateType<any>> = {
-    [key in keyof G]: ReturnType<G[key]>;
-};
-export type stateType<S, G extends gettersStateType<any>> = S & ExtraGettersState<G>;
+export type State<S, G> = S & G;
 export type StoreApi<S> = Omit<ZStoreApi<S>, 'setState'> & {
     setState: (updater: ((state: S) => void) | Partial<S>, replace?: boolean) => void;
 };
 export type ExtractState<S> = ZExtractState<S>;
-export interface insideActionsType<S> {
+export interface InsideActions<S> {
     reset: () => void;
     setState: StoreApi<S>['setState'];
     subscribe: StoreApi<S>['subscribe'];
 }
-export type actionsType<S, G extends gettersStateType<any>, OptionAction> = (setState: insideActionsType<S>['setState'], getState: () => stateType<S, G> & insideActionsType<S>, store: StoreApi<S>) => OptionAction;
-export interface optionsType<S, G extends gettersStateType<any>, Actions> {
+export type Actions<S, G, OptionAction> = (setState: InsideActions<S>['setState'], getState: () => State<S, G> & InsideActions<S>, store: StoreApi<S>) => OptionAction;
+export interface Options<S, G, A> {
     state: () => S;
-    getters: G;
-    actions: actionsType<S, G, Actions>;
+    getters: (state: S) => G;
+    actions: Actions<S, G, A>;
 }
-export type modelStateType<S, G extends gettersStateType<any>, Actions> = stateType<S, G> & Actions & insideActionsType<S>;
+export type ModelState<S, G, A> = State<S, G> & A & InsideActions<S>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "define-zustand",
-  "version": "3.5.0",
+  "version": "4.0.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",