vue 2.6.13 → 2.7.0-alpha.2

package/src/platforms/weex/entry-framework.js

@@ -1,187 +0,0 @@
-/* @flow */
-
-// this will be preserved during build
-// $flow-disable-line
-const VueFactory = require('./factory')
-
-const instanceOptions: { [key: string]: WeexInstanceOption } = {}
-
-/**
- * Create instance context.
- */
-export function createInstanceContext (
-  instanceId: string,
-  runtimeContext: WeexRuntimeContext,
-  data: Object = {}
-): WeexInstanceContext {
-  const weex: Weex = runtimeContext.weex
-  const instance: WeexInstanceOption = instanceOptions[instanceId] = {
-    instanceId,
-    config: weex.config,
-    document: weex.document,
-    data
-  }
-
-  // Each instance has a independent `Vue` module instance
-  const Vue = instance.Vue = createVueModuleInstance(instanceId, weex)
-
-  // DEPRECATED
-  const timerAPIs = getInstanceTimer(instanceId, weex.requireModule)
-
-  const instanceContext = Object.assign({ Vue }, timerAPIs)
-  Object.freeze(instanceContext)
-  return instanceContext
-}
-
-/**
- * Destroy an instance with id. It will make sure all memory of
- * this instance released and no more leaks.
- */
-export function destroyInstance (instanceId: string): void {
-  const instance = instanceOptions[instanceId]
-  if (instance && instance.app instanceof instance.Vue) {
-    try {
-      instance.app.$destroy()
-      instance.document.destroy()
-    } catch (e) {}
-    delete instance.document
-    delete instance.app
-  }
-  delete instanceOptions[instanceId]
-}
-
-/**
- * Refresh an instance with id and new top-level component data.
- * It will use `Vue.set` on all keys of the new data. So it's better
- * define all possible meaningful keys when instance created.
- */
-export function refreshInstance (
-  instanceId: string,
-  data: Object
-): Error | void {
-  const instance = instanceOptions[instanceId]
-  if (!instance || !(instance.app instanceof instance.Vue)) {
-    return new Error(`refreshInstance: instance ${instanceId} not found!`)
-  }
-  if (instance.Vue && instance.Vue.set) {
-    for (const key in data) {
-      instance.Vue.set(instance.app, key, data[key])
-    }
-  }
-  // Finally `refreshFinish` signal needed.
-  instance.document.taskCenter.send('dom', { action: 'refreshFinish' }, [])
-}
-
-/**
- * Create a fresh instance of Vue for each Weex instance.
- */
-function createVueModuleInstance (
-  instanceId: string,
-  weex: Weex
-): GlobalAPI {
-  const exports = {}
-  VueFactory(exports, weex.document)
-  const Vue = exports.Vue
-
-  const instance = instanceOptions[instanceId]
-
-  // patch reserved tag detection to account for dynamically registered
-  // components
-  const weexRegex = /^weex:/i
-  const isReservedTag = Vue.config.isReservedTag || (() => false)
-  const isRuntimeComponent = Vue.config.isRuntimeComponent || (() => false)
-  Vue.config.isReservedTag = name => {
-    return (!isRuntimeComponent(name) && weex.supports(`@component/${name}`)) ||
-      isReservedTag(name) ||
-      weexRegex.test(name)
-  }
-  Vue.config.parsePlatformTagName = name => name.replace(weexRegex, '')
-
-  // expose weex-specific info
-  Vue.prototype.$instanceId = instanceId
-  Vue.prototype.$document = instance.document
-
-  // expose weex native module getter on subVue prototype so that
-  // vdom runtime modules can access native modules via vnode.context
-  Vue.prototype.$requireWeexModule = weex.requireModule
-
-  // Hack `Vue` behavior to handle instance information and data
-  // before root component created.
-  Vue.mixin({
-    beforeCreate () {
-      const options = this.$options
-      // root component (vm)
-      if (options.el) {
-        // set external data of instance
-        const dataOption = options.data
-        const internalData = (typeof dataOption === 'function' ? dataOption() : dataOption) || {}
-        options.data = Object.assign(internalData, instance.data)
-        // record instance by id
-        instance.app = this
-      }
-    },
-    mounted () {
-      const options = this.$options
-      // root component (vm)
-      if (options.el && weex.document && instance.app === this) {
-        try {
-          // Send "createFinish" signal to native.
-          weex.document.taskCenter.send('dom', { action: 'createFinish' }, [])
-        } catch (e) {}
-      }
-    }
-  })
-
-  /**
-   * @deprecated Just instance variable `weex.config`
-   * Get instance config.
-   * @return {object}
-   */
-  Vue.prototype.$getConfig = function () {
-    if (instance.app instanceof Vue) {
-      return instance.config
-    }
-  }
-
-  return Vue
-}
-
-/**
- * DEPRECATED
- * Generate HTML5 Timer APIs. An important point is that the callback
- * will be converted into callback id when sent to native. So the
- * framework can make sure no side effect of the callback happened after
- * an instance destroyed.
- */
-function getInstanceTimer (
-  instanceId: string,
-  moduleGetter: Function
-): Object {
-  const instance = instanceOptions[instanceId]
-  const timer = moduleGetter('timer')
-  const timerAPIs = {
-    setTimeout: (...args) => {
-      const handler = function () {
-        args[0](...args.slice(2))
-      }
-
-      timer.setTimeout(handler, args[1])
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    setInterval: (...args) => {
-      const handler = function () {
-        args[0](...args.slice(2))
-      }
-
-      timer.setInterval(handler, args[1])
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    clearTimeout: (n) => {
-      timer.clearTimeout(n)
-    },
-    clearInterval: (n) => {
-      timer.clearInterval(n)
-    }
-  }
-  return timerAPIs
-}

package/src/platforms/weex/entry-runtime-factory.js

@@ -1,6 +0,0 @@
-// this entry is built and wrapped with a factory function
-// used to generate a fresh copy of Vue for every Weex instance.
-
-import Vue from './runtime/index'
-
-exports.Vue = Vue

package/src/platforms/weex/runtime/components/index.js

@@ -1,9 +0,0 @@
-import Richtext from './richtext'
-import Transition from './transition'
-import TransitionGroup from './transition-group'
-
-export default {
-  Richtext,
-  Transition,
-  TransitionGroup
-}

package/src/platforms/weex/runtime/components/richtext.js

@@ -1,82 +0,0 @@
-/* @flow */
-
-function getVNodeType (vnode: VNode): string {
-  if (!vnode.tag) {
-    return ''
-  }
-  return vnode.tag.replace(/vue\-component\-(\d+\-)?/, '')
-}
-
-function isSimpleSpan (vnode: VNode): boolean {
-  return vnode.children &&
-    vnode.children.length === 1 &&
-    !vnode.children[0].tag
-}
-
-function parseStyle (vnode: VNode): Object | void {
-  if (!vnode || !vnode.data) {
-    return
-  }
-  const { staticStyle, staticClass } = vnode.data
-  if (vnode.data.style || vnode.data.class || staticStyle || staticClass) {
-    const styles = Object.assign({}, staticStyle, vnode.data.style)
-    const cssMap = vnode.context.$options.style || {}
-    const classList = [].concat(staticClass, vnode.data.class)
-    classList.forEach(name => {
-      if (name && cssMap[name]) {
-        Object.assign(styles, cssMap[name])
-      }
-    })
-    return styles
-  }
-}
-
-function convertVNodeChildren (children: Array<VNode>): Array<VNode> | void {
-  if (!children.length) {
-    return
-  }
-
-  return children.map(vnode => {
-    const type: string = getVNodeType(vnode)
-    const props: Object = { type }
-
-    // convert raw text node
-    if (!type) {
-      props.type = 'span'
-      props.attr = {
-        value: (vnode.text || '').trim()
-      }
-    } else {
-      props.style = parseStyle(vnode)
-      if (vnode.data) {
-        props.attr = vnode.data.attrs
-        if (vnode.data.on) {
-          props.events = vnode.data.on
-        }
-      }
-      if (type === 'span' && isSimpleSpan(vnode)) {
-        props.attr = props.attr || {}
-        props.attr.value = vnode.children[0].text.trim()
-        return props
-      }
-    }
-
-    if (vnode.children && vnode.children.length) {
-      props.children = convertVNodeChildren(vnode.children)
-    }
-
-    return props
-  })
-}
-
-export default {
-  name: 'richtext',
-  render (h: Function) {
-    return h('weex:richtext', {
-      on: this._events,
-      attrs: {
-        value: convertVNodeChildren(this.$options._renderChildren || [])
-      }
-    })
-  }
-}

package/src/platforms/weex/runtime/components/transition-group.js

@@ -1,148 +0,0 @@
-import { warn, extend } from 'core/util/index'
-import { transitionProps, extractTransitionData } from './transition'
-
-const props = extend({
-  tag: String,
-  moveClass: String
-}, transitionProps)
-
-delete props.mode
-
-export default {
-  props,
-
-  created () {
-    const dom = this.$requireWeexModule('dom')
-    this.getPosition = el => new Promise((resolve, reject) => {
-      dom.getComponentRect(el.ref, res => {
-        if (!res.result) {
-          reject(new Error(`failed to get rect for element: ${el.tag}`))
-        } else {
-          resolve(res.size)
-        }
-      })
-    })
-
-    const animation = this.$requireWeexModule('animation')
-    this.animate = (el, options) => new Promise(resolve => {
-      animation.transition(el.ref, options, resolve)
-    })
-  },
-
-  render (h) {
-    const tag = this.tag || this.$vnode.data.tag || 'span'
-    const map = Object.create(null)
-    const prevChildren = this.prevChildren = this.children
-    const rawChildren = this.$slots.default || []
-    const children = this.children = []
-    const transitionData = extractTransitionData(this)
-
-    for (let i = 0; i < rawChildren.length; i++) {
-      const c = rawChildren[i]
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c)
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData
-        } else if (process.env.NODE_ENV !== 'production') {
-          const opts = c.componentOptions
-          const name = opts
-            ? (opts.Ctor.options.name || opts.tag)
-            : c.tag
-          warn(`<transition-group> children must be keyed: <${name}>`)
-        }
-      }
-    }
-
-    if (prevChildren) {
-      const kept = []
-      const removed = []
-      prevChildren.forEach(c => {
-        c.data.transition = transitionData
-
-        // TODO: record before patch positions
-
-        if (map[c.key]) {
-          kept.push(c)
-        } else {
-          removed.push(c)
-        }
-      })
-      this.kept = h(tag, null, kept)
-      this.removed = removed
-    }
-
-    return h(tag, null, children)
-  },
-
-  beforeUpdate () {
-    // force removing pass
-    this.__patch__(
-      this._vnode,
-      this.kept,
-      false, // hydrating
-      true // removeOnly (!important, avoids unnecessary moves)
-    )
-    this._vnode = this.kept
-  },
-
-  updated () {
-    const children = this.prevChildren
-    const moveClass = this.moveClass || ((this.name || 'v') + '-move')
-    const moveData = children.length && this.getMoveData(children[0].context, moveClass)
-    if (!moveData) {
-      return
-    }
-
-    // TODO: finish implementing move animations once
-    // we have access to sync getComponentRect()
-
-    // children.forEach(callPendingCbs)
-
-    // Promise.all(children.map(c => {
-    //   const oldPos = c.data.pos
-    //   const newPos = c.data.newPos
-    //   const dx = oldPos.left - newPos.left
-    //   const dy = oldPos.top - newPos.top
-    //   if (dx || dy) {
-    //     c.data.moved = true
-    //     return this.animate(c.elm, {
-    //       styles: {
-    //         transform: `translate(${dx}px,${dy}px)`
-    //       }
-    //     })
-    //   }
-    // })).then(() => {
-    //   children.forEach(c => {
-    //     if (c.data.moved) {
-    //       this.animate(c.elm, {
-    //         styles: {
-    //           transform: ''
-    //         },
-    //         duration: moveData.duration || 0,
-    //         delay: moveData.delay || 0,
-    //         timingFunction: moveData.timingFunction || 'linear'
-    //       })
-    //     }
-    //   })
-    // })
-  },
-
-  methods: {
-    getMoveData (context, moveClass) {
-      const stylesheet = context.$options.style || {}
-      return stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][moveClass]
-    }
-  }
-}
-
-// function callPendingCbs (c) {
-//   /* istanbul ignore if */
-//   if (c.elm._moveCb) {
-//     c.elm._moveCb()
-//   }
-//   /* istanbul ignore if */
-//   if (c.elm._enterCb) {
-//     c.elm._enterCb()
-//   }
-// }

