@mpxjs/core 2.7.52 → 2.8.0-beta.2

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

@@ -1,8 +1,7 @@
-import { hasOwn } from '../../../helper/utils'
-import MPXProxy from '../../../core/proxy'
+import { hasOwn } from '@mpxjs/utils'
+import MpxProxy from '../../../core/proxy'
 import builtInKeysMap from '../builtInKeysMap'
 import mergeOptions from '../../../core/mergeOptions'
-import { queueWatcher } from '../../../observer/scheduler'
 
 function transformProperties (properties) {
   if (!properties) {
@@ -24,15 +23,10 @@ function transformProperties (properties) {
     } else {
       newFiled = Object.assign({}, rawFiled)
     }
-    newFiled.observer = function (value, oldValue) {
+    newFiled.observer = function (value) {
       if (this.__mpxProxy) {
         this[key] = value
-        queueWatcher(() => {
-          // 只有当当前没有渲染任务时，属性更新才需要单独触发updated，否则可以由渲染任务结束后触发updated
-          if (this.__mpxProxy.curRenderTask && this.__mpxProxy.curRenderTask.state === 'finished') {
-            this.__mpxProxy.updated()
-          }
-        })
+        this.__mpxProxy.propsUpdated()
       }
     }
     newProps[key] = newFiled
@@ -41,27 +35,27 @@ function transformProperties (properties) {
 }
 
 function transformApiForProxy (context, currentInject) {
-  const rawSetData = context.setData.bind(context)
+  const rawSetData = context.setData
   Object.defineProperties(context, {
     setData: {
       get () {
         return function (data, callback) {
-          return this.__mpxProxy.forceUpdate(data, { sync: true }, callback)
+          return context.__mpxProxy.forceUpdate(data, { sync: true }, callback)
         }
       },
       configurable: true
     },
-    __getInitialData: {
+    __getProps: {
       get () {
         return (options) => {
-          const data = {}
-          const validData = Object.assign({}, options.data, options.properties, options.props)
-          for (const key in context.data) {
-            if (hasOwn(context.data, key) && hasOwn(validData, key)) {
-              data[key] = context.data[key]
+          const props = {}
+          const validProps = Object.assign({}, options.properties, options.props)
+          Object.keys(context.data).forEach((key) => {
+            if (hasOwn(validProps, key)) {
+              props[key] = context.data[key]
             }
-          }
-          return data
+          })
+          return props
         }
       },
       configurable: false
@@ -73,13 +67,27 @@ function transformApiForProxy (context, currentInject) {
       configurable: false
     }
   })
+
+  // // 抹平处理tt不支持驼峰事件名的问题
+  // if (__mpx_mode__ === 'tt') {
+  //   const rawTriggerEvent = context.triggerEvent
+  //   Object.defineProperty(context, 'triggerEvent', {
+  //     get () {
+  //       return function (eventName, eventDetail) {
+  //         return rawTriggerEvent.call(this, eventName.toLowerCase(), eventDetail)
+  //       }
+  //     },
+  //     configurable: true
+  //   })
+  // }
+
   // 绑定注入的render
   if (currentInject) {
     if (currentInject.render) {
       Object.defineProperties(context, {
         __injectedRender: {
           get () {
-            return currentInject.render.bind(context)
+            return currentInject.render
           },
           configurable: false
         }
@@ -116,17 +124,16 @@ export function filterOptions (options) {
   return newOptions
 }
 
-export function initProxy (context, rawOptions, currentInject, params) {
+export function initProxy (context, rawOptions, currentInject) {
   if (!context.__mpxProxy) {
     // 提供代理对象需要的api
     transformApiForProxy(context, currentInject)
-    // 缓存options
-    context.$rawOptions = rawOptions
     // 创建proxy对象
-    context.__mpxProxy = new MPXProxy(rawOptions, context)
-    context.__mpxProxy.created(params)
-  } else if (context.__mpxProxy.isDestroyed()) {
-    context.__mpxProxy.reCreated(params)
+    context.__mpxProxy = new MpxProxy(rawOptions, context)
+    context.__mpxProxy.created()
+  } else if (context.__mpxProxy.isUnmounted()) {
+    context.__mpxProxy = new MpxProxy(rawOptions, context, true)
+    context.__mpxProxy.created()
   }
 }
 
@@ -137,14 +144,14 @@ export function getDefaultOptions (type, { rawOptions = {}, currentInject }) {
     hookNames = ['onLoad', 'onReady', 'onUnload']
   }
   const rootMixins = [{
-    [hookNames[0]] (...params) {
-      initProxy(this, rawOptions, currentInject, params)
+    [hookNames[0]] () {
+      initProxy(this, rawOptions, currentInject)
     },
     [hookNames[1]] () {
       if (this.__mpxProxy) this.__mpxProxy.mounted()
     },
     [hookNames[2]] () {
-      if (this.__mpxProxy) this.__mpxProxy.destroyed()
+      if (this.__mpxProxy) this.__mpxProxy.unmounted()
     }
   }]
   rawOptions.mixins = rawOptions.mixins ? rootMixins.concat(rawOptions.mixins) : rootMixins

package/src/platform/patch/wx/lifecycle.js

@@ -1,4 +1,11 @@
-import { BEFORECREATE, CREATED, DESTROYED, MOUNTED, UPDATED, BEFOREMOUNT } from '../../../core/innerLifecycle'
+import {
+  CREATED,
+  UNMOUNTED,
+  MOUNTED,
+  ONSHOW,
+  ONHIDE,
+  ONLOAD
+} from '../../../core/innerLifecycle'
 
 const APP_HOOKS = [
   'onLaunch',
@@ -18,33 +25,33 @@ const PAGE_HOOKS = [
   'onUnload',
   'onPullDownRefresh',
   'onReachBottom',
-  'onShareAppMessage',
   'onPageScroll',
+  'onAddToFavorites',
+  'onShareAppMessage',
+  'onShareTimeline',
+  'onResize',
   'onTabItemTap',
-  'onResize'
+  'onSaveExitState'
 ]
 
 const COMPONENT_HOOKS = [
-  'beforeCreate',
   'created',
   'attached',
   'ready',
   'moved',
   'detached',
-  'updated',
   'pageShow',
-  'pageHide',
-  'definitionFilter'
+  'pageHide'
 ]
 
 export const lifecycleProxyMap = {
-  [BEFORECREATE]: ['beforeCreate'],
   // 类微信平台中onLoad不能代理到CREATED上，否则Component构造页面时无法获取页面参数
   [CREATED]: ['created', 'attached'],
-  [UPDATED]: ['updated'],
-  [BEFOREMOUNT]: ['beforeMount'],
   [MOUNTED]: ['ready', 'onReady'],
-  [DESTROYED]: ['detached', 'onUnload']
+  [UNMOUNTED]: ['detached', 'onUnload'],
+  [ONSHOW]: ['pageShow', 'onShow'],
+  [ONHIDE]: ['pageHide', 'onHide'],
+  [ONLOAD]: ['onLoad']
 }
 
 export const LIFECYCLE = {

package/src/runtime/createFactory.js

@@ -1,4 +1,8 @@
-const mpx = require('../index').default
+const factoryMap = {
+  App: require('../index').createApp,
+  Page: require('../index').createPage,
+  Component: require('../index').createComponent
+}
 
 module.exports = (type) => (...args) => {
   if (type === 'Behavior') {
@@ -13,5 +17,5 @@ module.exports = (type) => (...args) => {
     }
     return args[0]
   }
-  return mpx[`create${type}`] && mpx[`create${type}`].apply(null, args.concat({ isNative: true }))
+  return factoryMap[type].apply(null, args.concat({ isNative: true }))
 }

package/src/vue.web.js

@@ -1,3 +1,6 @@
 import Vue from 'vue'
+import install from './vuePlugin'
+
+Vue.use(install)
 
 export default Vue

package/src/vuePlugin.js

@@ -0,0 +1,31 @@
+import { walkChildren, parseSelector, error } from '@mpxjs/utils'
+import * as webApi from '@mpxjs/api-proxy/src/web/api'
+
+export default function install (Vue) {
+  Vue.prototype.triggerEvent = function (eventName, eventDetail) {
+    return this.$emit(eventName, {
+      type: eventName,
+      detail: eventDetail
+    })
+  }
+  Vue.prototype.selectComponent = function (selector, all) {
+    const result = []
+    if (/[>\s]/.test(selector)) {
+      const location = this.__mpxProxy.options.mpxFileResource
+      error('The selectComponent or selectAllComponents only supports the basic selector, the relation selector is not supported.', location)
+    } else {
+      const selectorGroups = parseSelector(selector)
+      walkChildren(this, selectorGroups, this, result, all)
+    }
+    return all ? result : result[0]
+  }
+  Vue.prototype.selectAllComponents = function (selector) {
+    return this.selectComponent(selector, true)
+  }
+  Vue.prototype.createSelectorQuery = function () {
+    return webApi.createSelectorQuery().in(this)
+  }
+  Vue.prototype.createIntersectionObserver = function (component, options) {
+    return webApi.createIntersectionObserver(component, options)
+  }
+}

package/src/core/createStore.js

@@ -1,241 +0,0 @@
-import { observe } from '../observer/index'
-
-import { initComputed } from '../observer/computed'
-
-import Vue from '../vue'
-
-import {
-  proxy,
-  getByPath
-} from '../helper/utils'
-
-import { warn } from '../helper/log'
-
-// 兼容在web和小程序平台中创建表现一致的store
-
-import mapStore from './mapStore'
-
-function transformGetters (getters, module, store) {
-  const newGetters = {}
-  for (let key in getters) {
-    if (key in store.getters) {
-      warn(`Duplicate getter type: ${key}.`)
-    }
-    const getter = function () {
-      if (store.withThis) {
-        return getters[key].call({
-          state: module.state,
-          getters: store.getters,
-          rootState: store.state
-        })
-      }
-      return getters[key](module.state, store.getters, store.state)
-    }
-    newGetters[key] = getter
-  }
-  return newGetters
-}
-
-function transformMutations (mutations, module, store) {
-  const newMutations = {}
-  for (let key in mutations) {
-    if (store.mutations[key]) {
-      warn(`Duplicate mutation type: ${key}.`)
-    }
-    const context = {
-      state: module.state,
-      commit: store.commit.bind(store)
-    }
-    const mutation = function (...payload) {
-      if (store.withThis) return mutations[key].apply(context, payload)
-      return mutations[key](module.state, ...payload)
-    }
-    newMutations[key] = mutation
-  }
-  return newMutations
-}
-
-function transformActions (actions, module, store) {
-  const newActions = {}
-  for (let key in actions) {
-    if (store.actions[key]) {
-      warn(`Duplicate action type: ${key}.`)
-    }
-    newActions[key] = function (...payload) {
-      const context = {
-        rootState: store.state,
-        state: module.state,
-        getters: store.getters,
-        dispatch: store.dispatch.bind(store),
-        commit: store.commit.bind(store)
-      }
-
-      let result
-      if (store.withThis) {
-        result = actions[key].apply(context, payload)
-      } else {
-        result = actions[key](context, ...payload)
-      }
-      // action一定返回一个promise
-      if (result && typeof result.then === 'function' && typeof result.catch === 'function') {
-        return result
-      } else {
-        return Promise.resolve(result)
-      }
-    }
-  }
-  return newActions
-}
-
-function mergeDeps (module, deps) {
-  const mergeProps = ['state', 'getters', 'mutations', 'actions']
-  Object.keys(deps).forEach(key => {
-    const store = deps[key]
-    mergeProps.forEach(prop => {
-      if (module[prop] && (key in module[prop])) {
-        warn(`Deps's name [${key}] conflicts with ${prop}'s key in current options.`)
-      } else {
-        module[prop] = module[prop] || {}
-        if (prop === 'getters') {
-          // depsGetters单独存放，不需要重新进行初始化
-          module.depsGetters = module.depsGetters || {}
-          module.depsGetters[key] = store.getters
-          // module[prop][key] = () => store[prop]
-        } else {
-          module[prop][key] = store[prop]
-        }
-      }
-    })
-  })
-}
-
-class Store {
-  constructor (options) {
-    const {
-      plugins = []
-    } = options
-    this.withThis = options.withThis
-    this.__wrappedGetters = {}
-    this.__depsGetters = {}
-    this.getters = {}
-    this.mutations = {}
-    this.actions = {}
-    this._subscribers = []
-    this.state = this.registerModule(options).state
-    this.resetStoreVM()
-    Object.assign(this, mapStore(this))
-    plugins.forEach(plugin => plugin(this))
-  }
-
-  dispatch (type, ...payload) {
-    const action = getByPath(this.actions, type)
-    if (!action) {
-      return Promise.reject(new Error(`unknown action type: ${type}`))
-    } else {
-      return action(...payload)
-    }
-  }
-
-  commit (type, ...payload) {
-    const mutation = getByPath(this.mutations, type)
-    if (!mutation) {
-      warn(`Unknown mutation type: ${type}.`)
-    } else {
-      mutation(...payload)
-      return this._subscribers.slice().forEach(sub => sub({ type, payload }, this.state))
-    }
-  }
-
-  subscribe (fn, options) {
-    return genericSubscribe(fn, this._subscribers, options)
-  }
-
-  registerModule (module) {
-    const state = module.state || {}
-    const reactiveModule = {
-      state
-    }
-    if (module.getters) {
-      reactiveModule.getters = transformGetters(module.getters, reactiveModule, this)
-    }
-    if (module.mutations) {
-      reactiveModule.mutations = transformMutations(module.mutations, reactiveModule, this)
-    }
-    if (module.actions) {
-      reactiveModule.actions = transformActions(module.actions, reactiveModule, this)
-    }
-    if (module.deps) {
-      mergeDeps(reactiveModule, module.deps)
-    }
-    Object.assign(this.__depsGetters, reactiveModule.depsGetters)
-    Object.assign(this.__wrappedGetters, reactiveModule.getters)
-    // merge mutations
-    Object.assign(this.mutations, reactiveModule.mutations)
-    // merge actions
-    Object.assign(this.actions, reactiveModule.actions)
-    // 子module
-    if (module.modules) {
-      const childs = module.modules
-      Object.keys(childs).forEach(key => {
-        reactiveModule.state[key] = this.registerModule(childs[key]).state
-      })
-    }
-    return reactiveModule
-  }
-
-  resetStoreVM () {
-    if (__mpx_mode__ === 'web') {
-      this._vm = new Vue({
-        data: {
-          __mpxState: this.state
-        },
-        computed: this.__wrappedGetters
-      })
-      const computedKeys = Object.keys(this.__wrappedGetters)
-      proxy(this.getters, this._vm, computedKeys)
-      proxy(this.getters, this.__depsGetters)
-    } else {
-      this._vm = {}
-      observe(this.state, true)
-      initComputed(this._vm, this.getters, this.__wrappedGetters)
-      proxy(this.getters, this.__depsGetters)
-    }
-  }
-}
-
-function genericSubscribe (fn, subs, options) {
-  if (subs.indexOf(fn) < 0) {
-    options && options.prepend
-      ? subs.unshift(fn)
-      : subs.push(fn)
-  }
-  return () => {
-    const i = subs.indexOf(fn)
-    if (i > -1) {
-      subs.splice(i, 1)
-    }
-  }
-}
-
-export default function createStore (options) {
-  return new Store(options)
-}
-
-// ts util functions
-export function createStateWithThis (state) {
-  return state
-}
-export function createGettersWithThis (getters, options = {}) {
-  return getters
-}
-export function createMutationsWithThis (mutations, options = {}) {
-  return mutations
-}
-export function createActionsWithThis (actions, options = {}) {
-  return actions
-}
-
-export function createStoreWithThis (options) {
-  options.withThis = true
-  return new Store(options)
-}

package/src/core/mapStore.js

@@ -1,94 +0,0 @@
-import {
-  normalizeMap,
-  getByPath
-} from '../helper/utils'
-
-import { warn, error } from '../helper/log'
-
-function mapFactory (type, store) {
-  return function (depPath, maps) {
-    maps = normalizeMap(depPath, maps)
-    const result = {}
-    Object.entries(maps).forEach(([key, value]) => {
-      result[key] = function (payload) {
-        switch (type) {
-          case 'state':
-            if (typeof value === 'function') {
-              return value.call(this, store.state, store.getters)
-            } else {
-              let stateVal = getByPath(store.state, value, '', '__NOTFOUND__')
-              if (stateVal === '__NOTFOUND__') {
-                warn(`Unknown state named [${value}].`)
-                stateVal = ''
-              }
-              return stateVal
-            }
-          case 'getters':
-            let getterVal = getByPath(store.getters, value, '', '__NOTFOUND__')
-            if (getterVal === '__NOTFOUND__') {
-              warn(`Unknown getter named [${value}].`)
-              getterVal = ''
-            }
-            return getterVal
-          case 'mutations':
-            return store.commit(value, payload)
-          case 'actions':
-            return store.dispatch(value, payload)
-        }
-      }
-    })
-    return result
-  }
-}
-
-function checkMapInstance (args) {
-  const context = args[args.length - 1]
-  const isValid = context && typeof context === 'object' && context.__mpxProxy
-  if (!isValid) {
-    error(`调用map**ToInstance时必须传入当前component实例this`)
-  }
-
-  args.splice(-1)
-
-  return {
-    restParams: args,
-    context
-  }
-}
-
-export default function (store) {
-  return {
-    mapGetters: mapFactory('getters', store),
-    mapMutations: mapFactory('mutations', store),
-    mapActions: mapFactory('actions', store),
-    mapState: mapFactory('state', store),
-    // 以下是map**ToInstance用于异步store的,参数args：depPath, maps, context
-    mapStateToInstance: (...args) => {
-      const { context, restParams } = checkMapInstance(args)
-      const mapStateFun = mapFactory('state', store)
-      const result = mapStateFun(...restParams)
-      // 将result挂载到mpxProxy实例属性上
-      context.__mpxProxy.options.computed = context.__mpxProxy.options.computed || {}
-      Object.assign(context.__mpxProxy.options.computed, result)
-    },
-    mapGettersToInstance: (...args) => {
-      const { context, restParams } = checkMapInstance(args)
-      const mapGetFun = mapFactory('getters', store)
-      const result = mapGetFun(...restParams)
-      context.__mpxProxy.options.computed = context.__mpxProxy.options.computed || {}
-      Object.assign(context.__mpxProxy.options.computed, result)
-    },
-    mapMutationsToInstance: (...args) => {
-      const { context, restParams } = checkMapInstance(args)
-      const mapMutationFun = mapFactory('mutations', store)
-      const result = mapMutationFun(...restParams)
-      Object.assign(context, result)
-    },
-    mapActionsToInstance: (...args) => {
-      const { context, restParams } = checkMapInstance(args)
-      const mapActionFun = mapFactory('actions', store)
-      const result = mapActionFun(...restParams)
-      Object.assign(context, result)
-    }
-  }
-}

package/src/helper/env.js

@@ -1,20 +0,0 @@
-export function getEnvObj () {
-  switch (__mpx_mode__) {
-    case 'wx':
-      return wx
-    case 'ali':
-      return my
-    case 'swan':
-      return swan
-    case 'qq':
-      return qq
-    case 'tt':
-      return tt
-    case 'jd':
-      return jd
-    case 'qa':
-      return qa
-    case 'dd':
-      return dd
-  }
-}