@chaomingd/store 2.0.7

package/dist/esm/utils/index.js

@@ -0,0 +1,58 @@
+export function calcDiffKeys(obj1, obj2, keys) {
+  var diffKeysMap = {};
+  var diff = false;
+  keys.forEach(function (key) {
+    // @ts-ignore
+    if (!Object.is(obj1[key], obj2[key])) {
+      diffKeysMap[key] = true;
+      diff = true;
+    }
+  });
+  return {
+    diffKeysMap: diffKeysMap,
+    diff: diff
+  };
+}
+export function calcComputedState(_ref) {
+  var prevState = _ref.prevState,
+    nextState = _ref.nextState,
+    computed = _ref.computed;
+  if (computed) {
+    computed.reduce(function (currentNextState, computedItem) {
+      var partialState;
+      if (typeof computedItem === 'function') {
+        partialState = computedItem(currentNextState, prevState);
+      } else {
+        var _calcDiffKeys = calcDiffKeys(prevState, currentNextState, computedItem.keys),
+          diffKeysMap = _calcDiffKeys.diffKeysMap,
+          diff = _calcDiffKeys.diff;
+        if (diff) {
+          partialState = computedItem.hander(currentNextState, diffKeysMap, prevState);
+        }
+      }
+      if (partialState) {
+        Object.assign(currentNextState, partialState);
+      }
+      return currentNextState;
+    }, nextState);
+  }
+  return nextState;
+}
+export function execWatchHandler(_ref2) {
+  var prevState = _ref2.prevState,
+    nextState = _ref2.nextState,
+    watch = _ref2.watch;
+  if (watch) {
+    watch.forEach(function (watchItem) {
+      if (watchItem.keys) {
+        var _calcDiffKeys2 = calcDiffKeys(prevState, nextState, watchItem.keys),
+          diffKeysMap = _calcDiffKeys2.diffKeysMap,
+          diff = _calcDiffKeys2.diff;
+        if (diff) {
+          // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+          watchItem.hander && watchItem.hander(nextState, diffKeysMap, prevState);
+        }
+      }
+    });
+  }
+}

package/dist/lib/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/lib/Manager/AsyncManager.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AsyncManager = void 0;
+var _utils = require("@chaomingd/utils");
+const DEFAULT_TIMEOUT = 300;
+class AsyncManager extends _utils.EventEmitter2 {
+  execId = 0;
+  options = {};
+  abortSignalMap = {};
+  constructor(options) {
+    super();
+    if (options) {
+      this.options = options;
+    }
+  }
+  getCurrentExecId() {
+    return this.execId;
+  }
+  getAbortController(execId) {
+    return this.abortSignalMap[execId];
+  }
+  exec(fn) {
+    let tryCount = 0;
+    const execId = ++this.execId;
+    this.emit('loading');
+    return new Promise((resolve, reject) => {
+      const _exec = () => {
+        const lastAbortController = this.abortSignalMap[execId - 1] || null;
+        const abortController = this.abortSignalMap[execId] = new AbortController();
+        fn({
+          lastAbortController,
+          abortController
+        }, tryCount).then(res => {
+          if (execId === this.execId) {
+            this.emit('success', res);
+          }
+          resolve(res);
+          delete this.abortSignalMap[execId];
+          this.emit('finish', null, res);
+          return res;
+        }).catch(e => {
+          if (execId === this.execId) {
+            if (tryCount < (this.options.retryCount || 0)) {
+              setTimeout(() => {
+                _exec();
+              }, this.options.retryInterval || DEFAULT_TIMEOUT);
+            } else {
+              this.emit('error', e);
+              reject(e);
+              delete this.abortSignalMap[execId];
+              this.emit('finish', e, null);
+            }
+          } else {
+            delete this.abortSignalMap[execId];
+            this.emit('finish', e, null);
+            reject(e);
+          }
+          tryCount++;
+        });
+      };
+      _exec();
+    });
+  }
+}
+exports.AsyncManager = AsyncManager;

package/dist/lib/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/lib/index.js