package/src/platforms/weex/runtime/components/transition.js

@@ -1,9 +0,0 @@
-// reuse same transition component logic from web
-export {
-  transitionProps,
-  extractTransitionData
-} from 'web/runtime/components/transition'
-
-import Transition from 'web/runtime/components/transition'
-
-export default Transition

package/src/platforms/weex/runtime/directives/index.js

@@ -1,2 +0,0 @@
-export default {
-}

package/src/platforms/weex/runtime/index.js

@@ -1,42 +0,0 @@
-/* @flow */
-
-import Vue from 'core/index'
-import { patch } from 'weex/runtime/patch'
-import { mountComponent } from 'core/instance/lifecycle'
-import platformDirectives from 'weex/runtime/directives/index'
-import platformComponents from 'weex/runtime/components/index'
-
-import {
-  query,
-  mustUseProp,
-  isReservedTag,
-  isRuntimeComponent,
-  isUnknownElement
-} from 'weex/util/element'
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp
-Vue.config.isReservedTag = isReservedTag
-Vue.config.isRuntimeComponent = isRuntimeComponent
-Vue.config.isUnknownElement = isUnknownElement
-
-// install platform runtime directives and components
-Vue.options.directives = platformDirectives
-Vue.options.components = platformComponents
-
-// install platform patch function
-Vue.prototype.__patch__ = patch
-
-// wrap mount
-Vue.prototype.$mount = function (
-  el?: any,
-  hydrating?: boolean
-): Component {
-  return mountComponent(
-    this,
-    el && query(el, this.$document),
-    hydrating
-  )
-}
-
-export default Vue

