@mpxjs/core 2.8.0-beta.3 → 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'
@@ -698,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/LICENSE

@@ -0,0 +1,433 @@
+                              Apache License
+
+                        Version 2.0, January 2004
+
+                     http://www.apache.org/licenses/
+
+
+
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+
+
+
+1. Definitions.
+
+
+
+
+   "License" shall mean the terms and conditions for use, reproduction,
+
+   and distribution as defined by Sections 1 through 9 of this document.
+
+
+
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+
+   the copyright owner that is granting the License.
+
+
+
+
+   "Legal Entity" shall mean the union of the acting entity and all
+
+   other entities that control, are controlled by, or are under common
+
+   control with that entity. For the purposes of this definition,
+
+   "control" means (i) the power, direct or indirect, to cause the
+
+   direction or management of such entity, whether by contract or
+
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+
+
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+
+   exercising permissions granted by this License.
+
+
+
+
+   "Source" form shall mean the preferred form for making modifications,
+
+   including but not limited to software source code, documentation
+
+   source, and configuration files.
+
+
+
+
+   "Object" form shall mean any form resulting from mechanical
+
+   transformation or translation of a Source form, including but
+
+   not limited to compiled object code, generated documentation,
+
+   and conversions to other media types.
+
+
+
+
+   "Work" shall mean the work of authorship, whether in Source or
+
+   Object form, made available under the License, as indicated by a
+
+   copyright notice that is included in or attached to the work
+
+   (an example is provided in the Appendix below).
+
+
+
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+
+   form, that is based on (or derived from) the Work and for which the
+
+   editorial revisions, annotations, elaborations, or other modifications
+
+   represent, as a whole, an original work of authorship. For the purposes
+
+   of this License, Derivative Works shall not include works that remain
+
+   separable from, or merely link (or bind by name) to the interfaces of,
+
+   the Work and Derivative Works thereof.
+
+
+
+
+   "Contribution" shall mean any work of authorship, including
+
+   the original version of the Work and any modifications or additions
+
+   to that Work or Derivative Works thereof, that is intentionally
+
+   submitted to Licensor for inclusion in the Work by the copyright owner
+
+   or by an individual or Legal Entity authorized to submit on behalf of
+
+   the copyright owner. For the purposes of this definition, "submitted"
+
+   means any form of electronic, verbal, or written communication sent
+
+   to the Licensor or its representatives, including but not limited to
+
+   communication on electronic mailing lists, source code control systems,
+
+   and issue tracking systems that are managed by, or on behalf of, the
+
+   Licensor for the purpose of discussing and improving the Work, but
+
+   excluding communication that is conspicuously marked or otherwise
+
+   designated in writing by the copyright owner as "Not a Contribution."
+
+
+
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+
+   on behalf of whom a Contribution has been received by Licensor and
+
+   subsequently incorporated within the Work.
+
+
+
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+
+   this License, each Contributor hereby grants to You a perpetual,
+
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+
+   copyright license to reproduce, prepare Derivative Works of,
+
+   publicly display, publicly perform, sublicense, and distribute the
+
+   Work and such Derivative Works in Source or Object form.
+
+
+
+
+3. Grant of Patent License. Subject to the terms and conditions of
+
+   this License, each Contributor hereby grants to You a perpetual,
+
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+
+   (except as stated in this section) patent license to make, have made,
+
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+
+   where such license applies only to those patent claims licensable
+
+   by such Contributor that are necessarily infringed by their
+
+   Contribution(s) alone or by combination of their Contribution(s)
+
+   with the Work to which such Contribution(s) was submitted. If You
+
+   institute patent litigation against any entity (including a
+
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+
+   or a Contribution incorporated within the Work constitutes direct
+
+   or contributory patent infringement, then any patent licenses
+
+   granted to You under this License for that Work shall terminate
+
+   as of the date such litigation is filed.
+
+
+
+
+4. Redistribution. You may reproduce and distribute copies of the
+
+   Work or Derivative Works thereof in any medium, with or without
+
+   modifications, and in Source or Object form, provided that You
+
+   meet the following conditions:
+
+
+
+
+   (a) You must give any other recipients of the Work or
+
+       Derivative Works a copy of this License; and
+
+
+
+
+   (b) You must cause any modified files to carry prominent notices
+
+       stating that You changed the files; and
+
+
+
+
+   (c) You must retain, in the Source form of any Derivative Works
+
+       that You distribute, all copyright, patent, trademark, and
+
+       attribution notices from the Source form of the Work,
+
+       excluding those notices that do not pertain to any part of
+
+       the Derivative Works; and
+
+
+
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+
+       distribution, then any Derivative Works that You distribute must
+
+       include a readable copy of the attribution notices contained
+
+       within such NOTICE file, excluding those notices that do not
+
+       pertain to any part of the Derivative Works, in at least one
+
+       of the following places: within a NOTICE text file distributed
+
+       as part of the Derivative Works; within the Source form or
+
+       documentation, if provided along with the Derivative Works; or,
+
+       within a display generated by the Derivative Works, if and
+
+       wherever such third-party notices normally appear. The contents
+
+       of the NOTICE file are for informational purposes only and
+
+       do not modify the License. You may add Your own attribution
+
+       notices within Derivative Works that You distribute, alongside
+
+       or as an addendum to the NOTICE text from the Work, provided
+
+       that such additional attribution notices cannot be construed
+
+       as modifying the License.
+
+
+
+
+   You may add Your own copyright statement to Your modifications and
+
+   may provide additional or different license terms and conditions
+
+   for use, reproduction, or distribution of Your modifications, or
+
+   for any such Derivative Works as a whole, provided Your use,
+
+   reproduction, and distribution of the Work otherwise complies with
+
+   the conditions stated in this License.
+
+
+
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+
+   any Contribution intentionally submitted for inclusion in the Work
+
+   by You to the Licensor shall be under the terms and conditions of
+
+   this License, without any additional terms or conditions.
+
+   Notwithstanding the above, nothing herein shall supersede or modify
+
+   the terms of any separate license agreement you may have executed
+
+   with Licensor regarding such Contributions.
+
+
+
+
+6. Trademarks. This License does not grant permission to use the trade
+
+   names, trademarks, service marks, or product names of the Licensor,
+
+   except as required for reasonable and customary use in describing the
+
+   origin of the Work and reproducing the content of the NOTICE file.
+
+
+
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+
+   agreed to in writing, Licensor provides the Work (and each
+
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+
+   implied, including, without limitation, any warranties or conditions
+
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+
+   appropriateness of using or redistributing the Work and assume any
+
+   risks associated with Your exercise of permissions under this License.
+
+
+
+
+8. Limitation of Liability. In no event and under no legal theory,
+
+   whether in tort (including negligence), contract, or otherwise,
+
+   unless required by applicable law (such as deliberate and grossly
+
+   negligent acts) or agreed to in writing, shall any Contributor be
+
+   liable to You for damages, including any direct, indirect, special,
+
+   incidental, or consequential damages of any character arising as a
+
+   result of this License or out of the use or inability to use the
+
+   Work (including but not limited to damages for loss of goodwill,
+
+   work stoppage, computer failure or malfunction, or any and all
+
+   other commercial damages or losses), even if such Contributor
+
+   has been advised of the possibility of such damages.
+
+
+
+
+9. Accepting Warranty or Additional Liability. While redistributing
+
+   the Work or Derivative Works thereof, You may choose to offer,
+
+   and charge a fee for, acceptance of support, warranty, indemnity,
+
+   or other liability obligations and/or rights consistent with this
+
+   License. However, in accepting such obligations, You may act only
+
+   on Your own behalf and on Your sole responsibility, not on behalf
+
+   of any other Contributor, and only if You agree to indemnify,
+
+   defend, and hold each Contributor harmless for any liability
+
+   incurred by, or claims asserted against, such Contributor by reason
+
+   of your accepting any such warranty or additional liability.
+
+
+
+
+END OF TERMS AND CONDITIONS
+
+
+
+
+APPENDIX: How to apply the Apache License to your work.
+
+
+
+
+   To apply the Apache License to your work, attach the following
+
+   boilerplate notice, with the fields enclosed by brackets "{}"
+
+   replaced with your own identifying information. (Don't include
+
+   the brackets!)  The text should be enclosed in the appropriate
+
+   comment syntax for the file format. We also recommend that a
+
+   file or class name and description of purpose be included on the
+
+   same "printed page" as the copyright notice for easier
+
+   identification within third-party archives.
+
+
+
+
+Copyright (C) 2017 Beijing Didi Infinity Technology and Development Co.,Ltd. All rights reserved.
+
+
+
+
+Licensed under the Apache License, Version 2.0 (the "License");
+
+you may not use this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+
+
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+
+
+
+Unless required by applicable law or agreed to in writing, software
+
+distributed under the License is distributed on an "AS IS" BASIS,
+
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+See the License for the specific language governing permissions and
+
+limitations under the License.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpxjs/core",
-  "version": "2.8.0-beta.3",
+  "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": "2d37697869b9bdda3efab92dda8c910b68fd05c0"
+  "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<{}, {}, {}, {}, {}>>
-  }
-}