@mpxjs/core 2.8.0-beta.2 → 2.8.0-beta.4

package/@types/index.d.ts

@@ -4,48 +4,29 @@
 // TypeScript Version: 4.1.3
 
 /// <reference types="miniprogram-api-typings" />
-/// <reference path="./mpx-store.d.ts" />
 /// <reference path="./global.d.ts" />
 /// <reference path="./node.d.ts" />
 
 // @ts-ignore
 import VueI18n from 'vue-i18n'
 
+import type { GetComputedType } from '@mpxjs/store'
+
+export * from '@mpxjs/store'
+
 declare module 'vue-i18n' {
   export default interface VueI18n {
     mergeMessages (messages: { [index: string]: VueI18n.LocaleMessageObject }): void;
   }
 }
-// declare Store types
-type StoreOpt<S, G, M, A, D extends MpxStore.Deps> = MpxStore.StoreOpt<S, G, M, A, D>
-
-type Store<S = {}, G = {}, M = {}, A = {}, D extends Deps = {}> = MpxStore.Store<S, G, M, A, D>
-
-type StoreOptWithThis<S, G, M, A, D extends Deps> = MpxStore.StoreOptWithThis<S, G, M, A, D>
-
-type StoreWithThis<S = {}, G = {}, M = {}, A = {}, D extends Deps = {}> = MpxStore.StoreWithThis<S, G, M, A, D>
-
-type UnboxDepsField<D extends Deps, F> = MpxStore.UnboxDepsField<D, F>
-
-type GetComputedType<T> = MpxStore.GetComputedType<T>
-
-type GetDispatchAndCommitWithThis<A, D extends Deps, AK extends 'actions' | 'mutations'> = MpxStore.GetDispatchAndCommitWithThis<A, D, AK>
-
-type MutationsAndActionsWithThis = MpxStore.MutationsAndActionsWithThis
-
-type Actions<S, G extends MpxStore.Getters<S>> = MpxStore.Actions<S, G>
-
-type Mutations<S> = MpxStore.Mutations<S>
-
-type Getters<S> = MpxStore.Getters<S>
-
-type Deps = MpxStore.Deps
 
 // utils
 type ObjectOf<T> = {
   [key: string]: T
 }
 
+type AnyObject = ObjectOf<any>
+
 type UnionToIntersection<U> = (U extends any
   ? (k: U) => void
   : never) extends ((k: infer I) => void)
@@ -182,11 +163,11 @@ type PageOpt<D, P, C, M, Mi extends Array<any>, S extends Record<any, any>> =
   ComponentOpt<D, P, C, M, Mi, S>
   & Partial<WechatMiniprogram.Page.ILifetime>
 
-type ThisTypedPageOpt<D, P, C, M, Mi extends Array<any>, S extends Record<any, any>, O = {}> =
+type ThisTypedPageOpt<D extends AnyObject, P, C, M, Mi extends Array<any>, S extends Record<any, any>, O = {}> =
   PageOpt<D, P, C, M, Mi, S>
   & ThisType<ComponentIns<D, P, C, M, Mi, S, O>> & O
 
-type ThisTypedComponentOpt<D, P, C, M, Mi extends Array<any>, S extends Record<any, any>, O = {}> =
+type ThisTypedComponentOpt<D extends AnyObject, P, C, M, Mi extends Array<any>, S extends Record<any, any>, O = {}> =
   ComponentOpt<D, P, C, M, Mi, S>
   & ThisType<ComponentIns<D, P, C, M, Mi, S, O>> & O
 
@@ -245,12 +226,12 @@ interface ReplaceWxComponentIns {
   selectAllComponents (selector: string): Array<ComponentIns<{}, {}, {}, {}, []>>
 }
 
-type WxComponentIns<D> =
+type WxComponentIns<D extends AnyObject> =
   ReplaceWxComponentIns
   & WechatMiniprogram.Component.InstanceProperties
   & WechatMiniprogram.Component.InstanceMethods<D>
 
-type ComponentIns<D, P, C, M, Mi extends Array<any>, S extends Record<any, any> = {}, O = {}> =
+type ComponentIns<D extends AnyObject, P, C, M, Mi extends Array<any>, S extends Record<any, any> = {}, O = {}> =
   GetDataType<D> & UnboxMixinsField<Mi, 'data'> &
   M & UnboxMixinsField<Mi, 'methods'> & { [K in keyof S]: S[K] extends Ref<infer V> ? V : S[K] } &
   GetPropsType<P & UnboxMixinsField<Mi, 'properties'>> &
@@ -261,9 +242,9 @@ interface CreateConfig {
   customCtor: any
 }
 