package/src/platforms/weex/runtime/modules/attrs.js

@@ -1,44 +0,0 @@
-/* @flow */
-
-import { extend } from 'shared/util'
-
-function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!oldVnode.data.attrs && !vnode.data.attrs) {
-    return
-  }
-  let key, cur, old
-  const elm = vnode.elm
-  const oldAttrs = oldVnode.data.attrs || {}
-  let attrs = vnode.data.attrs || {}
-  // clone observed objects, as the user probably wants to mutate it
-  if (attrs.__ob__) {
-    attrs = vnode.data.attrs = extend({}, attrs)
-  }
-
-  const supportBatchUpdate = typeof elm.setAttrs === 'function'
-  const batchedAttrs = {}
-  for (key in attrs) {
-    cur = attrs[key]
-    old = oldAttrs[key]
-    if (old !== cur) {
-      supportBatchUpdate
-        ? (batchedAttrs[key] = cur)
-        : elm.setAttr(key, cur)
-    }
-  }
-  for (key in oldAttrs) {
-    if (attrs[key] == null) {
-      supportBatchUpdate
-        ? (batchedAttrs[key] = undefined)
-        : elm.setAttr(key)
-    }
-  }
-  if (supportBatchUpdate) {
-    elm.setAttrs(batchedAttrs)
-  }
-}
-
-export default {
-  create: updateAttrs,
-  update: updateAttrs
-}