@@ -0,0 +1,371 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Model: true,
+  useModel: true,
+  createAsyncEffect: true,
+  createEqualityFn: true
+};
+exports.Model = void 0;
+exports.createAsyncEffect = createAsyncEffect;
+exports.createEqualityFn = createEqualityFn;
+exports.useModel = useModel;
+var _utils = require("@chaomingd/utils");
+var _ahooks = require("ahooks");
+var _react = require("react");
+var _withSelector = _interopRequireDefault(require("use-sync-external-store/shim/with-selector"));
+var _AsyncManager = require("./Manager/AsyncManager");
+var _utils2 = require("./utils");
+var _type = require("./type");
+Object.keys(_type).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _type[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _type[key];
+    }
+  });
+});
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  useSyncExternalStoreWithSelector
+} = _withSelector.default;
+const DEFAULT_SUBSCRIBE_NAME = 'reactStoreSubscribe';
+class Model {
+  isUnMount = false;
+  name;
+  state = {};
+  _userData = {};
+  _effects = {};
+  _preState = {};
+  _dispatchSignal = '';
+  _subscribes = {};
+  asyncManagerMap = {};
+  _isInited = false;
+  constructor(config) {
+    this.config = config;
+    if (config.autoInit !== false) {
+      this.init();
+    }
+  }
+  init() {
+    if (!this._isInited) {
+      this._isInited = true;
+      const config = this.config;
+      this.state = this.getActualState({}, config.state || {});
+      this._preState = {
+        ...this.state
+      };
+      this._userData = config?.userData || {};
+      if (config.effects) {
+        this.setEffects(config.effects);
+      }
+      if (config.name) {
+        this.name = config.name;
+      }
+    }
+  }
+  asyncManager(name, options) {
+    const {
+      loadingKey = 'loading',
+      errorKey = 'error',
+      showLoading = true,
+      config
+    } = options || {};
+    if (!this.asyncManagerMap[name]) {
+      this.asyncManagerMap[name] = new _AsyncManager.AsyncManager(config);
+    }
+    const asyncManager = this.asyncManagerMap[name];
+    asyncManager.offAllListeners();
+    asyncManager.on('loading', () => {
+      if (showLoading) {
+        this.setState({
+          [loadingKey]: true
+        });
+      }
+    });
+    asyncManager.on('success', result => {
+      if (typeof result === 'object' && result !== null) {
+        this.setState({
+          [loadingKey]: false,
+          ...result
+        });
+      }
+    });
+    asyncManager.on('error', error => {
+      this.setState({
+        [loadingKey]: false,
+        [errorKey]: error
+      });
+    });
+    return this.asyncManagerMap[name];
+  }
+  subscribe(func, name) {
+    const subscribeName = this.getSubscribeName(name);
+    if (!this._subscribes[subscribeName]) {
+      this._subscribes[subscribeName] = [];
+    }
+    this._subscribes[subscribeName].push(func);
+    return () => {
+      this.unsubscribe(func, name);
+    };
+  }
+  getSubscribeName(name) {
+    return name || DEFAULT_SUBSCRIBE_NAME;
+  }
+  unsubscribe(func, name) {
+    const subscribeName = this.getSubscribeName(name);
+    if (this._subscribes[subscribeName] && this._subscribes[subscribeName].length) {
+      this._subscribes[subscribeName] = this._subscribes[subscribeName].filter(fn => fn !== func);
+    }
+  }
+  getUserData() {
+    return {
+      ...this._userData
+    };
+  }
+  setUserData(userData) {
+    Object.assign(this._userData, userData);
+  }
+  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 = {
+        ...this.state
+      };
+    }
+  }
+  getActualState(prevState, payload) {
+    let nextState = {
+      ...prevState,
+      ...payload
+    };
+    const {
+      modifyState,
+      watch,
+      computed
+    } = this.config || {};
+    let partialState;
+    if (modifyState) {
+      partialState = modifyState(prevState, nextState);
+      if (partialState && typeof partialState === 'object') {
+        Object.assign(nextState, partialState);
+      }
+    }
+    // 处理计算属性
+    nextState = (0, _utils2.calcComputedState)({
+      prevState,
+      nextState,
+      computed
+    });
+    // 执行 watch
+    (0, _utils2.execWatchHandler)({
+      prevState,
+      nextState,
+      watch
+    });
+    return nextState;
+  }
+  getState = () => {
+    return this.state;
+  };
+  dispatch(options) {
+    if (this.isUnMount) return;
+    let subscribeNames = Object.keys(this._subscribes);
+    if (options) {
+      if (options.include) {
+        const includeNameMap = (0, _utils.arrayToMap)(options.include);
+        subscribeNames = subscribeNames.filter(name => includeNameMap[name]);
+      }
+      if (options.exclude) {
+        const excludeNameMap = (0, _utils.arrayToMap)(options.exclude);
+        subscribeNames = subscribeNames.filter(name => !excludeNameMap[name]);
+      }
+    }
+    this._dispatchSignal = (0, _utils.uuid)();
+    subscribeNames.forEach(subscribeName => {
+      if (this._subscribes[subscribeName]) {
+        this._subscribes[subscribeName].forEach(func => func(this, options?.silent || false));
+      }
+    });
+  }
+  setEffect(name, effect) {
+    if (this._effects[name] !== effect) {
+      this._effects[name] = typeof effect === 'function' ? effect.bind(this) : effect;
+    }
+  }
+  setEffects(effects) {
+    Object.keys(effects).forEach(name => {
+      this.setEffect(name, effects[name]);
+    });
+  }
+  getEffect(name) {
+    return (...args) => {
+      return this._effects[name].apply(this, args);
+    };
+  }
+  dispose() {
+    this._effects = {};
+    this.state = {};
+  }
+  useSelector = (equalityFn, name) => {
+    // eslint-disable-next-line
+    const subscribe = (0, _ahooks.useMemoizedFn)(listener => {
+      return this.subscribe((_, silent) => {
+        if (!silent) {
+          listener();
+        }
+      }, name);
+    });
+    const selector = (0, _ahooks.useMemoizedFn)(state => state);
+    const isEqual = (0, _ahooks.useMemoizedFn)((prevState, nextState) => {
+      if (equalityFn) {
+        return equalityFn(prevState, nextState);
+      }
+      return Object.is(prevState, nextState);
+    });
+    const state = useSyncExternalStoreWithSelector(subscribe, this.getState, this.getState, selector, isEqual);
+    return state;
+  };
+  useGetState = (keys, equalityFn, name) => {
+    const state = this.useSelector((prevState, nextState) => {
+      if (keys && (0, _utils.shallowEqualKeys)(prevState, nextState, keys)) {
+        return true;
+      }
+      if (equalityFn && equalityFn(prevState, nextState)) {
+        return true;
+      }
+      return false;
+    }, name);
+    return state;
+  };
+  useUpdate = (keys, equalityFn) => {
+    this.useGetState(keys, equalityFn);
+  };
+  subscribeWithKeys(func, options) {
+    const {
+      keys,
+      equalityFn,
+      name
+    } = options;
+    return this.subscribe((_, silent) => {
+      const nextState = this.getState();
+      if (keys && (0, _utils.shallowEqualKeys)(this._preState, nextState, keys)) {
+        return;
+      }
+      if (equalityFn && equalityFn(this._preState, nextState)) {
+        return;
+      }
+      func(this, silent);
+    }, name);
+  }
+  useSubscribe = (func, options) => {
+    const unmountRef = (0, _react.useRef)(false);
+    const funcRef = (0, _ahooks.useLatest)(func);
+    // eslint-disable-next-line
+    const [_, forceUpdate] = (0, _react.useState)({});
+    const optionsRef = (0, _ahooks.useLatest)(options);
+    const needDispatchRef = (0, _react.useRef)(false);
+    (0, _react.useEffect)(() => {
+      unmountRef.current = false;
+      funcRef.current?.(this, false);
+      const unsubscribe = this.subscribeWithKeys((__, silent) => {
+        if (!unmountRef.current) {
+          needDispatchRef.current = true;
+          if (optionsRef.current?.forceUpdate !== false && silent !== true) {
+            forceUpdate({});
+          }
+        }
+      }, options || {});
+      return () => {
+        unmountRef.current = true;
+        unsubscribe();
+      };
+      // eslint-disable-next-line
+    }, []);
+    (0, _react.useEffect)(() => {
+      if (needDispatchRef.current) {
+        funcRef.current?.(this, false);
+        needDispatchRef.current = false;
+      }
+    }, [this._dispatchSignal, funcRef]);
+  };
+  UI = ({
+    children,
+    keys,
+    equalityFn,
+    name
+  }) => {
+    const state = this.useGetState(keys, equalityFn, name);
+    return children(state);
+  };
+}
+exports.Model = Model;
+function useModel(modelConfig) {
+  const model = (0, _ahooks.useCreation)(() => {
+    return new Model(modelConfig);
+  }, []);
+  model.config = modelConfig;
+  if (modelConfig.effects) {
+    model.setEffects(modelConfig.effects);
+  }
+  (0, _react.useEffect)(() => {
+    model.isUnMount = false;
+    return () => {
+      model.isUnMount = true;
+    };
+  }, [model]);
+  return model;
+}
+function createAsyncEffect(effectHandler, config) {
+  return function (...args) {
+    const options = args[0];
+    const loadingKey = config?.loadingKey || 'loading';
+    const showLoading = options?.showLoading;
+    const model = this;
+    if (showLoading !== false) {
+      model.setState({
+        [loadingKey]: true
+      });
+    }
+    const fetchCountKey = `${loadingKey}-count`;
+    if (model[fetchCountKey] === undefined) {
+      model[fetchCountKey] = -1;
+    }
+    const fetchCount = ++model[fetchCountKey];
+    return effectHandler(...args).then(data => {
+      if (fetchCount !== model[fetchCountKey]) return data;
+      const nextState = {};
+      if (showLoading !== false) {
+        nextState[loadingKey] = false;
+      }
+      if (data && typeof data === 'object') {
+        Object.assign(nextState, data);
+      }
+      model.setState(nextState);
+      return data;
+    }).catch(e => {
+      if (showLoading !== false) {
+        model.setState({
+          [loadingKey]: false
+        });
+      }
+      throw e;
+    });
+  };
+}
+function createEqualityFn(keys) {
+  return (prevState, nextState) => (0, _utils.shallowEqualKeys)(prevState, nextState, keys);
+}

package/dist/lib/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/lib/type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/lib/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 {};