@chaomingd/store 2.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/esm/Manager/AsyncManager.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter2 } from '@chaomingd/utils';
+export interface AsyncManagerOptions {
+    retryCount?: number;
+    retryInterval?: number;
+}
+export declare class AsyncManager<T, Fn extends (aborts: {
+    lastAbortController: AbortController | null;
+    abortController: AbortController;
+}, tryCount: number) => Promise<T>> extends EventEmitter2<{
+    loading: (() => void)[];
+    success: ((result: any) => void)[];
+    error: ((error: Error) => void)[];
+    finish: ((error: Error | null, result: any) => void)[];
+}> {
+    execId: number;
+    options: AsyncManagerOptions;
+    abortSignalMap: Record<number, AbortController>;
+    constructor(options?: AsyncManagerOptions);
+    getCurrentExecId(): number;
+    getAbortController(execId: number): AbortController;
+    exec(fn: Fn): Promise<T>;
+}

package/dist/esm/Manager/AsyncManager.js

@@ -0,0 +1,89 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { EventEmitter2 } from '@chaomingd/utils';
+var DEFAULT_TIMEOUT = 300;
+export var AsyncManager = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(AsyncManager, _EventEmitter);
+  var _super = _createSuper(AsyncManager);
+  function AsyncManager(options) {
+    var _this;
+    _classCallCheck(this, AsyncManager);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "execId", 0);
+    _defineProperty(_assertThisInitialized(_this), "options", {});
+    _defineProperty(_assertThisInitialized(_this), "abortSignalMap", {});
+    if (options) {
+      _this.options = options;
+    }
+    return _this;
+  }
+  _createClass(AsyncManager, [{
+    key: "getCurrentExecId",
+    value: function getCurrentExecId() {
+      return this.execId;
+    }
+  }, {
+    key: "getAbortController",
+    value: function getAbortController(execId) {
+      return this.abortSignalMap[execId];
+    }
+  }, {
+    key: "exec",
+    value: function exec(fn) {
+      var _this2 = this;
+      var tryCount = 0;
+      var execId = ++this.execId;
+      this.emit('loading');
+      return new Promise(function (resolve, reject) {
+        var _exec = function _exec() {
+          var lastAbortController = _this2.abortSignalMap[execId - 1] || null;
+          var abortController = _this2.abortSignalMap[execId] = new AbortController();
+          fn({
+            lastAbortController: lastAbortController,
+            abortController: abortController
+          }, tryCount).then(function (res) {
+            if (execId === _this2.execId) {
+              _this2.emit('success', res);
+            }
+            resolve(res);
+            delete _this2.abortSignalMap[execId];
+            _this2.emit('finish', null, res);
+            return res;
+          }).catch(function (e) {
+            if (execId === _this2.execId) {
+              if (tryCount < (_this2.options.retryCount || 0)) {
+                setTimeout(function () {
+                  _exec();
+                }, _this2.options.retryInterval || DEFAULT_TIMEOUT);
+              } else {
+                _this2.emit('error', e);
+                reject(e);
+                delete _this2.abortSignalMap[execId];
+                _this2.emit('finish', e, null);
+              }
+            } else {
+              delete _this2.abortSignalMap[execId];
+              _this2.emit('finish', e, null);
+              reject(e);
+            }
+            tryCount++;
+          });
+        };
+        _exec();
+      });
+    }
+  }]);
+  return AsyncManager;
+}(EventEmitter2);

package/dist/esm/index.d.ts