package/src/platforms/weex/runtime/modules/class.js

@@ -1,76 +0,0 @@
-/* @flow */
-
-import { extend, isObject } from 'shared/util'
-
-function updateClass (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  const el = vnode.elm
-  const ctx = vnode.context
-
-  const data: VNodeData = vnode.data
-  const oldData: VNodeData = oldVnode.data
-  if (!data.staticClass &&
-    !data.class &&
-    (!oldData || (!oldData.staticClass && !oldData.class))
-  ) {
-    return
-  }
-
-  const oldClassList = makeClassList(oldData)
-  const classList = makeClassList(data)
-
-  if (typeof el.setClassList === 'function') {
-    el.setClassList(classList)
-  } else {
-    const style = getStyle(oldClassList, classList, ctx)
-    if (typeof el.setStyles === 'function') {
-      el.setStyles(style)
-    } else {
-      for (const key in style) {
-        el.setStyle(key, style[key])
-      }
-    }
-  }
-}
-
-function makeClassList (data: VNodeData): Array<string> {
-  const classList = []
-  // unlike web, weex vnode staticClass is an Array
-  const staticClass: any = data.staticClass
-  const dataClass = data.class
-  if (staticClass) {
-    classList.push.apply(classList, staticClass)
-  }
-  if (Array.isArray(dataClass)) {
-    classList.push.apply(classList, dataClass)
-  } else if (isObject(dataClass)) {
-    classList.push.apply(classList, Object.keys(dataClass).filter(className => dataClass[className]))
-  } else if (typeof dataClass === 'string') {
-    classList.push.apply(classList, dataClass.trim().split(/\s+/))
-  }
-  return classList
-}
-
-function getStyle (oldClassList: Array<string>, classList: Array<string>, ctx: Component): Object {
-  // style is a weex-only injected object
-  // compiled from <style> tags in weex files
-  const stylesheet: any = ctx.$options.style || {}
-  const result = {}
-  classList.forEach(name => {
-    const style = stylesheet[name]
-    extend(result, style)
-  })
-  oldClassList.forEach(name => {
-    const style = stylesheet[name]
-    for (const key in style) {
-      if (!result.hasOwnProperty(key)) {
-        result[key] = ''
-      }
-    }
-  })
-  return result
-}
-
-export default {
-  create: updateClass,
-  update: updateClass
-}

