rxtutils 1.1.2-beta.2 → 1.1.2-beta.20

package/README.md

@@ -17,6 +17,7 @@ pnpm add rxtutils
 - **缓存管理** - 支持内存、localStorage、sessionStorage 和 IndexedDB 多种存储方式
 - **HTTP 请求** - 基于 axios 的请求封装，支持错误处理和缓存
 - **状态管理** - 轻量级的状态管理解决方案，支持 React Hook
+- **数据验证** - 基于装饰器的数据验证系统，支持多种验证规则
 - **TypeScript** - 完整的 TypeScript 类型支持
 
 ## 📚 模块介绍
@@ -198,7 +199,149 @@ const currentUser = userStore.get();
 userStore.set({ name: 'Jane Doe', email: 'jane@example.com', isLoggedIn: true });
 ```
 
-### 4. 状态计算器 (createStoreGetter)
+### 4. 数据验证 (Validator)
+
+基于装饰器的数据验证系统，提供多种验证规则和自定义验证能力。
+
+#### 基本用法
+
+```typescript
+import { BaseValidator, VString, VNumber, VRequired, VEmail, VMinLength } from 'rxtutils';
+
+// 创建验证模型
+class User extends BaseValidator {
+  @VString('用户名必须为字符串')
+  @(VRequired()('用户名不能为空'))
+  name?: string;
+
+  @VNumber('年龄必须为数字')
+  @(VRequired()('年龄不能为空'))
+  age?: number;
+
+  @VEmail('邮箱格式不正确')
+  @(VRequired()('邮箱不能为空'))
+  email?: string;
+
+  @(VMinLength(6)('密码长度不能少于6位'))
+  @(VRequired()('密码不能为空'))
+  password?: string;
+}
+
+// 使用验证
+const user = new User();
+user.name = '张三';
+user.age = 25;
+user.email = 'invalid-email'; // 无效的邮箱格式
+user.password = '123'; // 密码长度不足
+
+// 验证单个字段
+const emailErrors = user.validate('email');
+console.log(emailErrors); // [{ status: false, message: '邮箱格式不正确' }]
+
+// 验证所有字段
+const allErrors = user.validateAll();
+console.log(allErrors); // 返回所有验证错误
+```
+
+#### 内置验证装饰器
+
+```typescript
+// 基本类型验证
+@VString('必须为字符串')
+@VNumber('必须为数字')
+@VBoolean('必须为布尔值')
+@VArray('必须为数组')
+
+// 必填验证
+@(VRequired()('不能为空'))
+
+// 范围验证
+@(VMin(18)('必须大于等于18'))
+@(VMax(100)('必须小于等于100'))
+
+// 长度验证
+@(VMinLength(6)('长度不能少于6位'))
+@(VMaxLength(20)('长度不能超过20位'))
+
+// 格式验证
+@VEmail('邮箱格式不正确')
+@(VPattern(/^1[3-9]\d{9}$/)('手机号格式不正确'))
+```
+
+#### 自定义验证装饰器
+
+```typescript
+import { BaseValidator } from 'rxtutils';
+
+// 创建自定义验证装饰器
+const VCustom = BaseValidator.decoratorCreator(
+  (val) => {
+    // 自定义验证逻辑
+    return typeof val === 'string' && val.startsWith('custom-');
+  }
+);
+
+// 使用自定义验证装饰器
+class Product extends BaseValidator {
+  @VCustom('产品编码必须以 custom- 开头')
+  code?: string;
+}
+```
+
+#### 验证方法
+
+BaseValidator 类提供了两个主要的验证方法：
+
+```typescript
+// 验证单个字段
+validate(itemKey: string, itemAll: boolean = false): { status: boolean; message?: string }[] | null;
+
+// 验证多个或所有字段
+validateAll(itemAll: boolean = false, everyItem: boolean = false, order?: string[]): { status: boolean; message?: string }[] | null;
+```
+
+参数说明：
+
+- `itemKey`: 要验证的字段名
+- `itemAll`: 是否验证该字段的所有规则，为 true 时会验证所有规则，为 false 时遇到第一个失败的规则就停止
+- `everyItem`: 是否验证所有字段，为 true 时会验证所有字段，为 false 时遇到第一个失败的字段就停止
+- `order`: 验证字段的顺序，可以指定验证的字段名数组及其顺序
+
+使用示例：
+
+```typescript
+// 创建验证模型
+class LoginForm extends BaseValidator {
+  @VString('用户名必须为字符串')
+  @(VRequired()('用户名不能为空'))
+  @(VMinLength(3)('用户名长度不能少于3位'))
+  @(VMaxLength(20)('用户名长度不能超过20位'))
+  username?: string;
+
+  @(VRequired()('密码不能为空'))
+  @(VMinLength(6)('密码长度不能少于6位'))
+  password?: string;
+}
+
+const form = new LoginForm();
+form.username = 'ab'; // 长度不足
+form.password = '123456';
+
+// 验证单个字段的所有规则
+const usernameErrors = form.validate('username', true);
+console.log(usernameErrors); 
+// [{ status: false, message: '用户名长度不能少于3位' }]
+
+// 验证所有字段，每个字段遇到第一个错误就停止
+const allErrors = form.validateAll(false, true);
+console.log(allErrors);
+
+// 按指定顺序验证字段，并验证每个字段的所有规则
+const orderedErrors = form.validateAll(true, true, ['password', 'username']);
+console.log(orderedErrors);
+```
+
+### 5. 状态计算器 (createStoreGetter)
 
 为状态存储提供计算属性和派生状态。
 

package/{dist/cjs → cjs}/cache/index.cjs

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var tslib = require('tslib');
 var moment = require('moment');
 var indexDB = require('./indexDB.cjs');
-var defaultEquals = require('../defaultEquals.cjs');
+var defaultEquals = require('../_utils/defaultEquals.cjs');
 
 /** 存储类型映射表 */
 var StorageMap = {
@@ -18,8 +18,16 @@ var StorageMap = {
  * @template Data 缓存数据类型
  */
 var Cache = /** @class */ (function () {
+    /**
+     * 构造函数
+     * @param cacheType 存储类型
+     * @param cacheKey 缓存键名
+     * @param cacheTime 缓存时间（秒）
+     * @param indexDBName IndexedDB 数据库名称，默认值为 '__apiCacheDatabase__'
+     * @param cacheKeyEquals 缓存键比较函数，默认使用 defaultEquals
+     */
     function Cache(cacheType, cacheKey, cacheTime, indexDBName, cacheKeyEquals) {
-        if (indexDBName === void 0) { indexDBName = '__apiCacheDatabase__'; }
+        if (indexDBName === void 0) { indexDBName = "__apiCacheDatabase__"; }
         if (cacheKeyEquals === void 0) { cacheKeyEquals = defaultEquals; }
         /** 内存中的缓存数组 */
         this.cache = [];
@@ -30,10 +38,10 @@ var Cache = /** @class */ (function () {
             indexDBName: indexDBName,
             cacheKeyEquals: cacheKeyEquals,
         };
-        if (cacheType === 'indexedDB') {
-            this.storage = new indexDB.IndexedDBStorage(indexDBName, 'cacheStore');
+        if (cacheType === "indexedDB") {
+            this.storage = new indexDB.IndexedDBStorage(indexDBName, "cacheStore");
         }
-        else if (typeof cacheType === 'string') {
+        else if (typeof cacheType === "string") {
             this.storage = StorageMap[cacheType];
         }
         this._init();
@@ -55,15 +63,15 @@ var Cache = /** @class */ (function () {
                         _d = (_c = JSON).parse;
                         return [4 /*yield*/, this.storage.getItem(cacheKey)];
                     case 1:
-                        _b.cache = _d.apply(_c, [(_e.sent()) || '[]']);
+                        _b.cache = _d.apply(_c, [(_e.sent()) || "[]"]);
                         return [3 /*break*/, 3];
                     case 2:
                         if (this.storage instanceof Storage) {
                             this.storage = StorageMap[cacheType];
                             if (this.storage) {
-                                if (typeof cacheKey === 'string') {
+                                if (typeof cacheKey === "string") {
                                     try {
-                                        this.cache = JSON.parse(this.storage.getItem(cacheKey) || '[]');
+                                        this.cache = JSON.parse(this.storage.getItem(cacheKey) || "[]");
                                     }
                                     catch (e) {
                                         this.cache = [];
@@ -80,7 +88,8 @@ var Cache = /** @class */ (function () {
                 }
             });
         });
-    }; /**
+    };
+    /**
      * 过滤掉已过期的缓存项
      * 通过比较当前时间和过期时间，移除过期的缓存项
      * @private
@@ -90,18 +99,20 @@ var Cache = /** @class */ (function () {
             return moment(item.expireTime).isAfter(moment());
         });
         this.cache = newCache;
-    }; /**
+    };
+    /**
      * 将当前缓存数据保存到存储中
      * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
      * @private
      */
     Cache.prototype._saveToStorage = function () {
         if (this.storage) {
-            if (typeof this.cacheOptions.cacheKey === 'string') {
+            if (typeof this.cacheOptions.cacheKey === "string") {
                 this.storage.setItem(this.cacheOptions.cacheKey, JSON.stringify(this.cache));
             }
         }
-    }; /**
+    };
+    /**
      * 设置缓存数据
      * @param params 缓存的参数
      * @param data 要缓存的数据
@@ -118,10 +129,11 @@ var Cache = /** @class */ (function () {
         this.cache.push({
             params: params,
             data: data,
-            expireTime: moment().add(cacheTime, 'seconds').toJSON(),
+            expireTime: moment().add(cacheTime, "seconds").toJSON(),
         });
         this._saveToStorage();
-    }; /**
+    };
+    /**
      * 获取缓存数据
      * @param params 查询参数
      * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
@@ -142,7 +154,8 @@ var Cache = /** @class */ (function () {
             }
         }
         return null;
-    }; /**
+    };
+    /**
      * 清空所有缓存数据
      * 清空内存中的缓存数组并同步到存储中
      */

package/{dist/types → cjs}/cache/index.d.ts

@@ -6,7 +6,7 @@ import { IndexedDBStorage } from './indexDB.js';
  * - localStorage: 本地存储，永久保存
  * - indexedDB: IndexedDB 数据库存储
  */
-type StorageType = 'sessionStorage' | 'localStorage' | 'indexedDB';
+type StorageType = "sessionStorage" | "localStorage" | "indexedDB";
 /**
  * 缓存项接口定义
  * 定义了单个缓存项的数据结构
@@ -89,7 +89,8 @@ declare class Cache<Param, Data> {
     /** 缓存选项 */
     private cacheOptions;
     /** 存储实例 */
-    storage?: Storage | IndexedDBStorage; /**
+    storage?: Storage | IndexedDBStorage;
+    /**
      * 构造函数
      * @param cacheType 存储类型
      * @param cacheKey 缓存键名
@@ -103,28 +104,33 @@ declare class Cache<Param, Data> {
      * 从存储中加载已保存的缓存数据，并进行解析和过期处理
      * @private
      */
-    private _init; /**
+    private _init;
+    /**
      * 过滤掉已过期的缓存项
      * 通过比较当前时间和过期时间，移除过期的缓存项
      * @private
      */
-    private _filterExpired; /**
+    private _filterExpired;
+    /**
      * 将当前缓存数据保存到存储中
      * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
      * @private
      */
-    private _saveToStorage; /**
+    private _saveToStorage;
+    /**
      * 设置缓存数据
      * @param params 缓存的参数
      * @param data 要缓存的数据
      * @param cacheOptions 可选的缓存配置，可以覆盖默认的缓存时间
      */
-    setCache(params: Param, data: Data, cacheOptions?: Omit<ICacheOptions<Param>, 'storageType' | 'cacheKey' | 'cacheKeyEquals'>): void; /**
+    setCache(params: Param, data: Data, cacheOptions?: Omit<ICacheOptions<Param>, "storageType" | "cacheKey" | "cacheKeyEquals">): void;
+    /**
      * 获取缓存数据
      * @param params 查询参数
      * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
      */
-    getCache(params: Param): Data; /**
+    getCache(params: Param): Data;
+    /**
      * 清空所有缓存数据
      * 清空内存中的缓存数组并同步到存储中
      */

package/cjs/request/index.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+var tslib = require('tslib');
+var axios = require('axios');
+var at = require('lodash-es/at');
+var defaultHandlers = require('./defaultHandlers.cjs');
+var defaultEquals = require('../_utils/defaultEquals.cjs');
+var index = require('../cache/index.cjs');
+var error = require('./error.cjs');
+
+/**
+ * 创建基础请求实例
+ * @param baseOptions 基础配置选项
+ * @returns 请求创建函数
+ */
+function createBaseRequest(baseOptions) {
+    var baseURL = Object(baseOptions).baseURL;
+    // 创建新的 Axios 实例并配置基础URL和跨域凭证
+    var instance = axios.create({
+        baseURL: baseURL,
+        withCredentials: true,
+    });
+    /**
+     * 创建请求函数
+     * @template Param 请求参数类型
+     * @template Data 响应数据类型，必须是对象类型
+     * @param requestOptions 请求配置
+     * @param createOptions 创建选项（覆盖基础配置）
+     * @returns 发送请求的函数
+     */
+    return function createRequest(requestOptions, createOptions) {
+        var _a = tslib.__assign({}, requestOptions), method = _a.method, url = _a.url;
+        var _b = tslib.__assign(tslib.__assign({}, baseOptions), createOptions), baseURL = _b.baseURL, _c = _b.cacheDataKey, cacheDataKey = _c === void 0 ? "".concat(method, ":").concat(baseURL).concat(url) : _c, cacheDataInStorage = _b.cacheDataInStorage, _d = _b.cacheKeyEquals, cacheKeyEquals = _d === void 0 ? defaultEquals : _d, cacheTime = _b.cacheTime, _e = _b.indexDBName, indexDBName = _e === void 0 ? "__apiCacheDatabase__" : _e;
+        var cache = new index.default(cacheDataInStorage, cacheDataKey, cacheTime, indexDBName, cacheKeyEquals);
+        function request(requestParam, options) {
+            var _this = this;
+            var _a = tslib.__assign(tslib.__assign({}, requestOptions), requestParam), method = _a.method, url = _a.url, _b = _a.data, data = _b === void 0 ? {} : _b, _c = _a.params, params = _c === void 0 ? {} : _c;
+            var requestDataOrParams = params;
+            if (method.toLowerCase() === "post") {
+                requestDataOrParams = data;
+            }
+            var _d = tslib.__assign(tslib.__assign(tslib.__assign({}, baseOptions), createOptions), options).defaultMessageShower, defaultMessageShower = _d === void 0 ? console.error : _d;
+            var _e = tslib.__assign(tslib.__assign(tslib.__assign({}, baseOptions), createOptions), options), _f = _e.enableCache, enableCache = _f === void 0 ? false : _f, _g = _e.cacheData, cacheData = _g === void 0 ? false : _g, _h = _e.defaultErrorCodeHandler, defaultErrorCodeHandler = _h === void 0 ? defaultHandlers._defaultErrorCodeHandler.bind(null, defaultMessageShower) : _h, _j = _e.defaultHttpErrorCodeHandler, defaultHttpErrorCodeHandler = _j === void 0 ? defaultHandlers._defaultHttpErrorCodeHandler.bind(null, defaultMessageShower) : _j, _k = _e.otherErrorHandler, otherErrorHandler = _k === void 0 ? defaultHandlers._defaultOtherErrorCodeHandler.bind(null, defaultMessageShower) : _k, _l = _e.errorCodePath, errorCodePath = _l === void 0 ? "code" : _l, _m = _e.cacheTime, cacheTime = _m === void 0 ? 60 : _m, _o = _e.errorCodeMap, errorCodeMap = _o === void 0 ? {} : _o, _p = _e.successCodes, successCodes = _p === void 0 ? ["0", "200"] : _p, _q = _e.httpErrorCodeMap, httpErrorCodeMap = _q === void 0 ? {} : _q, _r = _e.axiosOptions, axiosOptions = _r === void 0 ? {} : _r, _s = _e.throwError, throwError = _s === void 0 ? true : _s;
+            if (enableCache) {
+                var cacheItem = cache.getCache(requestDataOrParams);
+                if (cacheItem) {
+                    return Promise.resolve(cacheItem);
+                }
+            }
+            return instance
+                .request(tslib.__assign({ method: method, url: url, data: data, params: params }, axiosOptions))
+                .then(function (res) { return tslib.__awaiter(_this, void 0, void 0, function () {
+                var errorCode, _a, _b, _c, customHandler, err, _d, _e, replaceResData, _f, handlerThrowError, _g;
+                return tslib.__generator(this, function (_h) {
+                    switch (_h.label) {
+                        case 0:
+                            errorCode = String(at(res.data, errorCodePath));
+                            if (successCodes.includes(errorCode)) {
+                                if (cacheData) {
+                                    cache.setCache(requestDataOrParams, res.data, { cacheTime: cacheTime });
+                                }
+                                return [2 /*return*/, res.data];
+                            }
+                            _a = errorCodeMap, _b = errorCode, _c = _a[_b], customHandler = _c === void 0 ? defaultErrorCodeHandler : _c;
+                            err = new error("服务端错误", "server", res);
+                            if (!(typeof customHandler === "string")) return [3 /*break*/, 1];
+                            defaultMessageShower(customHandler);
+                            return [3 /*break*/, 3];
+                        case 1:
+                            _g = Object;
+                            return [4 /*yield*/, customHandler(errorCode, res.data, res, tslib.__assign(tslib.__assign({}, requestOptions), requestParam))];
+                        case 2:
+                            _d = _g.apply(void 0, [(_h.sent())]), _e = _d.replaceResData, replaceResData = _e === void 0 ? res.data : _e, _f = _d.throwError, handlerThrowError = _f === void 0 ? "default" : _f;
+                            res.data = replaceResData;
+                            switch (handlerThrowError) {
+                                case true:
+                                    throw err;
+                                case false:
+                                    return [2 /*return*/, res.data];
+                            }
+                            _h.label = 3;
+                        case 3:
+                            if (throwError) {
+                                throw err;
+                            }
+                            return [2 /*return*/, res.data];
+                    }
+                });
+            }); }, function (error$1) { return tslib.__awaiter(_this, void 0, void 0, function () {
+                var resData, _a, _b, _c, customHandler, err, _d, _e, replaceResData, _f, handlerThrowError, _g, resData, err, _h, _j, replaceResData, _k, handlerThrowError, _l;
+                return tslib.__generator(this, function (_m) {
+                    switch (_m.label) {
+                        case 0:
+                            if (!error$1.response) return [3 /*break*/, 4];
+                            resData = error$1;
+                            _a = httpErrorCodeMap, _b = error$1.response.status, _c = _a[_b], customHandler = _c === void 0 ? defaultHttpErrorCodeHandler : _c;
+                            err = new error("服务端错误", "http", error$1);
+                            if (!(typeof customHandler === "string")) return [3 /*break*/, 1];
+                            defaultMessageShower(customHandler);
+                            return [3 /*break*/, 3];
+                        case 1:
+                            _g = Object;
+                            return [4 /*yield*/, customHandler(error$1.response.status, error$1, tslib.__assign(tslib.__assign({}, requestOptions), requestParam))];
+                        case 2:
+                            _d = _g.apply(void 0, [(_m.sent())]), _e = _d.replaceResData, replaceResData = _e === void 0 ? error$1 : _e, _f = _d.throwError, handlerThrowError = _f === void 0 ? "default" : _f;
+                            resData = replaceResData;
+                            switch (handlerThrowError) {
+                                case true:
+                                    throw err;
+                                case false:
+                                    return [2 /*return*/, resData];
+                            }
+                            _m.label = 3;
+                        case 3:
+                            if (throwError) {
+                                throw err;
+                            }
+                            return [2 /*return*/, resData];
+                        case 4:
+                            resData = error$1;
+                            err = new error("服务端错误", "http", error$1);
+                            err.type = "http";
+                            err.data = error$1;
+                            _l = Object;
+                            return [4 /*yield*/, otherErrorHandler(error$1)];
+                        case 5:
+                            _h = (_l.apply(void 0, [(_m.sent())])), _j = _h.replaceResData, replaceResData = _j === void 0 ? error$1 : _j, _k = _h.throwError, handlerThrowError = _k === void 0 ? "default" : _k;
+                            resData = replaceResData;
+                            switch (handlerThrowError) {
+                                case true:
+                                    throw err;
+                                case false:
+                                    return [2 /*return*/, resData];
+                            }
+                            if (throwError) {
+                                throw err;
+                            }
+                            return [2 /*return*/, resData];
+                    }
+                });
+            }); });
+        }
+        request.clearCache = function () {
+            cache.clear();
+        };
+        return request;
+    };
+}
+
+module.exports = createBaseRequest;

package/{dist/types → cjs}/request/index.d.ts

@@ -1,5 +1,6 @@
 import { AxiosResponse, Method, AxiosRequestConfig } from 'axios';
 import { StorageType } from '../cache/index.js';
+export { default as RequestError, RequestErrorType } from './error.js';
 
 /**
  * 错误处理器返回类型
@@ -14,7 +15,7 @@ type ErrorHandlerReturnType<D> = {
      * - false: 不抛出错误
      * - 'default': 使用默认错误处理逻辑
      */
-    throwError?: boolean | 'default';
+    throwError?: boolean | "default";
 };
 /**
  * 请求配置选项接口
@@ -53,7 +54,8 @@ interface Options<Params = any, Data = any> {
      * 缓存时间（秒）
      * @default 60
      */
-    cacheTime?: number; /**
+    cacheTime?: number;
+    /**
      * 缓存数据的存储类型
      * - localStorage: 使用浏览器本地存储，数据永久保存
      * - sessionStorage: 使用会话存储，关闭浏览器后清除
@@ -75,7 +77,8 @@ interface Options<Params = any, Data = any> {
      * 错误码在响应数据中的路径
      * @default 'code'
      */
-    errorCodePath?: string; /**
+    errorCodePath?: string;
+    /**
      * 错误码映射表
      * 可以配置错误码对应的错误信息或处理函数
      * @default {} 空对象，使用默认处理函数
@@ -85,7 +88,8 @@ interface Options<Params = any, Data = any> {
      * 默认错误码处理函数
      * 当错误码不在 errorCodeMap 中时调用
      */
-    defaultErrorCodeHandler?: (code: string, data: Data, res: AxiosResponse<Data>) => ErrorHandlerReturnType<Data> | void; /**
+    defaultErrorCodeHandler?: (code: string, data: Data, res: AxiosResponse<Data>) => Promise<ErrorHandlerReturnType<Data> | void>;
+    /**
      * 成功状态的错误码列表
      * @default ['0', '200']
      */
@@ -95,18 +99,18 @@ interface Options<Params = any, Data = any> {
      * 可以配置 HTTP 状态码对应的错误信息或处理函数
      * @default {} 空对象，使用默认处理函数
      */
-    httpErrorCodeMap?: Record<string, string | ((code: number, res: AxiosResponse<Data>, requestParam: RequestOptions<Params>) => ErrorHandlerReturnType<Data> | void)>;
+    httpErrorCodeMap?: Record<string, string | ((code: number, res: AxiosResponse<Data>, requestParam: RequestOptions<Params>) => Promise<ErrorHandlerReturnType<Data> | void>)>;
     /**
      * 默认 HTTP 错误码处理函数
      * 当 HTTP 状态码不在 httpErrorCodeMap 中时调用
      */
-    defaultHttpErrorCodeHandler?: (code: number, error: any) => ErrorHandlerReturnType<Data> | void;
+    defaultHttpErrorCodeHandler?: (code: number, error: any) => Promise<ErrorHandlerReturnType<Data> | void>;
     /**
      * 其他错误处理函数
      * 处理非 HTTP 错误和非业务错误码的错误
      */
-    otherErrorHandler?: (error: any) => ErrorHandlerReturnType<Data> | void;
-    axiosOptions?: Omit<AxiosRequestConfig<Params>, 'method' | 'url' | 'params' | 'data'>;
+    otherErrorHandler?: (error: any) => Promise<ErrorHandlerReturnType<Data> | void>;
+    axiosOptions?: Omit<AxiosRequestConfig<Params>, "method" | "url" | "params" | "data">;
 }
 /**
  * 请求参数接口

package/cjs/store/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var index = require('./createGetter/index.cjs');
+var index$1 = require('./createStateStore/index.cjs');
+
+
+
+exports.createStoreGetter = index.createStoreGetter;
+exports.createStoreGetterMemo = index.createStoreGetterMemo;
+exports.createStateStore = index$1.default;

package/cjs/store/index.d.ts

@@ -0,0 +1,2 @@
+export { GetterNameMap, ReducedData, StoreGetter, createStoreGetter, createStoreGetterMemo } from './createGetter/index.js';
+export { IHookStateInitAction, IHookStateInitialSetter, IHookStateResolvable, IHookStateSetAction, IHookStateSetter, default as createStateStore } from './createStateStore/index.js';