@mpxjs/core 2.7.50 → 2.8.0-beta.2

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 Vue from 'vue'
+import install from './vuePlugin'
 
-export default vue
+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
-  }
-}

package/src/helper/getByPath.js

@@ -1,127 +0,0 @@
-let curStack
-let targetStacks
-let property
-
-class Stack {
-  constructor (mark) {
-    this.mark = mark
-    // 字符串stack需要特殊处理
-    this.type = /['"]/.test(mark) ? 'string' : 'normal'
-    this.value = []
-  }
-
-  push (data) {
-    this.value.push(data)
-  }
-}
-
-function startStack (mark) {
-  // 开启栈或关闭栈都意味着前面的字符拼接截止
-  propertyJoinOver()
-  curStack && targetStacks.push(curStack)
-  curStack = new Stack(mark)
-}
-
-function endStack () {
-  // 开启栈或关闭栈都意味着前面的字符拼接截止
-  propertyJoinOver()
-  // 字符串栈直接拼接
-  const result = curStack.type === 'string' ? '__mpx_str_' + curStack.value.join('') : curStack.value
-  curStack = targetStacks.pop()
-  // 将当前stack结果保存到父级stack里
-  curStack.push(result)
-}
-
-function propertyJoinOver () {
-  property = property.trim()
-  if (property) curStack.push(property)
-  property = ''
-}
-
-function init () {
-  property = ''
-  // 根stack
-  curStack = new Stack()
-  targetStacks = []
-}
-
-function parse (str) {
-  init()
-  for (const char of str) {
-    // 当前遍历引号内的字符串时
-    if (curStack.type === 'string') {
-      // 若为对应的结束flag，则出栈，反之直接push
-      curStack.mark === char ? endStack() : curStack.push(char)
-    } else if (/['"[]/.test(char)) {
-      startStack(char)
-    } else if (char === ']') {
-      endStack()
-    } else if (char === '.' || char === '+') {
-      propertyJoinOver()
-      if (char === '+') curStack.push(char)
-    } else {
-      property += char
-    }
-  }
-  // 字符解析收尾
-  propertyJoinOver()
-  return curStack.value
-}
-
-function outPutByPath (context, path, isSimple, transfer) {
-  let result = context
-  const len = path.length
-  const meta = {
-    isEnd: false,
-    stop: false
-  }
-  for (let index = 0; index < len; index++) {
-    if (index === len - 1) meta.isEnd = true
-    let key
-    const item = path[index]
-    if (result) {
-      if (isSimple) {
-        key = item
-      } else if (Array.isArray(item)) {
-        // 获取子数组的输出结果作为当前key
-        key = outPutByPath(context, item, isSimple, transfer)
-      } else if (/^__mpx_str_/.test(item)) {
-        // 字符串一定会被[]包裹，一定在子数组中
-        result = item.replace('__mpx_str_', '')
-      } else if (/^\d+$/.test(item)) {
-        // 数字一定会被[]包裹，一定在子数组中
-        result = +item
-      } else if (item === '+') {
-        // 获取加号后面所有path最终的结果
-        result += outPutByPath(context, path.slice(index + 1), isSimple, transfer)
-        break
-      } else {
-        key = item
-      }
-      if (key !== undefined) {
-        result = transfer ? transfer(result, key, meta) : result[key]
-        if (meta.stop) break
-      }
-    } else {
-      break
-    }
-  }
-  return result
-}
-
-export default function getByPath (context, pathStrOrArr, transfer) {
-  if (!pathStrOrArr) {
-    return context
-  }
-  let isSimple = false
-  if (Array.isArray(pathStrOrArr)) {
-    isSimple = true
-  } else if (!/[[\]]/.test(pathStrOrArr)) {
-    pathStrOrArr = pathStrOrArr.split('.')
-    isSimple = true
-  }
-
-  if (!isSimple) pathStrOrArr = parse(pathStrOrArr)
-
-  return outPutByPath(context, pathStrOrArr, isSimple, transfer)
-}

package/src/helper/log.js

@@ -1,31 +0,0 @@
-import EXPORT_MPX from '../index'
-
-export function warn (msg, location, e) {
-  const condition = EXPORT_MPX.config.ignoreWarning
-  let ignore = false
-  if (typeof condition === 'boolean') {
-    ignore = condition
-  } else if (typeof condition === 'string') {
-    ignore = msg.indexOf(condition) !== -1
-  } else if (typeof condition === 'function') {
-    ignore = condition(msg, location, e)
-  } else if (condition instanceof RegExp) {
-    ignore = condition.test(msg)
-  }
-  if (!ignore) return log('warn', msg, location, e)
-}
-
-export function error (msg, location, e) {
-  return log('error', msg, location, e)
-}
-
-function log (type, msg, location, e) {
-  if (process.env.NODE_ENV !== 'production') {
-    let header = `[Mpx runtime ${type}]: `
-    if (location) {
-      header = `[Mpx runtime ${type} at ${location}]: `
-    }
-    console[type](header + msg)
-    if (e) console[type](e)
-  }
-}