package/src/platforms/weex/runtime/modules/events.js

@@ -1,54 +0,0 @@
-/* @flow */
-
-import { updateListeners } from 'core/vdom/helpers/update-listeners'
-
-let target: any
-
-function createOnceHandler (event, handler, capture) {
-  const _target = target // save current target element in closure
-  return function onceHandler () {
-    const res = handler.apply(null, arguments)
-    if (res !== null) {
-      remove(event, onceHandler, capture, _target)
-    }
-  }
-}
-
-function add (
-  event: string,
-  handler: Function,
-  capture: boolean,
-  passive?: boolean,
-  params?: Array<any>
-) {
-  if (capture) {
-    console.log('Weex do not support event in bubble phase.')
-    return
-  }
-  target.addEvent(event, handler, params)
-}
-
-function remove (
-  event: string,
-  handler: any,
-  capture: any,
-  _target?: any
-) {
-  (_target || target).removeEvent(event)
-}
-
-function updateDOMListeners (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!oldVnode.data.on && !vnode.data.on) {
-    return
-  }
-  const on = vnode.data.on || {}
-  const oldOn = oldVnode.data.on || {}
-  target = vnode.elm
-  updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context)
-  target = undefined
-}
-
-export default {
-  create: updateDOMListeners,
-  update: updateDOMListeners
-}

package/src/platforms/weex/runtime/modules/index.js

@@ -1,13 +0,0 @@
-import attrs from './attrs'
-import klass from './class'
-import events from './events'
-import style from './style'
-import transition from './transition'
-
-export default [
-  attrs,
-  klass,
-  events,
-  style,
-  transition
-]