@@ -0,0 +1,85 @@
+import { ReactNode } from 'react';
+import type { AsyncManagerOptions } from './Manager/AsyncManager';
+import { AsyncManager } from './Manager/AsyncManager';
+import type { IDispatchOptions, TComputed, TEqualityFn, TWatch } from './type';
+type TSubscribeFunc<TState extends Record<string, any> = Record<string, any>, TEffects extends Record<string, any> = Record<string, any>, UserData extends Record<string, any> = Record<string, any>> = (state: Model<TState, TEffects, UserData>, silent: boolean) => any;
+type IEffects<M extends Model<any, any>> = Record<string, ((this: M, ...args: any[]) => any) | any>;
+export interface IModelConfig<TState extends Record<string, any> = Record<string, any>, TEffects extends IEffects<Model<TState, TEffects>> = IEffects<Model>, UserData extends Record<string, any> = Record<string, any>> {
+    autoInit?: boolean;
+    state: TState;
+    effects?: Partial<TEffects>;
+    onStateChange?: (prevState: TState, currentState: TState) => any;
+    modifyState?: (prevState: TState, nextState: TState) => Partial<TState> | null;
+    watch?: TWatch<TState>;
+    computed?: TComputed<TState>;
+    userData?: UserData;
+    name?: string;
+}
+export declare class Model<TState extends Record<string, any> = Record<string, any>, TEffects extends IEffects<Model<TState, TEffects>> = IEffects<Model<TState, any, any>>, UserData extends Record<string, any> = Record<string, any>> {
+    config: IModelConfig<TState, TEffects, UserData>;
+    isUnMount: boolean;
+    name?: string;
+    state: TState;
+    _userData: UserData;
+    _effects: TEffects;
+    _preState: TState;
+    _dispatchSignal: string;
+    _subscribes: Record<string, TSubscribeFunc<TState, TEffects, UserData>[]>;
+    asyncManagerMap: Record<string, AsyncManager<Partial<TState>, (aborts: {
+        lastAbortController: AbortController | null;
+        abortController: AbortController;
+    }, tryCount: number) => Promise<Partial<TState>>>>;
+    _isInited: boolean;
+    constructor(config: IModelConfig<TState, TEffects, UserData>);
+    init(): void;
+    asyncManager(name: string, options?: {
+        loadingKey?: string;
+        errorKey?: string;
+        config?: AsyncManagerOptions;
+        showLoading?: boolean;
+    }): AsyncManager<Partial<TState>, (aborts: {
+        lastAbortController: AbortController | null;
+        abortController: AbortController;
+    }, tryCount: number) => Promise<Partial<TState>>>;
+    subscribe(func: TSubscribeFunc<TState, TEffects, UserData>, name?: string): () => void;
+    getSubscribeName(name?: string): string;
+    unsubscribe(func: TSubscribeFunc<TState, TEffects, UserData>, name?: string): void;
+    getUserData(): UserData;
+    setUserData(userData: Partial<UserData>): void;
+    setState(state: Partial<TState> | ((state: TState) => Partial<TState>), options?: IDispatchOptions): void;
+    getActualState(prevState: TState, payload: Partial<TState>): TState & Partial<TState>;
+    getState: () => TState;
+    dispatch(options?: IDispatchOptions): void;
+    setEffect<M extends TEffects[keyof TEffects]>(name: keyof TEffects, effect: M): void;
+    setEffects(effects: Partial<TEffects>): void;
+    getEffect<Name extends keyof TEffects>(name: Name): (...args: Parameters<TEffects[Name]>) => ReturnType<TEffects[Name]>;
+    dispose(): void;
+    useSelector: (equalityFn?: TEqualityFn<TState>, name?: string) => TState;
+    useGetState: <Key extends keyof TState>(keys?: Key[], equalityFn?: TEqualityFn<TState>, name?: string) => TState;
+    useUpdate: <Key extends keyof TState>(keys?: Key[], equalityFn?: TEqualityFn<TState>) => void;
+    subscribeWithKeys<Key extends keyof TState>(func: TSubscribeFunc<TState, TEffects>, options: {
+        keys?: Key[];
+        equalityFn?: TEqualityFn<TState>;
+        name?: string;
+    }): () => void;
+    useSubscribe: <Key extends keyof TState>(func: TSubscribeFunc<TState, TEffects>, options?: {
+        keys?: Key[];
+        equalityFn?: TEqualityFn<TState>;
+        name?: string;
+        forceUpdate?: boolean;
+    }) => void;
+    UI: <Key extends keyof TState>({ children, keys, equalityFn, name, }: {
+        children: (state: TState) => ReactNode | ReactNode[];
+        keys?: Key[] | undefined;
+        equalityFn?: TEqualityFn<TState> | undefined;
+        name?: string | undefined;
+    }) => ReactNode | ReactNode[];
+}
+export declare function useModel<TState extends Record<string, any>, TEffects extends IEffects<Model<TState, TEffects>> = IEffects<Model<TState>>, UserData extends Record<string, any> = Record<string, any>>(modelConfig: IModelConfig<TState, TEffects, UserData>): Model<TState, TEffects, UserData>;
+export declare function createAsyncEffect<EffectHandler extends (options?: {
+    showLoading?: boolean;
+}, ...args: any[]) => Promise<any>>(effectHandler: EffectHandler, config: {
+    loadingKey: string;
+}): EffectHandler;
+export declare function createEqualityFn(keys?: string[]): (prevState: Record<string, any>, nextState: Record<string, any>) => boolean;
+export * from './type';