-export function createComponent<D extends Data = {}, P extends Properties = {}, C = {}, M extends Methods = {}, Mi extends Array<any> = [], O = {}> (opt: ThisTypedComponentOpt<D, P, C, M, Mi, O>, config?: CreateConfig): void
+export function createComponent<D extends Data = {}, P extends Properties = {}, C = {}, M extends Methods = {}, Mi extends Array<any> = [], S extends AnyObject = {}, O extends AnyObject = {}> (opt: ThisTypedComponentOpt<D, P, C, M, Mi, S, O>, config?: CreateConfig): void
 
-export function getMixin<D extends Data = {}, P extends Properties = {}, C = {}, M extends Methods = {}, Mi extends Array<any> = [], O = {}> (opt: ThisTypedComponentOpt<D, P, C, M, Mi, O>): {
+export function getMixin<D extends Data = {}, P extends Properties = {}, C = {}, M extends Methods = {}, Mi extends Array<any> = [], S extends AnyObject = {}, O extends AnyObject = {}> (opt: ThisTypedComponentOpt<D, P, C, M, Mi, S, O>): {
   data: GetDataType<D> & UnboxMixinsField<Mi, 'data'>
   properties: P & UnboxMixinsField<Mi, 'properties'>
   computed: C & UnboxMixinsField<Mi, 'computed'>
@@ -271,42 +252,10 @@ export function getMixin<D extends Data = {}, P extends Properties = {}, C = {},
   [index: string]: any
 }
 
-export function createPage<D extends Data = {}, P extends Properties = {}, C = {}, M extends Methods = {}, Mi extends Array<any> = [], O = {}> (opt: ThisTypedPageOpt<D, P, C, M, Mi, O>, config?: CreateConfig): void
+export function createPage<D extends Data = {}, P extends Properties = {}, C = {}, M extends Methods = {}, Mi extends Array<any> = [], O extends AnyObject = {}> (opt: ThisTypedPageOpt<D, P, C, M, Mi, O>, config?: CreateConfig): void
 
 export function createApp<T extends WechatMiniprogram.IAnyObject> (opt: WechatMiniprogram.App.Options<T>, config?: CreateConfig): void
 
-export function createStore<S, G extends Getters<S>, M extends Mutations<S>, A extends Actions<S, G>, D extends Deps = {}> (option: StoreOpt<S, G, M, A, D>): Store<S, G, M, A, D>
-
-export function createStoreWithThis<S = {}, G = {}, M extends MutationsAndActionsWithThis = {}, A extends MutationsAndActionsWithThis = {}, D extends Deps = {}> (option: StoreOptWithThis<S, G, M, A, D>): StoreWithThis<S, G, M, A, D>
-
-// auxiliary functions
-export function createStateWithThis<S = {}> (state: S): S
-
-export function createGettersWithThis<S = {}, D extends Deps = {}, G = {}, OG = {}> (getters: G & ThisType<{ state: S & UnboxDepsField<D, 'state'>, getters: GetComputedType<G & OG> & UnboxDepsField<D, 'getters'>, rootState: any }>, options?: {
-  state?: S,
-  getters?: OG,
-  deps?: D
-}): G
-
-export function createMutationsWithThis<S = {}, D extends Deps = {}, M extends MutationsAndActionsWithThis = {}> (mutations: M & ThisType<{ state: S & UnboxDepsField<D, 'state'>, commit: GetDispatchAndCommitWithThis<M, D, 'mutations'> }>, options?: {
-  state?: S,
-  deps?: D
-}): M
-
-export function createActionsWithThis<S = {}, G = {}, M extends MutationsAndActionsWithThis = {}, D extends Deps = {}, A extends MutationsAndActionsWithThis = {}, OA extends MutationsAndActionsWithThis = {}> (actions: A & ThisType<{
-  rootState: any,
-  state: S & UnboxDepsField<D, 'state'>,
-  getters: GetComputedType<G> & UnboxDepsField<D, 'getters'>,
-  dispatch: GetDispatchAndCommitWithThis<A & OA, D, 'actions'>,
-  commit: GetDispatchAndCommitWithThis<M, D, 'mutations'>
-} & MpxStore.CompatibleDispatch>, options?: {
-  state?: S,
-  getters?: G,
-  mutations?: M,
-  actions?: OA,
-  deps?: D
-}): A
-
 type MixinType = 'app' | 'page' | 'component'
 
 export function injectMixins (mixins: object | Array<object>, options?: MixinType | MixinType[] | { types?: MixinType | MixinType[], stage?: number }): void
@@ -322,12 +271,12 @@ interface AnyConstructor {
 interface MpxConfig {
   useStrictDiff: boolean
   ignoreWarning: boolean | string | RegExp | ((msg: string, location: string, e: Error) => boolean)
-  ignoreConflictWhiteList: Array<string>
+  ignoreProxyWhiteList: Array<string>
   observeClassInstance: boolean | Array<AnyConstructor>
-  hookErrorHandler: (e: Error, target: ComponentIns<{}, {}, {}, {}, []>, hookName: string) => any | null
+  errorHandler: (e: Error, target: ComponentIns<{}, {}, {}, {}, []>, hookName: string) => any | null
   proxyEventHandler: (e: Event) => any | null
   setDataHandler: (data: object, target: ComponentIns<{}, {}, {}, {}, []>) => any | null
-  forceRunWatcherSync: boolean,
+  forceFlushSync: boolean,
   webRouteConfig: object
 }
 
@@ -341,12 +290,13 @@ interface ImplementOptions {
 
 export function toPureObject<T extends object> (obj: T): T
 
+declare type PluginInstallFunction = (app: Mpx, ...options: any[]) => any;
+
+export type Plugin = PluginInstallFunction | {
+  install: PluginInstallFunction;
+};
+
 export interface Mpx {
-  createComponent: typeof createComponent
-  createPage: typeof createPage
-  createApp: typeof createApp
-  createStore: typeof createStore
-  createStoreWithThis: typeof createStoreWithThis
   getMixin: typeof getMixin
   mixin: typeof injectMixins
   injectMixins: typeof injectMixins
@@ -355,7 +305,7 @@ export interface Mpx {
 
   // watch: typeof watch
 
-  use (plugin: ((...args: any) => any) | { install: (...args: any) => any, [key: string]: any }, ...rest: any): Mpx
+  use (plugin: Plugin, ...rest: any[]): Mpx
 
   implement (name: string, options?: ImplementOptions): void
 
@@ -488,9 +438,8 @@ type WatchCallback<T> = (
 
 type WatchSource<T> =
   | Ref<T> // ref
-  | ComputedRef<T>
-  | Reactive<T>
   | (() => T) // getter
+  | ComputedRef<T>
 
 type MultiWatchSources = (WatchSource<unknown> | object)[]
 
@@ -498,7 +447,7 @@ interface WatchEffectOptions {
   flush?: 'pre' | 'post' | 'sync' // default: 'pre'
 }
 
-interface WatchOptions extends WatchEffectOptions {
+export interface WatchOptions extends WatchEffectOptions {
   immediate?: boolean // 默认：false
   deep?: boolean // 默认：false
   flush?: 'pre' | 'post' | 'sync' // 默认：'pre'
@@ -652,6 +601,22 @@ export function onHide (callback: () => void): void
 
 export function onResize (callback: () => void): void
 
+export function onPullDownRefresh (callback: () => void): void
+
+export function onReachBottom (callback: () => void): void
+
+export function onShareAppMessage (callback: () => void): void
+
+export function onShareTimeline (callback: () => void): void
+
+export function onAddToFavorites (callback: () => void): void
+
+export function onPageScroll (callback: () => void): void
+
+export function onTabItemTap (callback: () => void): void
+
+export function onSaveExitState (callback: () => void): void
+
 // get instance
 export function getCurrentInstance<T extends object> (): { target: T }
 
@@ -682,7 +647,7 @@ export const ONRESIZE: string
 
 declare global {
   const defineProps: <T>(props: T) => Readonly<GetPropsType<T>>
-  const defineOptions: <D extends Data = {}, P extends Properties = {}, C = {}, M extends Methods = {}, Mi extends Array<any> = [], O = {}> (opt: ThisTypedComponentOpt<D, P, C, M, Mi, O>) => void
-  const defineExpose: <E extends Record<string, any> = Record<string, any>>(exposed?: E) => void
+  const defineOptions: <D extends Data = {}, P extends Properties = {}, C = {}, M extends Methods = {}, Mi extends Array<any> = [], S extends AnyObject = {}, O extends AnyObject = {}> (opt: ThisTypedComponentOpt<D, P, C, M, Mi, S, O>) => void
+  const defineExpose: <E extends AnyObject = AnyObject>(exposed?: E) => void
   const useContext: () => Context
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpxjs/core",
-  "version": "2.8.0-beta.2",
+  "version": "2.8.0-beta.4",
   "description": "mpx runtime core",
   "keywords": [
     "miniprogram",
@@ -19,7 +19,7 @@
   ],
   "main": "src/index.js",
   "dependencies": {
-    "@mpxjs/utils": "^2.8.0-beta.2",
+    "@mpxjs/utils": "^2.8.0-beta.4",
     "lodash": "^4.1.1",
     "miniprogram-api-typings": "^3.0.2"
   },
@@ -47,5 +47,5 @@
     "url": "https://github.com/didi/mpx/issues"
   },
   "sideEffects": false,
-  "gitHead": "cd57f83a9d47236f527bd51a8650119514f4b433"
+  "gitHead": "7a3dd6c2d0fceb31ee035e85b7f11091e31409d3"
 }

package/src/core/implement.js

@@ -2,7 +2,7 @@ import { noop } from '@mpxjs/utils'
 
 export const implemented = {}
 
-export function implement (name, { modes = [], processor = noop(), remove = false } = {}) {
+export function implement (name, { modes = [], processor = noop, remove = false } = {}) {
   if (!name) return
   if (modes.indexOf(__mpx_mode__) > -1) {
     processor()

package/src/core/proxy.js

@@ -207,6 +207,8 @@ export default class MpxProxy {
     if (this.options.__type__ === 'page' && !this.options.__pageCtor__) {
       proxy(this.target, this.options, this.options.mpxCustomKeysForBlend, false, this.createProxyConflictHandler('page options'))
     }
+    // 挂载$rawOptions
+    this.target.$rawOptions = this.options
     if (__mpx_mode__ !== 'web') {
       // 挂载$watch
       this.target.$watch = this.watch.bind(this)

package/src/observer/array.js

@@ -1,5 +1,5 @@
 import { getObserver } from './reactive'
-import { def } from '@mpxjs/utils'
+import { def } from '@mpxjs/utils/src/base'
 
 const arrayProto = Array.prototype
 

package/src/platform/builtInMixins/pageStatusMixin.web.js

@@ -4,7 +4,8 @@ import {
   ONSHOW,
   ONLOAD
 } from '../../core/innerLifecycle'
-import { isFunction, isBrowser } from '@mpxjs/utils'
+import { isFunction } from '@mpxjs/utils'
+import { isBrowser } from '@mpxjs/utils/src/env'
 
 let systemInfo = {}
 

package/src/platform/builtInMixins/refsMixin.js

@@ -1,5 +1,6 @@
 import { CREATED, BEFOREMOUNT, BEFOREUPDATE, UNMOUNTED } from '../../core/innerLifecycle'
-import { noop, error, getEnvObj } from '@mpxjs/utils'
+import { noop, error } from '@mpxjs/utils'
+import { getEnvObj } from '@mpxjs/utils/src/env'
 
 const envObj = getEnvObj()
 

package/src/platform/createApp.js

@@ -1,7 +1,8 @@
 import transferOptions from '../core/transferOptions'
 import mergeOptions from '../core/mergeOptions'
 import builtInKeysMap from './patch/builtInKeysMap'
-import { makeMap, spreadProp } from '@mpxjs/utils'
+import { spreadProp } from '@mpxjs/utils'
+import { makeMap } from '@mpxjs/utils/src/array'
 import * as webLifecycle from '../platform/patch/web/lifecycle'
 import Mpx from '../index'
 

package/src/platform/export/index.web.js

@@ -1,3 +1,10 @@
+import {
+  effectScope as vueEffectScope,
+  getCurrentScope as getCurrentVueScope,
+  onScopeDispose,
+  getCurrentInstance as getCurrentVueInstance
+} from 'vue'
+
 export {
   // watch
   watchEffect,
@@ -21,14 +28,31 @@ export {
   shallowRef,
   triggerRef,
   // computed
-  computed,
-  // effectScope
+  computed
+} from 'vue'
+
+const noop = () => {
+}
+
+const fixEffectScope = (scope) => {
+  scope.pause = noop
+  scope.resume = noop
+}
+
+const effectScope = (detached) => fixEffectScope(vueEffectScope(detached))
+const getCurrentScope = () => fixEffectScope(getCurrentVueScope())
+
+export {
   effectScope,
   getCurrentScope,
-  onScopeDispose,
-  // instance
+  onScopeDispose
+}
+
+const getCurrentInstance = () => getCurrentVueInstance()?.__mpxProxy
+
+export {
   getCurrentInstance
-} from 'vue'
+}
 
 export {
   // i18n

package/src/platform/patch/builtInKeysMap.js

@@ -1,5 +1,5 @@
 import { INNER_LIFECYCLES } from '../../core/innerLifecycle'
-import { makeMap } from '@mpxjs/utils'
+import { makeMap } from '@mpxjs/utils/src/array'
 
 let bulitInKeys
 

package/src/platform/patch/web/getDefaultOptions.js

@@ -1,7 +1,7 @@
 import builtInKeysMap from '../builtInKeysMap'
 import mergeOptions from '../../../core/mergeOptions'
 import { diffAndCloneA } from '@mpxjs/utils'
-import { getCurrentInstance as getVueCurrentInstance } from '../../export/index'
+import { getCurrentInstance as getCurrentVueInstance } from '../../export/index'
 import MpxProxy, { setCurrentInstance, unsetCurrentInstance } from '../../../core/proxy'
 import { BEFOREUPDATE, UPDATED, BEFOREUNMOUNT, UNMOUNTED } from '../../../core/innerLifecycle'
 
@@ -37,7 +37,7 @@ export function getDefaultOptions (type, { rawOptions = {} }) {
   const rawSetup = rawOptions.setup
   if (rawSetup) {
     rawOptions.setup = (props) => {
-      const instance = getVueCurrentInstance().proxy
+      const instance = getCurrentVueInstance().proxy
       initProxy(instance, rawOptions)
       setCurrentInstance(instance.__mpxProxy)
       const newContext = {

package/@types/mpx-store.d.ts

@@ -1,333 +0,0 @@
-declare namespace MpxStore {
-  type UnboxDepField<D, F> = F extends keyof D ? D[F] : {}
-
-  interface  compContext{
-    __mpxProxy: object;
-    [key: string]: any
-  }
-
-  interface Deps {
-    [key: string]: Store | StoreWithThis
-  }
-
-  type UnboxDepsField<D extends Deps, F> = string extends keyof D ? {} : {
-    [K in keyof D]: UnboxDepField<D[K], F>
-  }
-
-  type getMutation<M> = M extends (state: any, ...payload: infer P) => infer R ? (...payload: P) => R : never
-
-  type getAction<A> = A extends (context: object, ...payload: infer P) => infer R ? (...payload: P) => R : never
-
-  type Mutations<S> = {
-    [key: string]: (this: void, state: S, ...payload: any[]) => any
-  }
-
-  interface Getters<S> {
-    [key: string]: (this: void, state: S, getters: any, globalState: any) => any
-  }
-
-  type Actions<S, G extends Getters<S>> = {
-    [key: string]: (this: void, context: {
-      rootState: any,
-      state: S,
-      getters: GetGetters<G>,
-      dispatch: (type: string, ...payload: any[]) => any,
-      commit: (type: string, ...payload: any[]) => any
-    }, ...payload: any[]) => any
-  }
-
-  type GetGetters<G> = {
-    readonly [K in keyof G]: G[K] extends (state: any, getters: any, globalState: any) => infer R ? R : G[K]
-  }
-
-  type GetMutations<M> = {
-    [K in keyof M]: getMutation<M[K]>
-  }
-
-  type GetActions<A> = {
-    [K in keyof A]: getAction<A[K]>
-  }
-
-  type GetDispatch<A, D> = keyof D extends never ? (<T extends keyof A>(type: T, ...payload: A[T] extends (context: any, ...payload: infer P) => any ? P : never) => A[T] extends (context: any, ...payload: any[]) => infer R ? R : never) : ((type: string, ...payload: any[]) => any)
-
-  type GetCommit<M, D> = keyof D extends never ? (<T extends keyof M>(type: T, ...payload: M[T] extends (state: any, ...payload: infer P) => any ? P : never) => M[T] extends (state: any, ...payload: any[]) => infer R ? R : never) : ((type: string, ...payload: any[]) => any)
-
-  interface Store<S = {}, G = {}, M = {}, A = {}, D extends Deps = {}> {
-
-    __deps: D
-    __state: S
-    __getters: GetGetters<G>
-
-    state: S & UnboxDepsField<D, 'state'>
-    getters: GetGetters<G> & UnboxDepsField<D, 'getters'>
-    mutations: GetMutations<M> & UnboxDepsField<D, 'mutations'>
-    actions: GetActions<A> & UnboxDepsField<D, 'actions'>
-
-    dispatch: GetDispatch<A, D>
-
-    commit: GetCommit<M, D>
-
-    mapState<K extends keyof S>(maps: K[]): {
-      [I in K]: () => S[I]
-    }
-    mapState(depPath: string, maps: string[]): object
-
-    // mapState support object
-    mapState<T extends { [key: string]: keyof GetAllMapKeys<S, D, 'state'> }>(obj: T): {
-      [I in keyof T]: () => GetAllMapKeys<S, D, 'state'>[T[I]]
-    }
-
-    mapGetters<K extends keyof G>(maps: K[]): {
-      [I in K]: () => GetGetters<G>[I]
-    }
-    mapGetters(depPath: string, maps: string[]): {
-      [key: string]: () => any
-    }
-
-    mapMutations<K extends keyof M>(maps: K[]): Pick<GetMutations<M>, K>
-    mapMutations(depPath: string, maps: string[]): {
-      [key: string]: (...payloads: any[]) => any
-    }
-
-    mapActions<K extends keyof A>(maps: K[]): Pick<GetActions<A>, K>
-    mapActions(depPath: string, maps: string[]): {
-      [key: string]: (...payloads: any[]) => any
-    }
-    // 下面是新增的异步store的接口类型
-    mapStateToInstance<K extends keyof S>(maps: K[], context: compContext): void
-    mapStateToInstance(depPath: string, maps: string[], context: compContext): void
-
-    // mapState support object
-    mapStateToInstance<T extends { [key: string]: keyof GetAllMapKeys<S, D, 'state'> }>(obj: T, context: compContext): void
-
-    mapGettersToInstance<K extends keyof G>(maps: K[], context: compContext): void
-    mapGettersToInstance(depPath: string, maps: string[], context: compContext): void
-
-    mapMutationsToInstance<K extends keyof M>(maps: K[], context: compContext): Pick<GetMutations<M>, K>
-    mapMutationsToInstance(depPath: string, maps: string[], context: compContext): void
-
-    mapActionsToInstance<K extends keyof A>(maps: K[], context: compContext): Pick<GetActions<A>, K>
-    mapActionsToInstance(depPath: string, maps: string[], context: compContext): void
-  }
-  type GetComputedSetKeys<T> = {
-    [K in keyof T]: T[K] extends {
-      get(): any,
-      set(val: any): void
-    } ? K : never
-  }[keyof T]
-
-  type GetComputedType<T> = {
-    readonly [K in Exclude<keyof T, GetComputedSetKeys<T>>]: T[K] extends () => infer R ? R : T[K]
-  } & {
-      [K in GetComputedSetKeys<T>]: T[K] extends {
-        get(): infer R,
-        set(val: any): void
-      } ? R : T[K]
-    }
-
-  interface MutationsAndActionsWithThis {
-    [key: string]: (...payload: any[]) => any
-  }
-
-  type UnionToIntersection<U> = (U extends any
-    ? (k: U) => void
-    : never) extends ((k: infer I) => void)
-    ? I
-    : never;
-
-  interface mapStateFunctionType<S, G> {
-    [key: string]: (state: S, getter: G) => any
-  }
-  interface DeeperMutationsAndActions {
-    [key: string]: ((...payload: any[]) => any) | MutationsAndActionsWithThis
-  }
-
-  interface DeeperStateAndGetters {
-    [key: string]: any | DeeperStateAndGetters
-  }
-
-  /**
-   * remove compatible code in Mpx.
-   * if you need using createStoreWithThis mix with createStore
-   * you can add a global define file
-   * use Declaration Merging(https://www.typescriptlang.org/docs/handbook/declaration-merging.html) on CompatibleDispatch:
-   * @example
-   * declare module MpxStore {
-   *  interface CompatibleDispatch {
-   *    dispatch(type: string, ...payload: any[]): any
-   *    commit(type: string, ...payload: any[]): any
-   *  }
-   * }
-   */
-  interface CompatibleDispatch {
-    // dispatch(type: string, ...payload: any[]): any
-    // commit(type: string, ...payload: any[]): any
-  }
-
-  // Store Type Bindings
-  type StringKeyof<T> = Exclude<keyof T, symbol>
-
-  type CombineStringKey<H extends string | number, L extends string | number> = H extends '' ? `${L}` : `${H}.${L}`
-
-  type GetActionsKey<A, P extends string | number = ''> = UnionToIntersection<{
-    [K in StringKeyof<A>]: {
-      [RK in CombineStringKey<P, K>]: A[K] extends DeeperMutationsAndActions ? GetActionsKey<A[K], RK> : Record<RK, A[K]>
-    }[CombineStringKey<P, K>]
-  }[StringKeyof<A>]> // {actA: () => void, storeB.actB: () => void}
-
-  type GetStateAndGettersKey<D extends Deps, DK extends keyof D, T extends 'state' | 'getters', P extends string | number = ''> = UnionToIntersection<{
-    [K in StringKeyof<D[DK][`__${T}`]>]: {
-      [RK in CombineStringKey<P, K>]: D[DK][`__${T}`][K]
-    }
-  }[StringKeyof<D[DK][`__${T}`]>] | {
-    [K in StringKeyof<D[DK]['__deps']>]: GetStateAndGettersKey<D[DK]['__deps'], K, T, CombineStringKey<P, K>>
-  }[StringKeyof<D[DK]['__deps']>]>
-
-  // type GetStateAndGettersKey<S, P extends string | number = ''> = UnionToIntersection<{
-  //   [K in StringKeyof<S>]: {
-  //     [RK in CombineStringKey<P, K>]: S[K] extends DeeperStateAndGetters ? GetStateAndGettersKey<S[K], RK> : Record<RK, S[K]>
-  //   }[CombineStringKey<P, K>]
-  // }[StringKeyof<S>]> // {stateA: any, storeB.stateB: any}
-
-  type GetAllDepsType<A, D extends Deps, AK extends 'state' | 'getters' | 'actions' | 'mutations'> = {
-    [K in StringKeyof<A>]: A[K]
-  } & UnionToIntersection<{
-    [K in StringKeyof<D>]: AK extends 'actions' | 'mutations' ? {
-      [P in keyof GetActionsKey<D[K][AK], K>]: GetActionsKey<D[K][AK], K>[P]
-    } : AK extends 'state' | 'getters' ? { // state, getters
-      [P in keyof GetStateAndGettersKey<D, K, AK, K>]: GetStateAndGettersKey<D, K, AK, K>[P]
-      // [P in keyof GetStateAndGettersKey<D[K][AK], K>]: GetStateAndGettersKey<D[K][AK], K>[P]
-    } : {}
-  }[StringKeyof<D>]>
-  type GetDispatchAndCommitWithThis<A, D extends Deps, AK extends 'actions' | 'mutations'> = (<T extends keyof GetAllDepsType<A, D, AK>>(type: T, ...payload: GetAllDepsType<A, D, AK>[T] extends (...payload: infer P) => any ? P : never) => GetAllDepsType<A, D, AK>[T] extends (...payload: any[]) => infer R ? R : never)
-
-  // type GetAllMapKeys<S, D extends Deps, SK extends 'state' | 'getters'> = GetAllDepsType<S, D, SK> & GetStateAndGettersKey<S>
-  type GetAllMapKeys<S, D extends Deps, SK extends 'state' | 'getters'> = GetAllDepsType<S, D, SK> // 关闭对state、getters本身传入对象的深层次推导，因为过深的递归会导致ts推导直接挂掉
-
-  interface StoreOptWithThis<S, G, M, A, D extends Deps> {
-    state?: S
-    getters?: G & ThisType<{ state: S & UnboxDepsField<D, 'state'>, getters: GetComputedType<G> & UnboxDepsField<D, 'getters'>, rootState: any }>
-    mutations?: M & ThisType<{ state: S & UnboxDepsField<D, 'state'> }>
-    actions?: A & ThisType<{
-      rootState: any,
-      state: S & UnboxDepsField<D, 'state'>,
-      getters: GetComputedType<G> & UnboxDepsField<D, 'getters'>,
-      dispatch: GetDispatchAndCommitWithThis<A, D, 'actions'>,
-      commit: GetDispatchAndCommitWithThis<M, D, 'mutations'>
-    } & CompatibleDispatch>
-    deps?: D
-    modules?: Record<string, StoreOptWithThis<{}, {}, {}, {}, {}>>
-  }
-
-  interface IStoreWithThis<S = {}, G = {}, M = {}, A = {}, D extends Deps = {}> {
-
-    __deps: D
-    __state: S
-    __getters: GetComputedType<G>
-
-    state: S & UnboxDepsField<D, 'state'>
-    getters: GetComputedType<G> & UnboxDepsField<D, 'getters'>
-    mutations: M & UnboxDepsField<D, 'mutations'>
-    actions: A & UnboxDepsField<D, 'actions'>
-
-    dispatch: GetDispatchAndCommitWithThis<A, D, 'actions'>
-
-    commit: GetDispatchAndCommitWithThis<M, D, 'mutations'>
-
-    mapState<K extends keyof S>(maps: K[]): {
-      [I in K]: () => S[I]
-    }
-    mapState<T extends string, P extends string>(depPath: P, maps: readonly T[]): {
-      [K in T]: () => (CombineStringKey<P, K> extends keyof GetAllMapKeys<S, D, 'state'> ? GetAllMapKeys<S, D, 'state'>[CombineStringKey<P, K>] : any)
-    }
-    mapState<T extends mapStateFunctionType<S & UnboxDepsField<D, 'state'>, GetComputedType<G> & UnboxDepsField<D, 'getters'>>>(obj: ThisType<any> & T): {
-      [I in keyof T]: () => ReturnType<T[I]>
-    }
-    // Support chain derivation
-    mapState<T extends { [key: string]: keyof GetAllMapKeys<S, D, 'state'> }>(obj: T): {
-      [I in keyof T]: () => GetAllMapKeys<S, D, 'state'>[T[I]]
-    }
-    mapState<T extends { [key: string]: keyof S }>(obj: T): {
-      [I in keyof T]: () => S[T[I]]
-    }
-    mapState<T extends { [key: string]: string }>(obj: T): {
-      [I in keyof T]: (...payloads: any[]) => any
-    }
-
-    mapGetters<K extends keyof G>(maps: K[]): Pick<G, K>
-    mapGetters<T extends string, P extends string>(depPath: P, maps: readonly T[]): {
-      // use GetComputedType to get getters' returns
-      [K in T]: () => (CombineStringKey<P, K> extends keyof GetAllMapKeys<GetComputedType<G>, D, 'getters'> ? GetAllMapKeys<GetComputedType<G>, D, 'getters'>[CombineStringKey<P, K>] : any)
-    }
-    // Support chain derivation
-    mapGetters<T extends { [key: string]: keyof GetAllMapKeys<GetComputedType<G>, D, 'getters'> }>(obj: T): {
-      [I in keyof T]: () => GetAllMapKeys<GetComputedType<G>, D, 'getters'>[T[I]]
-    }
-    mapGetters<T extends { [key: string]: keyof G }>(obj: T): {
-      [I in keyof T]: G[T[I]]
-    }
-    // When importing js in ts file, use this method to be compatible
-    mapGetters<T extends { [key: string]: string }>(obj: T): {
-      [I in keyof T]: (...payloads: any[]) => any
-    }
-
-    mapMutations<K extends keyof M>(maps: K[]): Pick<M, K>
-    mapMutations<T extends string, P extends string>(depPath: P, maps: readonly T[]): {
-      [K in T]: CombineStringKey<P, K> extends keyof GetAllDepsType<M, D, 'mutations'> ? GetAllDepsType<M, D, 'mutations'>[CombineStringKey<P, K>] : (...payloads: any[]) => any
-    }
-    mapMutations<T extends { [key: string]: keyof M }>(obj: T): {
-      [I in keyof T]: M[T[I]]
-    }
-    mapMutations<T extends { [key: string]: string }>(obj: T): {
-      [I in keyof T]: (...payloads: any[]) => any
-    }
-
-    mapActions<K extends keyof A>(maps: K[]): Pick<A, K>
-    mapActions<T extends string, P extends string>(depPath: P, maps: readonly T[]): {
-      [K in T]: CombineStringKey<P, K> extends keyof GetAllDepsType<A, D, 'actions'> ? GetAllDepsType<A, D, 'actions'>[CombineStringKey<P, K>] : (...payloads: any[]) => any
-    }
-    mapActions<T extends { [key: string]: keyof A }>(obj: T): {
-      [I in keyof T]: A[T[I]]
-    }
-    mapActions<T extends { [key: string]: string }>(obj: T): {
-      [I in keyof T]: (...payloads: any[]) => any
-    }
-    // 异步store api
-    mapStateToInstance<K extends keyof S>(maps: K[], context: compContext): void
-    mapStateToInstance<T extends string, P extends string>(depPath: P, maps: readonly T[], context: compContext):void
-    mapStateToInstance<T extends mapStateFunctionType<S & UnboxDepsField<D, 'state'>, GetComputedType<G> & UnboxDepsField<D, 'getters'>>>(obj: ThisType<any> & T, context: compContext): void
-    // Support chain derivation
-    mapStateToInstance<T extends { [key: string]: keyof GetAllMapKeys<S, D, 'state'> }>(obj: T, context: compContext): void
-    mapStateToInstance<T extends { [key: string]: keyof S }>(obj: T, context: compContext): void
-    mapStateToInstance<T extends { [key: string]: string }>(obj: T, context: compContext): void
-
-    mapGettersToInstance<K extends keyof G>(maps: K[], context: compContext): void
-    mapGettersToInstance<T extends string, P extends string>(depPath: P, maps: readonly T[], context: compContext): void
-    // Support chain derivation
-    mapGettersToInstance<T extends { [key: string]: keyof GetAllMapKeys<GetComputedType<G>, D, 'getters'> }>(obj: T, context: compContext): void
-    mapGettersToInstance<T extends { [key: string]: keyof G }>(obj: T, context: compContext): void
-    // When importing js in ts file, use this method to be compatible
-    mapGettersToInstance<T extends { [key: string]: string }>(obj: T, context: compContext): void
-
-    mapMutationsToInstance<K extends keyof M>(maps: K[], context: compContext): void
-    mapMutationsToInstance<T extends string, P extends string>(depPath: P, maps: readonly T[], context: compContext): void
-    mapMutationsToInstance<T extends { [key: string]: keyof M }>(obj: T, context: compContext): void
-    mapMutationsToInstance<T extends { [key: string]: string }>(obj: T, context: compContext): void
-
-    mapActionsToInstance<K extends keyof A>(maps: K[], context: compContext): void
-    mapActionsToInstance<T extends string, P extends string>(depPath: P, maps: readonly T[], context: compContext): void
-    mapActionsToInstance<T extends { [key: string]: keyof A }>(obj: T, context: compContext): void
-    mapActionsToInstance<T extends { [key: string]: string }>(obj: T, context: compContext): void
-  }
-
-  type StoreWithThis<S = {}, G = {}, M = {}, A = {}, D extends Deps = {}> = IStoreWithThis<S, G, M, A, D> & CompatibleDispatch
-
-  interface StoreOpt<S, G, M, A, D extends Deps> {
-    state?: S,
-    getters?: G
-    mutations?: M,
-    actions?: A,
-    deps?: D
-    modules?: Record<string, StoreOpt<{}, {}, {}, {}, {}>>
-  }
-}