@mpxjs/core 2.9.70-alpha.0 → 2.9.71

package/src/observer/reactive.js

@@ -34,6 +34,7 @@ export class Observer {
 
   constructor (value, shallow) {
     this.value = value
+    this.shallow = shallow
     def(value, ObKey, this)
     if (Array.isArray(value)) {
       const augment = hasProto && arrayProtoAugment
@@ -120,7 +121,7 @@ export function defineReactive (obj, key, val, shallow) {
   const getter = property && property.get
   const setter = property && property.set
 
-  let childOb = !shallow && observe(val)
+  let childOb = shallow ? getObserver(val) : observe(val)
   Object.defineProperty(obj, key, {
     enumerable: true,
     configurable: true,
@@ -149,7 +150,7 @@ export function defineReactive (obj, key, val, shallow) {
       } else {
         val = newVal
       }
-      childOb = !shallow && observe(newVal)
+      childOb = shallow ? getObserver(newVal) : observe(newVal)
       dep.notify()
     }
   })
@@ -175,7 +176,7 @@ export function set (target, key, val) {
     target[key] = val
     return val
   }
-  defineReactive(ob.value, key, val)
+  defineReactive(ob.value, key, val, ob.shallow)
   ob.dep.notify()
   return val
 }

package/src/platform/builtInMixins/directiveHelperMixin.ios.js

@@ -1,7 +1,10 @@
 export default function directiveHelperMixin () {
   return {
     methods: {
-      __getWxKey (item, key) {
+      __getWxKey (item, key, index) {
+        if (key === 'index') {
+          return index
+        }
         return key === '*this' ? item : item[key]
       }
     }

package/src/platform/builtInMixins/index.js

@@ -37,11 +37,6 @@ export default function getBuiltInMixins ({ type, rawOptions = {} }) {
       // 由于relation可能是通过mixin注入的，不能通过当前的用户options中是否存在relations来简单判断是否注入该项mixin
       relationsMixin(type)
     ]
-  } else if (__mpx_mode__ === 'tenon') {
-    bulitInMixins = [
-      proxyEventMixin(),
-      pageStatusMixin(type)
-    ]
   } else {
     // 此为差异抹平类mixins，原生模式下也需要注入也抹平平台差异
     bulitInMixins = [

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

@@ -1,4 +1,5 @@
-import { setByPath } from '@mpxjs/utils'
+import { setByPath, error, parseDataset } from '@mpxjs/utils'
+import Mpx from '../../index'
 
 export default function proxyEventMixin () {
   return {
@@ -19,11 +20,58 @@ export default function proxyEventMixin () {
         const value = filterMethod ? (innerFilter[filterMethod] ? innerFilter[filterMethod](originValue) : typeof this[filterMethod] === 'function' && this[filterMethod]) : originValue
         setByPath(this, expr, value)
       },
-      __invokeHandler (eventName, $event) {
-        const handler = this[eventName]
-        if (handler && typeof handler === 'function') {
-          handler.call(this, $event)
+      __invoke (rawEvent, eventConfig = []) {
+        if (typeof Mpx.config.proxyEventHandler === 'function') {
+          try {
+            Mpx.config.proxyEventHandler(rawEvent)
+          } catch (e) {}
         }
+        const location = this.__mpxProxy.options.mpxFileResource
+
+        if (rawEvent.target && !rawEvent.target._datasetProcessed) {
+          const originalDataset = rawEvent.target.dataset
+          Object.defineProperty(rawEvent.target, 'dataset', {
+            get: () => parseDataset(originalDataset),
+            configurable: true,
+            enumerable: true
+          })
+          rawEvent.target._datasetProcessed = true
+        }
+        if (rawEvent.currentTarget && !rawEvent.currentTarget._datasetProcessed) {
+          const originalDataset = rawEvent.currentTarget.dataset
+          Object.defineProperty(rawEvent.currentTarget, 'dataset', {
+            get: () => parseDataset(originalDataset),
+            configurable: true,
+            enumerable: true
+          })
+          rawEvent.currentTarget._datasetProcessed = true
+        }
+
+        let returnedValue
+        eventConfig.forEach((item) => {
+          const callbackName = item[0]
+          if (callbackName) {
+            const params =
+              item.length > 1
+                ? item.slice(1).map((item) => {
+                    if (item === '__mpx_event__') {
+                      return rawEvent
+                    } else {
+                      return item
+                    }
+                  })
+                : [rawEvent]
+            if (typeof this[callbackName] === 'function') {
+              returnedValue = this[callbackName].apply(this, params)
+            } else {
+              error(
+                `Instance property [${callbackName}] is not function, please check.`,
+                location
+              )
+            }
+          }
+        })
+        return returnedValue
       }
     }
   }

package/src/platform/builtInMixins/styleHelperMixin.ios.js

@@ -181,7 +181,7 @@ export default function styleHelperMixin () {
             } else if (appClassMap[className]) {
               // todo 全局样式在每个页面和组件中生效，以支持全局原子类，后续支持样式模块复用后可考虑移除
               Object.assign(result, appClassMap[className])
-            } else if (this.__props[className] && isObject(this.__props[className])) {
+            } else if (isObject(this.__props[className])) {
               // externalClasses必定以对象形式传递下来
               Object.assign(result, this.__props[className])
             }

package/src/platform/createApp.ios.js

@@ -1,12 +1,12 @@
 import transferOptions from '../core/transferOptions'
 import builtInKeysMap from './patch/builtInKeysMap'
-import { makeMap, spreadProp, parseUrlQuery, getFocusedNavigation, hasOwn, extend } from '@mpxjs/utils'
+import { makeMap, spreadProp, getFocusedNavigation, hasOwn } from '@mpxjs/utils'
 import { mergeLifecycle } from '../convertor/mergeLifecycle'
 import { LIFECYCLE } from '../platform/patch/lifecycle/index'
 import Mpx from '../index'
 import { createElement, memo, useRef, useEffect } from 'react'
 import * as ReactNative from 'react-native'
-import { ref } from '../observer/ref'
+import { Image } from 'react-native'
 
 const appHooksMap = makeMap(mergeLifecycle(LIFECYCLE).app)
 
@@ -29,22 +29,27 @@ function filterOptions (options, appData) {
   return newOptions
 }
 
-function createAppInstance (appData) {
-  return extend({}, Mpx.prototype, appData)
-}
-
-export default function createApp (option, config = {}) {
+export default function createApp (options) {
   const appData = {}
 
   const { NavigationContainer, createStackNavigator, SafeAreaProvider } = global.__navigationHelper
   // app选项目前不需要进行转换
-  const { rawOptions, currentInject } = transferOptions(option, 'app', false)
+  const { rawOptions, currentInject } = transferOptions(options, 'app', false)
   const defaultOptions = filterOptions(spreadProp(rawOptions, 'methods'), appData)
-  defaultOptions.onAppInit && defaultOptions.onAppInit()
   // 在页面script执行前填充getApp()
   global.getApp = function () {
     return appData
   }
+
+  // 模拟小程序appInstance在热启动时不会重新创建的行为，在外部创建跟随js context的appInstance
+  const appInstance = Object.assign({}, appData, Mpx.prototype)
+
+  defaultOptions.onShow && global.__mpxAppCbs.show.push(defaultOptions.onShow.bind(appInstance))
+  defaultOptions.onHide && global.__mpxAppCbs.hide.push(defaultOptions.onHide.bind(appInstance))
+  defaultOptions.onError && global.__mpxAppCbs.error.push(defaultOptions.onError.bind(appInstance))
+  defaultOptions.onUnhandledRejection && global.__mpxAppCbs.rejection.push(defaultOptions.onUnhandledRejection.bind(appInstance))
+  defaultOptions.onAppInit && defaultOptions.onAppInit()
+
   const pages = currentInject.getPages() || {}
   const firstPage = currentInject.firstPage
   const Stack = createStackNavigator()
@@ -80,63 +85,51 @@ export default function createApp (option, config = {}) {
     }
   }
 
-  global.__mpxAppCbs = global.__mpxAppCbs || {
-    show: [],
-    hide: [],
-    error: []
-  }
-
   global.__mpxAppLaunched = false
-
-  global.__mpxAppFocusedState = ref('show')
   global.__mpxOptionsMap[currentInject.moduleId] = memo((props) => {
-    const instanceRef = useRef(null)
-    if (!instanceRef.current) {
-      instanceRef.current = createAppInstance(appData)
-    }
-    const instance = instanceRef.current
+    const firstRef = useRef(true)
     const initialRouteRef = useRef({
       initialRouteName: firstPage,
       initialParams: {}
     })
+    if (firstRef.current) {
+      // 热启动情况下，app会被销毁重建，将__mpxAppHotLaunched重置保障路由等初始化逻辑正确执行
+      global.__mpxAppHotLaunched = false
+      // 热启动情况下重置__mpxPagesMap避免页面销毁函数未及时执行时错误地引用到之前的navigation
+      global.__mpxPagesMap = {}
+      firstRef.current = false
+    }
+    if (!global.__mpxAppHotLaunched) {
+      const { initialRouteName, initialParams } = Mpx.config.rnConfig.parseAppProps?.(props) || {}
+      initialRouteRef.current.initialRouteName = initialRouteName || initialRouteRef.current.initialRouteName
+      initialRouteRef.current.initialParams = initialParams || initialRouteRef.current.initialParams
 
-    if (!global.__mpxAppLaunched) {
-      const parsed = Mpx.config.rnConfig.parseAppProps?.(props) || {}
-      if (parsed.url) {
-        const { path, queryObj } = parseUrlQuery(parsed.url)
-        Object.assign(initialRouteRef.current, {
-          initialRouteName: path.startsWith('/') ? path.slice(1) : path,
-          initialParams: queryObj
-        })
-      }
       global.__mpxAppOnLaunch = (navigation) => {
-        global.__mpxAppLaunched = true
         const state = navigation.getState()
         Mpx.config.rnConfig.onStateChange?.(state)
         const current = state.routes[state.index]
-        global.__mpxEnterOptions = {
+        const options = {
           path: current.name,
           query: current.params,
           scene: 0,
           shareTicket: '',
-          referrerInfo: {}
+          referrerInfo: {},
+          isLaunch: true
         }
-        defaultOptions.onLaunch && defaultOptions.onLaunch.call(instance, global.__mpxEnterOptions)
-        defaultOptions.onShow && defaultOptions.onShow.call(instance, global.__mpxEnterOptions)
+        global.__mpxEnterOptions = options
+        if (!global.__mpxAppLaunched) {
+          global.__mpxLaunchOptions = options
+          defaultOptions.onLaunch && defaultOptions.onLaunch.call(appInstance, options)
+        }
+        global.__mpxAppCbs.show.forEach((cb) => {
+          cb(options)
+        })
+        global.__mpxAppLaunched = true
+        global.__mpxAppHotLaunched = true
       }
     }
 
     useEffect(() => {
-      if (defaultOptions.onShow) {
-        global.__mpxAppCbs.show.push(defaultOptions.onShow.bind(instance))
-      }
-      if (defaultOptions.onHide) {
-        global.__mpxAppCbs.hide.push(defaultOptions.onHide.bind(instance))
-      }
-      if (defaultOptions.onError) {
-        global.__mpxAppCbs.error.push(defaultOptions.onError.bind(instance))
-      }
-
       const changeSubscription = ReactNative.AppState.addEventListener('change', (currentState) => {
         if (currentState === 'active') {
           let options = global.__mpxEnterOptions
@@ -158,7 +151,7 @@ export default function createApp (option, config = {}) {
           if (navigation && hasOwn(global.__mpxPageStatusMap, navigation.pageId)) {
             global.__mpxPageStatusMap[navigation.pageId] = 'show'
           }
-        } else if (currentState === 'inactive') {
+        } else if (currentState === 'inactive' || currentState === 'background') {
           global.__mpxAppCbs.hide.forEach((cb) => {
             cb()
           })
@@ -187,6 +180,19 @@ export default function createApp (option, config = {}) {
     }, [])
 
     const { initialRouteName, initialParams } = initialRouteRef.current
+    const headerBackImageProps = Mpx.config.rnConfig.headerBackImageProps || null
+    const navScreenOpts = {
+      // 7.x替换headerBackTitleVisible
+      // headerBackButtonDisplayMode: 'minimal',
+      headerBackTitleVisible: false,
+      // 安卓上会出现初始化时闪现导航条的问题
+      headerShown: false
+    }
+    if (headerBackImageProps) {
+      navScreenOpts.headerBackImage = () => {
+        return createElement(Image, headerBackImageProps)
+      }
+    }
     return createElement(SafeAreaProvider,
       null,
       createElement(NavigationContainer,
@@ -197,13 +203,7 @@ export default function createApp (option, config = {}) {
         createElement(Stack.Navigator,
           {
             initialRouteName,
-            screenOptions: {
-              gestureEnabled: true,
-              // 7.x替换headerBackTitleVisible
-              // headerBackButtonDisplayMode: 'minimal',
-              headerBackTitleVisible: false,
-              headerMode: 'float'
-            }
+            screenOptions: navScreenOpts
           },
           ...getPageScreens(initialRouteName, initialParams)
         )

package/src/platform/createApp.js

@@ -5,7 +5,7 @@ import { makeMap, spreadProp, isBrowser } from '@mpxjs/utils'
 import { mergeLifecycle } from '../convertor/mergeLifecycle'
 import { LIFECYCLE } from '../platform/patch/lifecycle/index'
 import Mpx from '../index'
-import { initAppProvides } from './export/apiInject'
+import { initAppProvides } from './export/inject'
 
 const appHooksMap = makeMap(mergeLifecycle(LIFECYCLE).app)
 
@@ -24,19 +24,29 @@ function filterOptions (options, appData) {
   return newOptions
 }
 
-export default function createApp (option, config = {}) {
-  // 在App中挂载mpx对象供周边工具访问，如e2e测试
+export default function createApp (options, config = {}) {
+  const appData = {}
+  // app选项目前不需要进行转换
+  const { rawOptions, currentInject } = transferOptions(options, 'app', false)
   const builtInMixins = [{
+    // 在App中挂载mpx对象供周边工具访问，如e2e测试
     getMpx () {
       return Mpx
     }
   }]
-  const appData = {}
   if (__mpx_mode__ === 'web') {
     builtInMixins.push({
+      beforeCreate () {
+        // for vue provide vm access
+        Object.assign(this, appData, Mpx.prototype)
+        if (isBrowser) {
+          rawOptions.onShow && global.__mpxAppCbs.show.push(rawOptions.onShow.bind(this))
+          rawOptions.onHide && global.__mpxAppCbs.hide.push(rawOptions.onHide.bind(this))
+          rawOptions.onError && global.__mpxAppCbs.error.push(rawOptions.onError.bind(this))
+          rawOptions.onUnhandledRejection && global.__mpxAppCbs.rejection.push(rawOptions.onUnhandledRejection.bind(this))
+        }
+      },
       created () {
-        Object.assign(this, Mpx.prototype)
-        Object.assign(this, appData)
         const current = this.$root.$options?.router?.currentRoute || {}
         const options = {
           path: current.path && current.path.replace(/^\//, ''),
@@ -45,57 +55,36 @@ export default function createApp (option, config = {}) {
           shareTicket: '',
           referrerInfo: {}
         }
+        // web不分冷启动和热启动
         global.__mpxEnterOptions = options
-        this.$options.onLaunch && this.$options.onLaunch.call(this, options)
-        global.__mpxAppCbs = global.__mpxAppCbs || {
-          show: [],
-          hide: [],
-          error: []
-        }
-        if (isBrowser) {
-          if (this.$options.onShow) {
-            this.$options.onShow.call(this, options)
-            global.__mpxAppCbs.show.push(this.$options.onShow.bind(this))
-          }
-          if (this.$options.onHide) {
-            global.__mpxAppCbs.hide.push(this.$options.onHide.bind(this))
-          }
-          if (this.$options.onError) {
-            global.__mpxAppCbs.error.push(this.$options.onError.bind(this))
-          }
-        }
-      }
-    })
-  } else if (__mpx_mode__ === 'tenon') {
-    // todo add tenon mixins
-    builtInMixins.push({
-      onLaunch () {
-        // console.log('tenon mixins')
+        global.__mpxLaunchOptions = options
+        rawOptions.onLaunch && rawOptions.onLaunch.call(this, options)
+        global.__mpxAppCbs.show.forEach((cb) => {
+          cb(options)
+        })
       }
     })
   } else {
     builtInMixins.push({
       onLaunch () {
         Object.assign(this, Mpx.prototype)
+        initAppProvides(rawOptions.provide, this)
       }
     })
   }
-  // app选项目前不需要进行转换
-  const { rawOptions, currentInject } = transferOptions(option, 'app', false)
   rawOptions.mixins = builtInMixins
   const defaultOptions = filterOptions(spreadProp(mergeOptions(rawOptions, 'app', false), 'methods'), appData)
 
-  if (__mpx_mode__ === 'web' || __mpx_mode__ === 'tenon') {
-    global.__mpxOptionsMap = global.__mpxOptionsMap || {}
-    global.__mpxOptionsMap[currentInject.moduleId] = defaultOptions
+  if (__mpx_mode__ === 'web') {
     global.getApp = function () {
       if (!isBrowser) {
         console.error('[Mpx runtime error]: Dangerous API! global.getApp method is running in non browser environments')
       }
       return appData
     }
+    global.__mpxOptionsMap = global.__mpxOptionsMap || {}
+    global.__mpxOptionsMap[currentInject.moduleId] = defaultOptions
   } else {
-    initAppProvides(rawOptions)
     defaultOptions.onAppInit && defaultOptions.onAppInit()
     const ctor = config.customCtor || global.currentCtor || App
     ctor(defaultOptions)

package/src/platform/env/event.js

@@ -0,0 +1,105 @@
+import { isBrowser } from '@mpxjs/utils'
+
+function extendEvent (e, extendObj = {}) {
+  Object.keys(extendObj).forEach((key) => {
+    Object.defineProperty(e, key, {
+      value: extendObj[key],
+      enumerable: true,
+      configurable: true,
+      writable: true
+    })
+  })
+}
+
+function createMpxEvent (layer) {
+  let startTimer = null
+  let needTap = true
+  let touchStartX = 0
+  let touchStartY = 0
+  let targetElement = null
+  const isTouchDevice = document && 'ontouchstart' in document.documentElement
+
+  const onTouchStart = (event) => {
+    if (event.targetTouches?.length > 1) {
+      return true
+    }
+    const touches = event.targetTouches
+    targetElement = event.target
+    needTap = true
+    startTimer = null
+    touchStartX = touches[0].pageX
+    touchStartY = touches[0].pageY
+    startTimer = setTimeout(() => {
+      needTap = false
+      sendEvent(targetElement, 'longpress', event)
+      sendEvent(targetElement, 'longtap', event)
+    }, 350)
+  }
+
+  const onTouchMove = (event) => {
+    const touch = event.changedTouches[0]
+    if (
+      Math.abs(touch.pageX - touchStartX) > 1 ||
+      Math.abs(touch.pageY - touchStartY) > 1
+    ) {
+      needTap = false
+      startTimer && clearTimeout(startTimer)
+      startTimer = null
+    }
+  }
+
+  const onTouchEnd = (event) => {
+    if (event.targetTouches?.length > 1) {
+      return true
+    }
+    startTimer && clearTimeout(startTimer)
+    startTimer = null
+    if (needTap) {
+      sendEvent(targetElement, 'tap', event)
+    }
+  }
+
+  const onClick = (event) => {
+    targetElement = event.target
+    sendEvent(targetElement, 'tap', event)
+  }
+
+  const sendEvent = (targetElement, type, event) => {
+    const touchEvent = new CustomEvent(type, {
+      bubbles: true,
+      cancelable: true
+    })
+    const changedTouches = event.changedTouches || []
+    extendEvent(touchEvent, {
+      timeStamp: event.timeStamp,
+      changedTouches,
+      touches: changedTouches,
+      detail: {
+        x: changedTouches[0]?.pageX || event.pageX || 0,
+        y: changedTouches[0]?.pageY || event.pageY || 0
+      }
+    })
+    targetElement && targetElement.dispatchEvent(touchEvent)
+  }
+
+  if (isTouchDevice) {
+    layer.addEventListener('touchstart', onTouchStart, true)
+    layer.addEventListener('touchmove', onTouchMove, true)
+    layer.addEventListener('touchend', onTouchEnd, true)
+  } else {
+    layer.addEventListener('click', onClick, true)
+  }
+}
+
+export function initEvent () {
+  if (isBrowser && !global.__mpxCreatedEvent) {
+    global.__mpxCreatedEvent = true
+    if (document.readyState === 'complete' || document.readyState === 'interactive') {
+      createMpxEvent(document.body)
+    } else {
+      document.addEventListener('DOMContentLoaded', function () {
+        createMpxEvent(document.body)
+      }, false)
+    }
+  }
+}

package/src/platform/env/index.ios.js

@@ -0,0 +1,51 @@
+import { createI18n } from '../builtInMixins/i18nMixin'
+
+export function init (Mpx) {
+  global.__mpx = Mpx
+  global.__mpxAppCbs = global.__mpxAppCbs || {
+    show: [],
+    hide: [],
+    error: [],
+    rejection: []
+  }
+  if (global.i18n) {
+    Mpx.i18n = createI18n(global.i18n)
+  }
+  initGlobalErrorHandling()
+}
+
+function initGlobalErrorHandling () {
+  if (global.ErrorUtils) {
+    const defaultHandler = global.ErrorUtils.getGlobalHandler()
+    global.ErrorUtils.setGlobalHandler((error, isFatal) => {
+      if (global.__mpxAppCbs && global.__mpxAppCbs.error && global.__mpxAppCbs.error.length) {
+        global.__mpxAppCbs.error.forEach((cb) => {
+          cb(error)
+        })
+      } else if (defaultHandler) {
+        defaultHandler(error, isFatal)
+      } else {
+        console.error(`${error.name}: ${error.message}\n`)
+      }
+    })
+  }
+
+  const rejectionTrackingOptions = {
+    allRejections: true,
+    onUnhandled (id, error) {
+      if (global.__mpxAppCbs && global.__mpxAppCbs.rejection && global.__mpxAppCbs.rejection.length) {
+        global.__mpxAppCbs.rejection.forEach((cb) => {
+          cb(error, id)
+        })
+      } else {
+        console.warn(`UNHANDLED PROMISE REJECTION (id: ${id}): ${error}\n`)
+      }
+    }
+  }
+
+  if (global?.HermesInternal?.hasPromise?.()) {
+    global.HermesInternal?.enablePromiseRejectionTracker?.(rejectionTrackingOptions)
+  } else {
+    require('promise/setimmediate/rejection-tracking').enable(rejectionTrackingOptions)
+  }
+}

package/src/platform/env/index.js

@@ -0,0 +1,8 @@
+import { createI18n } from '../builtInMixins/i18nMixin'
+
+export function init (Mpx) {
+  global.__mpx = Mpx
+  if (global.i18n) {
+    Mpx.i18n = createI18n(global.i18n)
+  }
+}

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

@@ -0,0 +1,48 @@
+import Vue from 'vue'
+import install from './vuePlugin'
+import { isBrowser, error, warn } from '@mpxjs/utils'
+import { initEvent } from './event'
+
+export function init (Mpx) {
+  global.__mpx = Mpx
+  global.__mpxAppCbs = global.__mpxAppCbs || {
+    show: [],
+    hide: [],
+    error: [],
+    rejection: []
+  }
+  Mpx.__vue = Vue
+  Vue.use(install)
+  initEvent()
+  initGlobalErrorHandling()
+}
+
+function initGlobalErrorHandling () {
+  Vue.config.errorHandler = (e, vm, info) => {
+    error(`Unhandled error occurs${info ? ` during execution of [${info}]` : ''}!`, vm?.__mpxProxy?.options.mpxFileResource, e)
+  }
+  Vue.config.warnHandler = (msg, vm, trace) => {
+    warn(msg, vm?.__mpxProxy?.options.mpxFileResource, trace)
+  }
+
+  if (isBrowser) {
+    window.addEventListener('error', (event) => {
+      if (global.__mpxAppCbs && global.__mpxAppCbs.error && global.__mpxAppCbs.error.length) {
+        global.__mpxAppCbs.error.forEach((cb) => {
+          cb(event.error)
+        })
+      } else {
+        console.error(`${event.type}: ${event.message}\n`)
+      }
+    })
+    window.addEventListener('unhandledrejection', (event) => {
+      if (global.__mpxAppCbs && global.__mpxAppCbs.rejection && global.__mpxAppCbs.rejection.length) {
+        global.__mpxAppCbs.rejection.forEach((cb) => {
+          cb(event.reason, event.promise)
+        })
+      } else {
+        console.warn(`UNHANDLED PROMISE REJECTION: ${event.reason}\n`)
+      }
+    })
+  }
+}

package/src/{external → platform/env}/vuePlugin.js

@@ -1,7 +1,7 @@
 import { walkChildren, parseSelector, error, hasOwn, collectDataset } from '@mpxjs/utils'
 import { createSelectorQuery, createIntersectionObserver } from '@mpxjs/api-proxy'
 import { EffectScope } from 'vue'
-import { PausedState } from '../helper/const'
+import { PausedState } from '../../helper/const'
 
 const hackEffectScope = () => {
   EffectScope.prototype.pause = function () {
@@ -60,17 +60,23 @@ export default function install (Vue) {
     data: {
       get () {
         return Object.assign({}, this.$props, this.$data)
-      }
+      },
+      enumerable: true,
+      configurable: true
     },
     dataset: {
       get () {
         return collectDataset(this.$attrs, true)
-      }
+      },
+      enumerable: true,
+      configurable: true
     },
     id: {
       get () {
         return this.$attrs.id || ''
-      }
+      },
+      enumerable: true,
+      configurable: true
     }
   })