package/dist/esm/index.js

@@ -0,0 +1,394 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { arrayToMap, shallowEqualKeys, uuid } from '@chaomingd/utils';
+import { useCreation, useLatest, useMemoizedFn } from 'ahooks';
+import { useEffect, useRef, useState } from 'react';
+import useSyncExternalStoreExports from 'use-sync-external-store/shim/with-selector';
+import { AsyncManager } from "./Manager/AsyncManager";
+import { calcComputedState, execWatchHandler } from "./utils";
+var useSyncExternalStoreWithSelector = useSyncExternalStoreExports.useSyncExternalStoreWithSelector;
+var DEFAULT_SUBSCRIBE_NAME = 'reactStoreSubscribe';
+export var Model = /*#__PURE__*/function () {
+  function Model(config) {
+    var _this = this;
+    _classCallCheck(this, Model);
+    _defineProperty(this, "isUnMount", false);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "state", {});
+    _defineProperty(this, "_userData", {});
+    _defineProperty(this, "_effects", {});
+    _defineProperty(this, "_preState", {});
+    _defineProperty(this, "_dispatchSignal", '');
+    _defineProperty(this, "_subscribes", {});
+    _defineProperty(this, "asyncManagerMap", {});
+    _defineProperty(this, "_isInited", false);
+    _defineProperty(this, "getState", function () {
+      return _this.state;
+    });
+    _defineProperty(this, "useSelector", function (equalityFn, name) {
+      // eslint-disable-next-line
+      var subscribe = useMemoizedFn(function (listener) {
+        return _this.subscribe(function (_, silent) {
+          if (!silent) {
+            listener();
+          }
+        }, name);
+      });
+      var selector = useMemoizedFn(function (state) {
+        return state;
+      });
+      var isEqual = useMemoizedFn(function (prevState, nextState) {
+        if (equalityFn) {
+          return equalityFn(prevState, nextState);
+        }
+        return Object.is(prevState, nextState);
+      });
+      var state = useSyncExternalStoreWithSelector(subscribe, _this.getState, _this.getState, selector, isEqual);
+      return state;
+    });
+    _defineProperty(this, "useGetState", function (keys, equalityFn, name) {
+      var state = _this.useSelector(function (prevState, nextState) {
+        if (keys && shallowEqualKeys(prevState, nextState, keys)) {
+          return true;
+        }
+        if (equalityFn && equalityFn(prevState, nextState)) {
+          return true;
+        }
+        return false;
+      }, name);
+      return state;
+    });
+    _defineProperty(this, "useUpdate", function (keys, equalityFn) {
+      _this.useGetState(keys, equalityFn);
+    });
+    _defineProperty(this, "useSubscribe", function (func, options) {
+      var unmountRef = useRef(false);
+      var funcRef = useLatest(func);
+      // eslint-disable-next-line
+      var _useState = useState({}),
+        _useState2 = _slicedToArray(_useState, 2),
+        _ = _useState2[0],
+        forceUpdate = _useState2[1];
+      var optionsRef = useLatest(options);
+      var needDispatchRef = useRef(false);
+      useEffect(function () {
+        var _funcRef$current;
+        unmountRef.current = false;
+        (_funcRef$current = funcRef.current) === null || _funcRef$current === void 0 || _funcRef$current.call(funcRef, _this, false);
+        var unsubscribe = _this.subscribeWithKeys(function (__, silent) {
+          if (!unmountRef.current) {
+            var _optionsRef$current;
+            needDispatchRef.current = true;
+            if (((_optionsRef$current = optionsRef.current) === null || _optionsRef$current === void 0 ? void 0 : _optionsRef$current.forceUpdate) !== false && silent !== true) {
+              forceUpdate({});
+            }
+          }
+        }, options || {});
+        return function () {
+          unmountRef.current = true;
+          unsubscribe();
+        };
+        // eslint-disable-next-line
+      }, []);
+      useEffect(function () {
+        if (needDispatchRef.current) {
+          var _funcRef$current2;
+          (_funcRef$current2 = funcRef.current) === null || _funcRef$current2 === void 0 || _funcRef$current2.call(funcRef, _this, false);
+          needDispatchRef.current = false;
+        }
+      }, [_this._dispatchSignal, funcRef]);
+    });
+    _defineProperty(this, "UI", function (_ref) {
+      var children = _ref.children,
+        keys = _ref.keys,
+        equalityFn = _ref.equalityFn,
+        name = _ref.name;
+      var state = _this.useGetState(keys, equalityFn, name);
+      return children(state);
+    });
+    this.config = config;
+    if (config.autoInit !== false) {
+      this.init();
+    }
+  }
+  _createClass(Model, [{
+    key: "init",
+    value: function init() {
+      if (!this._isInited) {
+        this._isInited = true;
+        var _config = this.config;
+        this.state = this.getActualState({}, _config.state || {});
+        this._preState = _objectSpread({}, this.state);
+        this._userData = (_config === null || _config === void 0 ? void 0 : _config.userData) || {};
+        if (_config.effects) {
+          this.setEffects(_config.effects);
+        }
+        if (_config.name) {
+          this.name = _config.name;
+        }
+      }
+    }
+  }, {
+    key: "asyncManager",
+    value: function asyncManager(name, options) {
+      var _this2 = this;
+      var _ref2 = options || {},
+        _ref2$loadingKey = _ref2.loadingKey,
+        loadingKey = _ref2$loadingKey === void 0 ? 'loading' : _ref2$loadingKey,
+        _ref2$errorKey = _ref2.errorKey,
+        errorKey = _ref2$errorKey === void 0 ? 'error' : _ref2$errorKey,
+        _ref2$showLoading = _ref2.showLoading,
+        showLoading = _ref2$showLoading === void 0 ? true : _ref2$showLoading,
+        config = _ref2.config;
+      if (!this.asyncManagerMap[name]) {
+        this.asyncManagerMap[name] = new AsyncManager(config);
+      }
+      var asyncManager = this.asyncManagerMap[name];
+      asyncManager.offAllListeners();
+      asyncManager.on('loading', function () {
+        if (showLoading) {
+          _this2.setState(_defineProperty({}, loadingKey, true));
+        }
+      });
+      asyncManager.on('success', function (result) {
+        if (_typeof(result) === 'object' && result !== null) {
+          _this2.setState(_objectSpread(_defineProperty({}, loadingKey, false), result));
+        }
+      });
+      asyncManager.on('error', function (error) {
+        _this2.setState(_defineProperty(_defineProperty({}, loadingKey, false), errorKey, error));
+      });
+      return this.asyncManagerMap[name];
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(func, name) {
+      var _this3 = this;
+      var subscribeName = this.getSubscribeName(name);
+      if (!this._subscribes[subscribeName]) {
+        this._subscribes[subscribeName] = [];
+      }
+      this._subscribes[subscribeName].push(func);
+      return function () {
+        _this3.unsubscribe(func, name);
+      };
+    }
+  }, {
+    key: "getSubscribeName",
+    value: function getSubscribeName(name) {
+      return name || DEFAULT_SUBSCRIBE_NAME;
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe(func, name) {
+      var subscribeName = this.getSubscribeName(name);
+      if (this._subscribes[subscribeName] && this._subscribes[subscribeName].length) {
+        this._subscribes[subscribeName] = this._subscribes[subscribeName].filter(function (fn) {
+          return fn !== func;
+        });
+      }
+    }
+  }, {
+    key: "getUserData",
+    value: function getUserData() {
+      return _objectSpread({}, this._userData);
+    }
+  }, {
+    key: "setUserData",
+    value: function setUserData(userData) {
+      Object.assign(this._userData, userData);
+    }
+  }, {
+    key: "setState",
+    value: function setState(state, options) {
+      if (state) {
+        if (typeof state === 'function') {
+          this.state = this.getActualState(this._preState, state(this.state));
+        } else {
+          this.state = this.getActualState(this._preState, state);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        this.config.onStateChange && this.config.onStateChange(this._preState, this.getState());
+        this.dispatch(options);
+        this._preState = _objectSpread({}, this.state);
+      }
+    }
+  }, {
+    key: "getActualState",
+    value: function getActualState(prevState, payload) {
+      var nextState = _objectSpread(_objectSpread({}, prevState), payload);
+      var _ref3 = this.config || {},
+        modifyState = _ref3.modifyState,
+        watch = _ref3.watch,
+        computed = _ref3.computed;
+      var partialState;
+      if (modifyState) {
+        partialState = modifyState(prevState, nextState);
+        if (partialState && _typeof(partialState) === 'object') {
+          Object.assign(nextState, partialState);
+        }
+      }
+      // 处理计算属性
+      nextState = calcComputedState({
+        prevState: prevState,
+        nextState: nextState,
+        computed: computed
+      });
+      // 执行 watch
+      execWatchHandler({
+        prevState: prevState,
+        nextState: nextState,
+        watch: watch
+      });
+      return nextState;
+    }
+  }, {
+    key: "dispatch",
+    value: function dispatch(options) {
+      var _this4 = this;
+      if (this.isUnMount) return;
+      var subscribeNames = Object.keys(this._subscribes);
+      if (options) {
+        if (options.include) {
+          var includeNameMap = arrayToMap(options.include);
+          subscribeNames = subscribeNames.filter(function (name) {
+            return includeNameMap[name];
+          });
+        }
+        if (options.exclude) {
+          var excludeNameMap = arrayToMap(options.exclude);
+          subscribeNames = subscribeNames.filter(function (name) {
+            return !excludeNameMap[name];
+          });
+        }
+      }
+      this._dispatchSignal = uuid();
+      subscribeNames.forEach(function (subscribeName) {
+        if (_this4._subscribes[subscribeName]) {
+          _this4._subscribes[subscribeName].forEach(function (func) {
+            return func(_this4, (options === null || options === void 0 ? void 0 : options.silent) || false);
+          });
+        }
+      });
+    }
+  }, {
+    key: "setEffect",
+    value: function setEffect(name, effect) {
+      if (this._effects[name] !== effect) {
+        this._effects[name] = typeof effect === 'function' ? effect.bind(this) : effect;
+      }
+    }
+  }, {
+    key: "setEffects",
+    value: function setEffects(effects) {
+      var _this5 = this;
+      Object.keys(effects).forEach(function (name) {
+        _this5.setEffect(name, effects[name]);
+      });
+    }
+  }, {
+    key: "getEffect",
+    value: function getEffect(name) {
+      var _this6 = this;
+      return function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return _this6._effects[name].apply(_this6, args);
+      };
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this._effects = {};
+      this.state = {};
+    }
+  }, {
+    key: "subscribeWithKeys",
+    value: function subscribeWithKeys(func, options) {
+      var _this7 = this;
+      var keys = options.keys,
+        equalityFn = options.equalityFn,
+        name = options.name;
+      return this.subscribe(function (_, silent) {
+        var nextState = _this7.getState();
+        if (keys && shallowEqualKeys(_this7._preState, nextState, keys)) {
+          return;
+        }
+        if (equalityFn && equalityFn(_this7._preState, nextState)) {
+          return;
+        }
+        func(_this7, silent);
+      }, name);
+    }
+  }]);
+  return Model;
+}();
+export function useModel(modelConfig) {
+  var model = useCreation(function () {
+    return new Model(modelConfig);
+  }, []);
+  model.config = modelConfig;
+  if (modelConfig.effects) {
+    model.setEffects(modelConfig.effects);
+  }
+  useEffect(function () {
+    model.isUnMount = false;
+    return function () {
+      model.isUnMount = true;
+    };
+  }, [model]);
+  return model;
+}
+export function createAsyncEffect(effectHandler, config) {
+  return function () {
+    var options = arguments.length <= 0 ? undefined : arguments[0];
+    var loadingKey = (config === null || config === void 0 ? void 0 : config.loadingKey) || 'loading';
+    var showLoading = options === null || options === void 0 ? void 0 : options.showLoading;
+    var model = this;
+    if (showLoading !== false) {
+      model.setState(_defineProperty({}, loadingKey, true));
+    }
+    var fetchCountKey = "".concat(loadingKey, "-count");
+    if (model[fetchCountKey] === undefined) {
+      model[fetchCountKey] = -1;
+    }
+    var fetchCount = ++model[fetchCountKey];
+    return effectHandler.apply(void 0, arguments).then(function (data) {
+      if (fetchCount !== model[fetchCountKey]) return data;
+      var nextState = {};
+      if (showLoading !== false) {
+        nextState[loadingKey] = false;
+      }
+      if (data && _typeof(data) === 'object') {
+        Object.assign(nextState, data);
+      }
+      model.setState(nextState);
+      return data;
+    }).catch(function (e) {
+      if (showLoading !== false) {
+        model.setState(_defineProperty({}, loadingKey, false));
+      }
+      throw e;
+    });
+  };
+}
+export function createEqualityFn(keys) {
+  return function (prevState, nextState) {
+    return shallowEqualKeys(prevState, nextState, keys);
+  };
+}
+export * from "./type";

package/dist/esm/type.d.ts

@@ -0,0 +1,17 @@
+export type TEqualityFn<TState extends Record<string, any>> = (prevState: TState, nextState: TState) => boolean;
+export type TPromiseValue<T> = T | Promise<T>;
+export type TComputedHandler<TState, R = any> = (state: TState, keyMap: Record<keyof TState & string, boolean>, prevState: TState) => R;
+export type TWatch<TState extends Record<string, any>> = {
+    keys: (keyof TState)[];
+    hander: TComputedHandler<TState, any>;
+}[];
+export type TComputed<TState extends Record<string, any>> = ({
+    keys: (keyof TState)[];
+    hander: TComputedHandler<TState, Partial<TState>>;
+} | ((state: TState, prevState: TState) => Partial<TState>))[];
+export interface IDispatchOptions {
+    include?: string[];
+    exclude?: string[];
+    silent?: boolean;
+}
+export type TSelectorFn<TState> = (state: TState) => Partial<TState>;

package/dist/esm/type.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,18 @@
+import type { TComputed, TWatch } from '../type';
+interface IComputedConfig<TState extends Record<string, any>> {
+    prevState: TState;
+    nextState: TState;
+    computed?: TComputed<TState>;
+}
+export declare function calcDiffKeys(obj1: object, obj2: object, keys: (string | number | symbol)[]): {
+    diffKeysMap: Record<string | number | symbol, boolean>;
+    diff: boolean;
+};
+export declare function calcComputedState<TState extends Record<string, any>>({ prevState, nextState, computed, }: IComputedConfig<TState>): TState;
+interface IWatchConfig<TState extends Record<string, any>> {
+    prevState: TState;
+    nextState: TState;
+    watch?: TWatch<TState>;
+}
+export declare function execWatchHandler<TState extends Record<string, any>>({ prevState, nextState, watch, }: IWatchConfig<TState>): void;
+export {};