// fix env
|
try {
|
if (!global) global = {}
|
global.process = global.process || {}
|
global.process.env = global.process.env || {}
|
global.App = global.App || App
|
global.Page = global.Page || Page
|
global.Component = global.Component || Component
|
global.getApp = global.getApp || getApp
|
} catch (e) {}
|
|
;(function(global, factory) {
|
typeof exports === "object" && typeof module !== "undefined"
|
? (module.exports = factory())
|
: typeof define === "function" && define.amd
|
? define(factory)
|
: (global.Vue = factory())
|
})(this, function() {
|
"use strict"
|
|
//fixed by xxxxxx
|
function calcDiff(holder, key, newObj, oldObj) {
|
if (newObj === oldObj || newObj === undefined) {
|
return
|
}
|
|
if (newObj == null || oldObj == null || typeof newObj !== typeof oldObj) {
|
holder[key] = newObj
|
} else if (Array.isArray(newObj) && Array.isArray(oldObj)) {
|
if (newObj.length === oldObj.length) {
|
for (var i = 0, len = newObj.length; i < len; ++i) {
|
calcDiff(holder, key + "[" + i + "]", newObj[i], oldObj[i])
|
}
|
} else {
|
holder[key] = newObj
|
}
|
} else if (typeof newObj === "object" && typeof oldObj === "object") {
|
var newKeys = Object.keys(newObj)
|
var oldKeys = Object.keys(oldObj)
|
|
if (newKeys.length !== oldKeys.length) {
|
holder[key] = newObj
|
} else {
|
var allKeysSet = Object.create(null)
|
for (var i = 0, len = newKeys.length; i < len; ++i) {
|
allKeysSet[newKeys[i]] = true
|
allKeysSet[oldKeys[i]] = true
|
}
|
if (Object.keys(allKeysSet).length !== newKeys.length) {
|
holder[key] = newObj
|
} else {
|
for (var i = 0, len = newKeys.length; i < len; ++i) {
|
var k = newKeys[i]
|
calcDiff(holder, key + "." + k, newObj[k], oldObj[k])
|
}
|
}
|
}
|
} else if (newObj !== oldObj) {
|
holder[key] = newObj
|
}
|
}
|
|
function diff(newObj, oldObj) {
|
var keys = Object.keys(newObj)
|
var diffResult = {}
|
for (var i = 0, len = keys.length; i < len; ++i) {
|
var k = keys[i]
|
var oldKeyPath = k.split(".")
|
var oldValue = oldObj[oldKeyPath[0]]
|
for (var j = 1, jlen = oldKeyPath.length; j < jlen && oldValue !== undefined; ++j) {
|
oldValue = oldValue[oldKeyPath[j]]
|
}
|
calcDiff(diffResult, k, newObj[k], oldValue)
|
}
|
return diffResult
|
}
|
|
/* */
|
|
// these helpers produces better vm code in JS engines due to their
|
// explicitness and function inlining
|
function isUndef(v) {
|
return v === undefined || v === null
|
}
|
|
function isDef(v) {
|
return v !== undefined && v !== null
|
}
|
|
function isTrue(v) {
|
return v === true
|
}
|
|
function isFalse(v) {
|
return v === false
|
}
|
|
/**
|
* Check if value is primitive
|
*/
|
function isPrimitive(value) {
|
return typeof value === "string" || typeof value === "number"
|
}
|
|
/**
|
* Quick object check - this is primarily used to tell
|
* Objects from primitive values when we know the value
|
* is a JSON-compliant type.
|
*/
|
function isObject(obj) {
|
return obj !== null && typeof obj === "object"
|
}
|
|
var _toString = Object.prototype.toString
|
|
/**
|
* Strict object type check. Only returns true
|
* for plain JavaScript objects.
|
*/
|
function isPlainObject(obj) {
|
return _toString.call(obj) === "[object Object]"
|
}
|
|
function isRegExp(v) {
|
return _toString.call(v) === "[object RegExp]"
|
}
|
|
/**
|
* Check if val is a valid array index.
|
*/
|
function isValidArrayIndex(val) {
|
var n = parseFloat(val)
|
return n >= 0 && Math.floor(n) === n && isFinite(val)
|
}
|
|
/**
|
* Convert a value to a string that is actually rendered.
|
*/
|
function toString(val) {
|
return val == null
|
? ""
|
: typeof val === "object"
|
? JSON.stringify(val, null, 2)
|
: String(val)
|
}
|
|
/**
|
* Convert a input value to a number for persistence.
|
* If the conversion fails, return original string.
|
*/
|
function toNumber(val) {
|
var n = parseFloat(val)
|
return isNaN(n) ? val : n
|
}
|
|
/**
|
* Make a map and return a function for checking if a key
|
* is in that map.
|
*/
|
function makeMap(str, expectsLowerCase) {
|
var map = Object.create(null)
|
var list = str.split(",")
|
for (var i = 0; i < list.length; i++) {
|
map[list[i]] = true
|
}
|
return expectsLowerCase
|
? function(val) {
|
return map[val.toLowerCase()]
|
}
|
: function(val) {
|
return map[val]
|
}
|
}
|
|
/**
|
* Check if a tag is a built-in tag.
|
*/
|
var isBuiltInTag = makeMap("slot,component", true)
|
|
/**
|
* Check if a attribute is a reserved attribute.
|
*/
|
var isReservedAttribute = makeMap("key,ref,slot,is")
|
|
/**
|
* Remove an item from an array
|
*/
|
function remove(arr, item) {
|
if (arr.length) {
|
var index = arr.indexOf(item)
|
if (index > -1) {
|
return arr.splice(index, 1)
|
}
|
}
|
}
|
|
/**
|
* Check whether the object has the property.
|
*/
|
var hasOwnProperty = Object.prototype.hasOwnProperty
|
|
function hasOwn(obj, key) {
|
return hasOwnProperty.call(obj, key)
|
}
|
|
/**
|
* Create a cached version of a pure function.
|
*/
|
function cached(fn) {
|
var cache = Object.create(null)
|
return function cachedFn(str) {
|
var hit = cache[str]
|
return hit || (cache[str] = fn(str))
|
}
|
}
|
|
/**
|
* Camelize a hyphen-delimited string.
|
*/
|
var camelizeRE = /-(\w)/g
|
var camelize = cached(function(str) {
|
return str.replace(camelizeRE, function(_, c) {
|
return c ? c.toUpperCase() : ""
|
})
|
})
|
|
/**
|
* Capitalize a string.
|
*/
|
var capitalize = cached(function(str) {
|
return str.charAt(0).toUpperCase() + str.slice(1)
|
})
|
|
/**
|
* Hyphenate a camelCase string.
|
*/
|
var hyphenateRE = /([^-])([A-Z])/g
|
var hyphenate = cached(function(str) {
|
return str
|
.replace(hyphenateRE, "$1-$2")
|
.replace(hyphenateRE, "$1-$2")
|
.toLowerCase()
|
})
|
|
/**
|
* Simple bind, faster than native
|
*/
|
function bind(fn, ctx) {
|
function boundFn(a) {
|
var l = arguments.length
|
return l ? (l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a)) : fn.call(ctx)
|
}
|
// record original fn length
|
boundFn._length = fn.length
|
return boundFn
|
}
|
|
/**
|
* Convert an Array-like object to a real Array.
|
*/
|
function toArray(list, start) {
|
start = start || 0
|
var i = list.length - start
|
var ret = new Array(i)
|
while (i--) {
|
ret[i] = list[i + start]
|
}
|
return ret
|
}
|
|
/**
|
* Mix properties into target object.
|
*/
|
function extend(to, _from) {
|
for (var key in _from) {
|
to[key] = _from[key]
|
}
|
return to
|
}
|
|
/**
|
* Merge an Array of Objects into a single Object.
|
*/
|
function toObject(arr) {
|
var res = {}
|
for (var i = 0; i < arr.length; i++) {
|
if (arr[i]) {
|
extend(res, arr[i])
|
}
|
}
|
return res
|
}
|
|
/**
|
* Perform no operation.
|
* Stubbing args to make Flow happy without leaving useless transpiled code
|
* with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
|
*/
|
function noop(a, b, c) {}
|
|
/**
|
* Always return false.
|
*/
|
var no = function(a, b, c) {
|
return false
|
}
|
|
/**
|
* Return same value
|
*/
|
var identity = function(_) {
|
return _
|
}
|
|
/**
|
* Generate a static keys string from compiler modules.
|
*/
|
|
/**
|
* Check if two values are loosely equal - that is,
|
* if they are plain objects, do they have the same shape?
|
*/
|
function looseEqual(a, b) {
|
var isObjectA = isObject(a)
|
var isObjectB = isObject(b)
|
if (isObjectA && isObjectB) {
|
try {
|
return JSON.stringify(a) === JSON.stringify(b)
|
} catch (e) {
|
// possible circular reference
|
return a === b
|
}
|
} else if (!isObjectA && !isObjectB) {
|
return String(a) === String(b)
|
} else {
|
return false
|
}
|
}
|
|
function looseIndexOf(arr, val) {
|
for (var i = 0; i < arr.length; i++) {
|
if (looseEqual(arr[i], val)) {
|
return i
|
}
|
}
|
return -1
|
}
|
|
/**
|
* Ensure a function is called only once.
|
*/
|
function once(fn) {
|
var called = false
|
return function() {
|
if (!called) {
|
called = true
|
fn.apply(this, arguments)
|
}
|
}
|
}
|
|
var SSR_ATTR = "data-server-rendered"
|
|
var ASSET_TYPES = ["component", "directive", "filter"]
|
|
var LIFECYCLE_HOOKS = [
|
"beforeCreate",
|
"created",
|
"beforeMount",
|
"mounted",
|
"beforeUpdate",
|
"updated",
|
"beforeDestroy",
|
"destroyed",
|
"activated",
|
"deactivated",
|
"onLaunch",
|
"onLoad",
|
"onShow",
|
"onReady",
|
"onHide",
|
"onUnload",
|
"onPullDownRefresh",
|
"onReachBottom",
|
"onShareAppMessage",
|
"onPageScroll",
|
"onTabItemTap",
|
"attached",
|
"ready",
|
"moved",
|
"detached",
|
"onUniNViewMessage", //fixed by xxxxxx
|
"onNavigationBarButtonTap", //fixed by xxxxxx
|
"onBackPress",//fixed by xxxxxx
|
]
|
|
/* */
|
|
var config = {
|
/**
|
* Option merge strategies (used in core/util/options)
|
*/
|
optionMergeStrategies: Object.create(null),
|
|
/**
|
* Whether to suppress warnings.
|
*/
|
silent: false,
|
|
/**
|
* Show production mode tip message on boot?
|
*/
|
productionTip: "production" !== "production",
|
|
/**
|
* Whether to enable devtools
|
*/
|
devtools: "production" !== "production",
|
|
/**
|
* Whether to record perf
|
*/
|
performance: false,
|
|
/**
|
* Error handler for watcher errors
|
*/
|
errorHandler: null,
|
|
/**
|
* Warn handler for watcher warns
|
*/
|
warnHandler: null,
|
|
/**
|
* Ignore certain custom elements
|
*/
|
ignoredElements: [],
|
|
/**
|
* Custom user key aliases for v-on
|
*/
|
keyCodes: Object.create(null),
|
|
/**
|
* Check if a tag is reserved so that it cannot be registered as a
|
* component. This is platform-dependent and may be overwritten.
|
*/
|
isReservedTag: no,
|
|
/**
|
* Check if an attribute is reserved so that it cannot be used as a component
|
* prop. This is platform-dependent and may be overwritten.
|
*/
|
isReservedAttr: no,
|
|
/**
|
* Check if a tag is an unknown element.
|
* Platform-dependent.
|
*/
|
isUnknownElement: no,
|
|
/**
|
* Get the namespace of an element
|
*/
|
getTagNamespace: noop,
|
|
/**
|
* Parse the real tag name for the specific platform.
|
*/
|
parsePlatformTagName: identity,
|
|
/**
|
* Check if an attribute must be bound using property, e.g. value
|
* Platform-dependent.
|
*/
|
mustUseProp: no,
|
|
/**
|
* Exposed for legacy reasons
|
*/
|
_lifecycleHooks: LIFECYCLE_HOOKS
|
}
|
|
/* */
|
|
var emptyObject = Object.freeze({})
|
|
/**
|
* Check if a string starts with $ or _
|
*/
|
function isReserved(str) {
|
var c = (str + "").charCodeAt(0)
|
return c === 0x24 || c === 0x5f
|
}
|
|
/**
|
* Define a property.
|
*/
|
function def(obj, key, val, enumerable) {
|
Object.defineProperty(obj, key, {
|
value: val,
|
enumerable: !!enumerable,
|
writable: true,
|
configurable: true
|
})
|
}
|
|
/**
|
* Parse simple path.
|
*/
|
var bailRE = /[^\w.$]/
|
|
function parsePath(path) {
|
if (bailRE.test(path)) {
|
return
|
}
|
var segments = path.split(".")
|
return function(obj) {
|
for (var i = 0; i < segments.length; i++) {
|
if (!obj) {
|
return
|
}
|
obj = obj[segments[i]]
|
}
|
return obj
|
}
|
}
|
|
/* */
|
|
var warn = noop
|
|
var formatComponentName = null // work around flow check
|
|
/* */
|
|
function handleError(err, vm, info) {
|
if (config.errorHandler) {
|
config.errorHandler.call(null, err, vm, info)
|
} else {
|
if (inBrowser && typeof console !== "undefined") {
|
console.error(err)
|
} else {
|
throw err
|
}
|
}
|
}
|
|
/* */
|
|
// can we use __proto__?
|
var hasProto = "__proto__" in {}
|
|
// Browser environment sniffing
|
var inBrowser = typeof window !== "undefined"
|
var UA = ["mpvue-runtime"].join()
|
var isIE = UA && /msie|trident/.test(UA)
|
var isIE9 = UA && UA.indexOf("msie 9.0") > 0
|
var isEdge = UA && UA.indexOf("edge/") > 0
|
var isAndroid = UA && UA.indexOf("android") > 0
|
var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA)
|
var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
|
|
// Firefix has a "watch" function on Object.prototype...
|
var nativeWatch = {}.watch
|
|
var supportsPassive = false
|
if (inBrowser) {
|
try {
|
var opts = {}
|
Object.defineProperty(opts, "passive", {
|
get: function get() {
|
/* istanbul ignore next */
|
supportsPassive = true
|
}
|
}) // https://github.com/facebook/flow/issues/285
|
window.addEventListener("test-passive", null, opts)
|
} catch (e) {}
|
}
|
|
// this needs to be lazy-evaled because vue may be required before
|
// vue-server-renderer can set VUE_ENV
|
var _isServer
|
var isServerRendering = function() {
|
if (_isServer === undefined) {
|
/* istanbul ignore if */
|
if (!inBrowser && typeof global !== "undefined") {
|
// detect presence of vue-server-renderer and avoid
|
// Webpack shimming the process
|
_isServer = global["process"].env.VUE_ENV === "server"
|
} else {
|
_isServer = false
|
}
|
}
|
return _isServer
|
}
|
|
// detect devtools
|
var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__
|
|
/* istanbul ignore next */
|
function isNative(Ctor) {
|
return typeof Ctor === "function" && /native code/.test(Ctor.toString())
|
}
|
|
var hasSymbol =
|
typeof Symbol !== "undefined" &&
|
isNative(Symbol) &&
|
typeof Reflect !== "undefined" &&
|
isNative(Reflect.ownKeys)
|
|
/**
|
* Defer a task to execute it asynchronously.
|
*/
|
var nextTick = (function() {
|
var callbacks = []
|
var pending = false
|
var timerFunc
|
|
function nextTickHandler() {
|
pending = false
|
var copies = callbacks.slice(0)
|
callbacks.length = 0
|
for (var i = 0; i < copies.length; i++) {
|
copies[i]()
|
}
|
}
|
|
// the nextTick behavior leverages the microtask queue, which can be accessed
|
// via either native Promise.then or MutationObserver.
|
// MutationObserver has wider support, however it is seriously bugged in
|
// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
|
// completely stops working after triggering a few times... so, if native
|
// Promise is available, we will use it:
|
/* istanbul ignore if */
|
if (typeof Promise !== "undefined" && isNative(Promise)) {
|
var p = Promise.resolve()
|
var logError = function(err) {
|
console.error(err)
|
}
|
timerFunc = function() {
|
p.then(nextTickHandler).catch(logError)
|
// in problematic UIWebViews, Promise.then doesn't completely break, but
|
// it can get stuck in a weird state where callbacks are pushed into the
|
// microtask queue but the queue isn't being flushed, until the browser
|
// needs to do some other work, e.g. handle a timer. Therefore we can
|
// "force" the microtask queue to be flushed by adding an empty timer.
|
if (isIOS) {
|
setTimeout(noop)
|
}
|
}
|
// } else if (typeof MutationObserver !== 'undefined' && (
|
// isNative(MutationObserver) ||
|
// // PhantomJS and iOS 7.x
|
// MutationObserver.toString() === '[object MutationObserverConstructor]'
|
// )) {
|
// // use MutationObserver where native Promise is not available,
|
// // e.g. PhantomJS IE11, iOS7, Android 4.4
|
// var counter = 1
|
// var observer = new MutationObserver(nextTickHandler)
|
// var textNode = document.createTextNode(String(counter))
|
// observer.observe(textNode, {
|
// characterData: true
|
// })
|
// timerFunc = () => {
|
// counter = (counter + 1) % 2
|
// textNode.data = String(counter)
|
// }
|
} else {
|
// fallback to setTimeout
|
/* istanbul ignore next */
|
timerFunc = function() {
|
setTimeout(nextTickHandler, 0)
|
}
|
}
|
|
return function queueNextTick(cb, ctx) {
|
var _resolve
|
callbacks.push(function() {
|
if (cb) {
|
try {
|
cb.call(ctx)
|
} catch (e) {
|
handleError(e, ctx, "nextTick")
|
}
|
} else if (_resolve) {
|
_resolve(ctx)
|
}
|
})
|
if (!pending) {
|
pending = true
|
timerFunc()
|
}
|
if (!cb && typeof Promise !== "undefined") {
|
return new Promise(function(resolve, reject) {
|
_resolve = resolve
|
})
|
}
|
}
|
})()
|
|
var _Set
|
/* istanbul ignore if */
|
if (typeof Set !== "undefined" && isNative(Set)) {
|
// use native Set when available.
|
_Set = Set
|
} else {
|
// a non-standard Set polyfill that only works with primitive keys.
|
_Set = (function() {
|
function Set() {
|
this.set = Object.create(null)
|
}
|
Set.prototype.has = function has(key) {
|
return this.set[key] === true
|
}
|
Set.prototype.add = function add(key) {
|
this.set[key] = true
|
}
|
Set.prototype.clear = function clear() {
|
this.set = Object.create(null)
|
}
|
|
return Set
|
})()
|
}
|
|
/* */
|
|
var uid$1 = 0
|
|
/**
|
* A dep is an observable that can have multiple
|
* directives subscribing to it.
|
*/
|
var Dep = function Dep() {
|
this.id = uid$1++
|
this.subs = []
|
}
|
|
Dep.prototype.addSub = function addSub(sub) {
|
this.subs.push(sub)
|
}
|
|
Dep.prototype.removeSub = function removeSub(sub) {
|
remove(this.subs, sub)
|
}
|
|
Dep.prototype.depend = function depend() {
|
if (Dep.target) {
|
Dep.target.addDep(this)
|
}
|
}
|
|
Dep.prototype.notify = function notify() {
|
// stabilize the subscriber list first
|
var subs = this.subs.slice()
|
for (var i = 0, l = subs.length; i < l; i++) {
|
subs[i].update()
|
}
|
}
|
|
// the current target watcher being evaluated.
|
// this is globally unique because there could be only one
|
// watcher being evaluated at any time.
|
Dep.target = null
|
var targetStack = []
|
|
function pushTarget(_target) {
|
if (Dep.target) {
|
targetStack.push(Dep.target)
|
}
|
Dep.target = _target
|
}
|
|
function popTarget() {
|
Dep.target = targetStack.pop()
|
}
|
|
/*
|
* not type checking this file because flow doesn't play well with
|
* dynamically accessing methods on Array prototype
|
*/
|
|
var arrayProto = Array.prototype
|
var arrayMethods = Object.create(arrayProto)
|
;["push", "pop", "shift", "unshift", "splice", "sort", "reverse"].forEach(function(method) {
|
// cache original method
|
var original = arrayProto[method]
|
def(arrayMethods, method, function mutator() {
|
var args = [],
|
len = arguments.length
|
while (len--) args[len] = arguments[len]
|
|
var result = original.apply(this, args)
|
var ob = this.__ob__
|
var inserted
|
switch (method) {
|
case "push":
|
case "unshift":
|
inserted = args
|
break
|
case "splice":
|
inserted = args.slice(2)
|
break
|
}
|
if (inserted) {
|
ob.observeArray(inserted)
|
}
|
// notify change
|
ob.dep.notify()
|
return result
|
})
|
})
|
|
/* */
|
|
var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
|
|
/**
|
* By default, when a reactive property is set, the new value is
|
* also converted to become reactive. However when passing down props,
|
* we don't want to force conversion because the value may be a nested value
|
* under a frozen data structure. Converting it would defeat the optimization.
|
*/
|
var observerState = {
|
shouldConvert: true
|
}
|
|
/**
|
* Observer class that are attached to each observed
|
* object. Once attached, the observer converts target
|
* object's property keys into getter/setters that
|
* collect dependencies and dispatches updates.
|
*/
|
var Observer = function Observer(value) {
|
this.value = value
|
this.dep = new Dep()
|
this.vmCount = 0
|
def(value, "__ob__", this)
|
if (Array.isArray(value)) {
|
var augment = hasProto ? protoAugment : copyAugment
|
augment(value, arrayMethods, arrayKeys)
|
this.observeArray(value)
|
} else {
|
this.walk(value)
|
}
|
}
|
|
/**
|
* Walk through each property and convert them into
|
* getter/setters. This method should only be called when
|
* value type is Object.
|
*/
|
Observer.prototype.walk = function walk(obj) {
|
var keys = Object.keys(obj)
|
for (var i = 0; i < keys.length; i++) {
|
defineReactive$$1(obj, keys[i], obj[keys[i]])
|
}
|
}
|
|
/**
|
* Observe a list of Array items.
|
*/
|
Observer.prototype.observeArray = function observeArray(items) {
|
for (var i = 0, l = items.length; i < l; i++) {
|
observe(items[i])
|
}
|
}
|
|
// helpers
|
|
/**
|
* Augment an target Object or Array by intercepting
|
* the prototype chain using __proto__
|
*/
|
function protoAugment(target, src, keys) {
|
/* eslint-disable no-proto */
|
target.__proto__ = src
|
/* eslint-enable no-proto */
|
}
|
|
/**
|
* Augment an target Object or Array by defining
|
* hidden properties.
|
*/
|
/* istanbul ignore next */
|
function copyAugment(target, src, keys) {
|
for (var i = 0, l = keys.length; i < l; i++) {
|
var key = keys[i]
|
def(target, key, src[key])
|
}
|
}
|
|
/**
|
* Attempt to create an observer instance for a value,
|
* returns the new observer if successfully observed,
|
* or the existing observer if the value already has one.
|
*/
|
function observe(value, asRootData) {
|
if (!isObject(value)) {
|
return
|
}
|
var ob
|
if (hasOwn(value, "__ob__") && value.__ob__ instanceof Observer) {
|
ob = value.__ob__
|
} else if (
|
observerState.shouldConvert &&
|
!isServerRendering() &&
|
(Array.isArray(value) || isPlainObject(value)) &&
|
Object.isExtensible(value) &&
|
!value._isVue
|
) {
|
ob = new Observer(value)
|
}
|
if (asRootData && ob) {
|
ob.vmCount++
|
}
|
return ob
|
}
|
|
/**
|
* Define a reactive property on an Object.
|
*/
|
function defineReactive$$1(obj, key, val, customSetter, shallow) {
|
var dep = new Dep()
|
|
var property = Object.getOwnPropertyDescriptor(obj, key)
|
if (property && property.configurable === false) {
|
return
|
}
|
|
// cater for pre-defined getter/setters
|
var getter = property && property.get
|
var setter = property && property.set
|
|
var childOb = !shallow && observe(val)
|
Object.defineProperty(obj, key, {
|
enumerable: true,
|
configurable: true,
|
get: function reactiveGetter() {
|
var value = getter ? getter.call(obj) : val
|
if (Dep.target) {
|
dep.depend()
|
if (childOb) {
|
childOb.dep.depend()
|
}
|
if (Array.isArray(value)) {
|
dependArray(value)
|
}
|
}
|
return value
|
},
|
set: function reactiveSetter(newVal) {
|
var value = getter ? getter.call(obj) : val
|
/* eslint-disable no-self-compare */
|
if (newVal === value || (newVal !== newVal && value !== value)) {
|
return
|
}
|
/* eslint-enable no-self-compare */
|
if ("production" !== "production" && customSetter) {
|
customSetter()
|
}
|
if (setter) {
|
setter.call(obj, newVal)
|
} else {
|
val = newVal
|
}
|
childOb = !shallow && observe(newVal)
|
dep.notify()
|
}
|
})
|
}
|
|
/**
|
* Set a property on an object. Adds the new property and
|
* triggers change notification if the property doesn't
|
* already exist.
|
*/
|
function set(target, key, val) {
|
if (Array.isArray(target) && isValidArrayIndex(key)) {
|
target.length = Math.max(target.length, key)
|
target.splice(key, 1, val)
|
return val
|
}
|
if (hasOwn(target, key)) {
|
target[key] = val
|
return val
|
}
|
var ob = target.__ob__
|
if (target._isVue || (ob && ob.vmCount)) {
|
"production" !== "production" &&
|
warn(
|
"Avoid adding reactive properties to a Vue instance or its root $data " +
|
"at runtime - declare it upfront in the data option."
|
)
|
return val
|
}
|
if (!ob) {
|
target[key] = val
|
return val
|
}
|
defineReactive$$1(ob.value, key, val)
|
ob.dep.notify()
|
return val
|
}
|
|
/**
|
* Delete a property and trigger change if necessary.
|
*/
|
function del(target, key) {
|
if (Array.isArray(target) && isValidArrayIndex(key)) {
|
target.splice(key, 1)
|
return
|
}
|
var ob = target.__ob__
|
if (target._isVue || (ob && ob.vmCount)) {
|
"production" !== "production" &&
|
warn(
|
"Avoid deleting properties on a Vue instance or its root $data " +
|
"- just set it to null."
|
)
|
return
|
}
|
if (!hasOwn(target, key)) {
|
return
|
}
|
delete target[key]
|
if (!ob) {
|
return
|
}
|
ob.dep.notify()
|
}
|
|
/**
|
* Collect dependencies on array elements when the array is touched, since
|
* we cannot intercept array element access like property getters.
|
*/
|
function dependArray(value) {
|
for (var e = void 0, i = 0, l = value.length; i < l; i++) {
|
e = value[i]
|
e && e.__ob__ && e.__ob__.dep.depend()
|
if (Array.isArray(e)) {
|
dependArray(e)
|
}
|
}
|
}
|
|
/* */
|
|
/**
|
* Option overwriting strategies are functions that handle
|
* how to merge a parent option value and a child option
|
* value into the final value.
|
*/
|
var strats = config.optionMergeStrategies
|
|
/**
|
* Options with restrictions
|
*/
|
/**
|
* Helper that recursively merges two data objects together.
|
*/
|
function mergeData(to, from) {
|
if (!from) {
|
return to
|
}
|
var key, toVal, fromVal
|
var keys = Object.keys(from)
|
for (var i = 0; i < keys.length; i++) {
|
key = keys[i]
|
toVal = to[key]
|
fromVal = from[key]
|
if (!hasOwn(to, key)) {
|
set(to, key, fromVal)
|
} else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
|
mergeData(toVal, fromVal)
|
}
|
}
|
return to
|
}
|
|
/**
|
* Data
|
*/
|
function mergeDataOrFn(parentVal, childVal, vm) {
|
if (!vm) {
|
// in a Vue.extend merge, both should be functions
|
if (!childVal) {
|
return parentVal
|
}
|
if (!parentVal) {
|
return childVal
|
}
|
// when parentVal & childVal are both present,
|
// we need to return a function that returns the
|
// merged result of both functions... no need to
|
// check if parentVal is a function here because
|
// it has to be a function to pass previous merges.
|
return function mergedDataFn() {
|
return mergeData(
|
typeof childVal === "function" ? childVal.call(this) : childVal,
|
parentVal.call(this)
|
)
|
}
|
} else if (parentVal || childVal) {
|
return function mergedInstanceDataFn() {
|
// instance merge
|
var instanceData = typeof childVal === "function" ? childVal.call(vm) : childVal
|
var defaultData = typeof parentVal === "function" ? parentVal.call(vm) : undefined
|
if (instanceData) {
|
return mergeData(instanceData, defaultData)
|
} else {
|
return defaultData
|
}
|
}
|
}
|
}
|
|
strats.data = function(parentVal, childVal, vm) {
|
if (!vm) {
|
if (childVal && typeof childVal !== "function") {
|
"production" !== "production" &&
|
warn(
|
'The "data" option should be a function ' +
|
"that returns a per-instance value in component " +
|
"definitions.",
|
vm
|
)
|
|
return parentVal
|
}
|
return mergeDataOrFn.call(this, parentVal, childVal)
|
}
|
|
return mergeDataOrFn(parentVal, childVal, vm)
|
}
|
|
/**
|
* Hooks and props are merged as arrays.
|
*/
|
function mergeHook(parentVal, childVal) {
|
return childVal
|
? parentVal
|
? parentVal.concat(childVal)
|
: Array.isArray(childVal)
|
? childVal
|
: [childVal]
|
: parentVal
|
}
|
|
LIFECYCLE_HOOKS.forEach(function(hook) {
|
strats[hook] = mergeHook
|
})
|
|
/**
|
* Assets
|
*
|
* When a vm is present (instance creation), we need to do
|
* a three-way merge between constructor options, instance
|
* options and parent options.
|
*/
|
function mergeAssets(parentVal, childVal) {
|
var res = Object.create(parentVal || null)
|
return childVal ? extend(res, childVal) : res
|
}
|
|
ASSET_TYPES.forEach(function(type) {
|
strats[type + "s"] = mergeAssets
|
})
|
|
/**
|
* Watchers.
|
*
|
* Watchers hashes should not overwrite one
|
* another, so we merge them as arrays.
|
*/
|
strats.watch = function(parentVal, childVal) {
|
// work around Firefox's Object.prototype.watch...
|
if (parentVal === nativeWatch) {
|
parentVal = undefined
|
}
|
if (childVal === nativeWatch) {
|
childVal = undefined
|
}
|
/* istanbul ignore if */
|
if (!childVal) {
|
return Object.create(parentVal || null)
|
}
|
if (!parentVal) {
|
return childVal
|
}
|
var ret = {}
|
extend(ret, parentVal)
|
for (var key in childVal) {
|
var parent = ret[key]
|
var child = childVal[key]
|
if (parent && !Array.isArray(parent)) {
|
parent = [parent]
|
}
|
ret[key] = parent ? parent.concat(child) : Array.isArray(child) ? child : [child]
|
}
|
return ret
|
}
|
|
/**
|
* Other object hashes.
|
*/
|
strats.props = strats.methods = strats.inject = strats.computed = function(
|
parentVal,
|
childVal
|
) {
|
if (!childVal) {
|
return Object.create(parentVal || null)
|
}
|
if (!parentVal) {
|
return childVal
|
}
|
var ret = Object.create(null)
|
extend(ret, parentVal)
|
extend(ret, childVal)
|
return ret
|
}
|
strats.provide = mergeDataOrFn
|
|
/**
|
* Default strategy.
|
*/
|
var defaultStrat = function(parentVal, childVal) {
|
return childVal === undefined ? parentVal : childVal
|
}
|
|
/**
|
* Ensure all props option syntax are normalized into the
|
* Object-based format.
|
*/
|
function normalizeProps(options) {
|
var props = options.props
|
if (!props) {
|
return
|
}
|
var res = {}
|
var i, val, name
|
if (Array.isArray(props)) {
|
i = props.length
|
while (i--) {
|
val = props[i]
|
if (typeof val === "string") {
|
name = camelize(val)
|
res[name] = {
|
type: null
|
}
|
} else {
|
}
|
}
|
} else if (isPlainObject(props)) {
|
for (var key in props) {
|
val = props[key]
|
name = camelize(key)
|
res[name] = isPlainObject(val)
|
? val
|
: {
|
type: val
|
}
|
}
|
}
|
options.props = res
|
}
|
|
/**
|
* Normalize all injections into Object-based format
|
*/
|
function normalizeInject(options) {
|
var inject = options.inject
|
if (Array.isArray(inject)) {
|
var normalized = (options.inject = {})
|
for (var i = 0; i < inject.length; i++) {
|
normalized[inject[i]] = inject[i]
|
}
|
}
|
}
|
|
/**
|
* Normalize raw function directives into object format.
|
*/
|
function normalizeDirectives(options) {
|
var dirs = options.directives
|
if (dirs) {
|
for (var key in dirs) {
|
var def = dirs[key]
|
if (typeof def === "function") {
|
dirs[key] = {
|
bind: def,
|
update: def
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* Merge two option objects into a new one.
|
* Core utility used in both instantiation and inheritance.
|
*/
|
function mergeOptions(parent, child, vm) {
|
if (typeof child === "function") {
|
child = child.options
|
}
|
|
normalizeProps(child)
|
normalizeInject(child)
|
normalizeDirectives(child)
|
var extendsFrom = child.extends
|
if (extendsFrom) {
|
parent = mergeOptions(parent, extendsFrom, vm)
|
}
|
if (child.mixins) {
|
for (var i = 0, l = child.mixins.length; i < l; i++) {
|
parent = mergeOptions(parent, child.mixins[i], vm)
|
}
|
}
|
var options = {}
|
var key
|
for (key in parent) {
|
mergeField(key)
|
}
|
for (key in child) {
|
if (!hasOwn(parent, key)) {
|
mergeField(key)
|
}
|
}
|
|
function mergeField(key) {
|
var strat = strats[key] || defaultStrat
|
options[key] = strat(parent[key], child[key], vm, key)
|
}
|
return options
|
}
|
|
/**
|
* Resolve an asset.
|
* This function is used because child instances need access
|
* to assets defined in its ancestor chain.
|
*/
|
function resolveAsset(options, type, id, warnMissing) {
|
/* istanbul ignore if */
|
if (typeof id !== "string") {
|
return
|
}
|
var assets = options[type]
|
// check local registration variations first
|
if (hasOwn(assets, id)) {
|
return assets[id]
|
}
|
var camelizedId = camelize(id)
|
if (hasOwn(assets, camelizedId)) {
|
return assets[camelizedId]
|
}
|
var PascalCaseId = capitalize(camelizedId)
|
if (hasOwn(assets, PascalCaseId)) {
|
return assets[PascalCaseId]
|
}
|
// fallback to prototype chain
|
var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]
|
if ("production" !== "production" && warnMissing && !res) {
|
warn("Failed to resolve " + type.slice(0, -1) + ": " + id, options)
|
}
|
return res
|
}
|
|
/* */
|
|
function validateProp(key, propOptions, propsData, vm) {
|
var prop = propOptions[key]
|
var absent = !hasOwn(propsData, key)
|
var value = propsData[key]
|
// handle boolean props
|
if (isType(Boolean, prop.type)) {
|
if (absent && !hasOwn(prop, "default")) {
|
value = false
|
} else if (!isType(String, prop.type) && (value === "" || value === hyphenate(key))) {
|
value = true
|
}
|
}
|
// check default value
|
if (value === undefined) {
|
value = getPropDefaultValue(vm, prop, key)
|
// since the default value is a fresh copy,
|
// make sure to observe it.
|
var prevShouldConvert = observerState.shouldConvert
|
observerState.shouldConvert = true
|
observe(value)
|
observerState.shouldConvert = prevShouldConvert
|
}
|
return value
|
}
|
|
/**
|
* Get the default value of a prop.
|
*/
|
function getPropDefaultValue(vm, prop, key) {
|
// no default, return undefined
|
if (!hasOwn(prop, "default")) {
|
return undefined
|
}
|
var def = prop.default
|
// warn against non-factory defaults for Object & Array
|
if ("production" !== "production" && isObject(def)) {
|
warn(
|
'Invalid default value for prop "' +
|
key +
|
'": ' +
|
"Props with type Object/Array must use a factory function " +
|
"to return the default value.",
|
vm
|
)
|
}
|
// the raw prop value was also undefined from previous render,
|
// return previous default value to avoid unnecessary watcher trigger
|
if (
|
vm &&
|
vm.$options.propsData &&
|
vm.$options.propsData[key] === undefined &&
|
vm._props[key] !== undefined
|
) {
|
return vm._props[key]
|
}
|
// call factory function for non-Function types
|
// a value is Function if its prototype is function even across different execution context
|
return typeof def === "function" && getType(prop.type) !== "Function" ? def.call(vm) : def
|
}
|
|
/**
|
* Use function string name to check built-in types,
|
* because a simple equality check will fail when running
|
* across different vms / iframes.
|
*/
|
function getType(fn) {
|
var match = fn && fn.toString().match(/^\s*function (\w+)/)
|
return match ? match[1] : ""
|
}
|
|
function isType(type, fn) {
|
if (!Array.isArray(fn)) {
|
return getType(fn) === getType(type)
|
}
|
for (var i = 0, len = fn.length; i < len; i++) {
|
if (getType(fn[i]) === getType(type)) {
|
return true
|
}
|
}
|
/* istanbul ignore next */
|
return false
|
}
|
|
/* */
|
|
/* not type checking this file because flow doesn't play well with Proxy */
|
|
var mark
|
var measure
|
|
/* */
|
|
var VNode = function VNode(
|
tag,
|
data,
|
children,
|
text,
|
elm,
|
context,
|
componentOptions,
|
asyncFactory
|
) {
|
this.tag = tag
|
this.data = data
|
this.children = children
|
this.text = text
|
this.elm = elm
|
this.ns = undefined
|
this.context = context
|
this.functionalContext = undefined
|
this.key = data && data.key
|
this.componentOptions = componentOptions
|
this.componentInstance = undefined
|
this.parent = undefined
|
this.raw = false
|
this.isStatic = false
|
this.isRootInsert = true
|
this.isComment = false
|
this.isCloned = false
|
this.isOnce = false
|
this.asyncFactory = asyncFactory
|
this.asyncMeta = undefined
|
this.isAsyncPlaceholder = false
|
}
|
|
var prototypeAccessors = {
|
child: {}
|
}
|
|
// DEPRECATED: alias for componentInstance for backwards compat.
|
/* istanbul ignore next */
|
prototypeAccessors.child.get = function() {
|
return this.componentInstance
|
}
|
|
Object.defineProperties(VNode.prototype, prototypeAccessors)
|
|
var createEmptyVNode = function(text) {
|
if (text === void 0) text = ""
|
|
var node = new VNode()
|
node.text = text
|
node.isComment = true
|
return node
|
}
|
|
function createTextVNode(val) {
|
return new VNode(undefined, undefined, undefined, String(val))
|
}
|
|
// optimized shallow clone
|
// used for static nodes and slot nodes because they may be reused across
|
// multiple renders, cloning them avoids errors when DOM manipulations rely
|
// on their elm reference.
|
function cloneVNode(vnode) {
|
var cloned = new VNode(
|
vnode.tag,
|
vnode.data,
|
vnode.children,
|
vnode.text,
|
vnode.elm,
|
vnode.context,
|
vnode.componentOptions,
|
vnode.asyncFactory
|
)
|
cloned.ns = vnode.ns
|
cloned.isStatic = vnode.isStatic
|
cloned.key = vnode.key
|
cloned.isComment = vnode.isComment
|
cloned.isCloned = true
|
return cloned
|
}
|
|
function cloneVNodes(vnodes) {
|
var len = vnodes.length
|
var res = new Array(len)
|
for (var i = 0; i < len; i++) {
|
res[i] = cloneVNode(vnodes[i])
|
}
|
return res
|
}
|
|
/* */
|
|
var normalizeEvent = cached(function(name) {
|
var passive = name.charAt(0) === "&"
|
name = passive ? name.slice(1) : name
|
var once$$1 = name.charAt(0) === "~" // Prefixed last, checked first
|
name = once$$1 ? name.slice(1) : name
|
var capture = name.charAt(0) === "!"
|
name = capture ? name.slice(1) : name
|
return {
|
name: name,
|
once: once$$1,
|
capture: capture,
|
passive: passive
|
}
|
})
|
|
function createFnInvoker(fns) {
|
function invoker() {
|
var arguments$1 = arguments
|
|
var fns = invoker.fns
|
if (Array.isArray(fns)) {
|
var cloned = fns.slice()
|
for (var i = 0; i < cloned.length; i++) {
|
cloned[i].apply(null, arguments$1)
|
}
|
} else {
|
// return handler return value for single handlers
|
return fns.apply(null, arguments)
|
}
|
}
|
invoker.fns = fns
|
return invoker
|
}
|
|
function updateListeners(on, oldOn, add, remove$$1, vm) {
|
var name, cur, old, event
|
for (name in on) {
|
cur = on[name]
|
old = oldOn[name]
|
event = normalizeEvent(name)
|
if (isUndef(cur)) {
|
"production" !== "production" &&
|
warn('Invalid handler for event "' + event.name + '": got ' + String(cur), vm)
|
} else if (isUndef(old)) {
|
if (isUndef(cur.fns)) {
|
cur = on[name] = createFnInvoker(cur)
|
}
|
add(event.name, cur, event.once, event.capture, event.passive)
|
} else if (cur !== old) {
|
old.fns = cur
|
on[name] = old
|
}
|
}
|
for (name in oldOn) {
|
if (isUndef(on[name])) {
|
event = normalizeEvent(name)
|
remove$$1(event.name, oldOn[name], event.capture)
|
}
|
}
|
}
|
|
/* */
|
|
/* */
|
|
function extractPropsFromVNodeData(data, Ctor, tag) {
|
// we are only extracting raw values here.
|
// validation and default values are handled in the child
|
// component itself.
|
var propOptions = Ctor.options.props
|
if (isUndef(propOptions)) {
|
return
|
}
|
var res = {}
|
var attrs = data.attrs
|
var props = data.props
|
if (isDef(attrs) || isDef(props)) {
|
for (var key in propOptions) {
|
var altKey = hyphenate(key)
|
checkProp(res, props, key, altKey, true) ||
|
checkProp(res, attrs, key, altKey, false)
|
}
|
}
|
return res
|
}
|
|
function checkProp(res, hash, key, altKey, preserve) {
|
if (isDef(hash)) {
|
if (hasOwn(hash, key)) {
|
res[key] = hash[key]
|
if (!preserve) {
|
delete hash[key]
|
}
|
return true
|
} else if (hasOwn(hash, altKey)) {
|
res[key] = hash[altKey]
|
if (!preserve) {
|
delete hash[altKey]
|
}
|
return true
|
}
|
}
|
return false
|
}
|
|
/* */
|
|
// The template compiler attempts to minimize the need for normalization by
|
// statically analyzing the template at compile time.
|
//
|
// For plain HTML markup, normalization can be completely skipped because the
|
// generated render function is guaranteed to return Array<VNode>. There are
|
// two cases where extra normalization is needed:
|
|
// 1. When the children contains components - because a functional component
|
// may return an Array instead of a single root. In this case, just a simple
|
// normalization is needed - if any child is an Array, we flatten the whole
|
// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
|
// because functional components already normalize their own children.
|
function simpleNormalizeChildren(children) {
|
for (var i = 0; i < children.length; i++) {
|
if (Array.isArray(children[i])) {
|
return Array.prototype.concat.apply([], children)
|
}
|
}
|
return children
|
}
|
|
// 2. When the children contains constructs that always generated nested Arrays,
|
// e.g. <template>, <slot>, v-for, or when the children is provided by user
|
// with hand-written render functions / JSX. In such cases a full normalization
|
// is needed to cater to all possible types of children values.
|
function normalizeChildren(children) {
|
return isPrimitive(children)
|
? [createTextVNode(children)]
|
: Array.isArray(children)
|
? normalizeArrayChildren(children)
|
: undefined
|
}
|
|
function isTextNode(node) {
|
return isDef(node) && isDef(node.text) && isFalse(node.isComment)
|
}
|
|
function normalizeArrayChildren(children, nestedIndex) {
|
var res = []
|
var i, c, last
|
for (i = 0; i < children.length; i++) {
|
c = children[i]
|
if (isUndef(c) || typeof c === "boolean") {
|
continue
|
}
|
last = res[res.length - 1]
|
// nested
|
if (Array.isArray(c)) {
|
res.push.apply(res, normalizeArrayChildren(c, (nestedIndex || "") + "_" + i))
|
} else if (isPrimitive(c)) {
|
if (isTextNode(last)) {
|
// merge adjacent text nodes
|
// this is necessary for SSR hydration because text nodes are
|
// essentially merged when rendered to HTML strings
|
last.text += String(c)
|
} else if (c !== "") {
|
// convert primitive to vnode
|
res.push(createTextVNode(c))
|
}
|
} else {
|
if (isTextNode(c) && isTextNode(last)) {
|
// merge adjacent text nodes
|
res[res.length - 1] = createTextVNode(last.text + c.text)
|
} else {
|
// default key for nested array children (likely generated by v-for)
|
if (
|
isTrue(children._isVList) &&
|
isDef(c.tag) &&
|
isUndef(c.key) &&
|
isDef(nestedIndex)
|
) {
|
c.key = "__vlist" + nestedIndex + "_" + i + "__"
|
}
|
res.push(c)
|
}
|
}
|
}
|
return res
|
}
|
|
/* */
|
|
function ensureCtor(comp, base) {
|
if (comp.__esModule && comp.default) {
|
comp = comp.default
|
}
|
return isObject(comp) ? base.extend(comp) : comp
|
}
|
|
function createAsyncPlaceholder(factory, data, context, children, tag) {
|
var node = createEmptyVNode()
|
node.asyncFactory = factory
|
node.asyncMeta = {
|
data: data,
|
context: context,
|
children: children,
|
tag: tag
|
}
|
return node
|
}
|
|
function resolveAsyncComponent(factory, baseCtor, context) {
|
if (isTrue(factory.error) && isDef(factory.errorComp)) {
|
return factory.errorComp
|
}
|
|
if (isDef(factory.resolved)) {
|
return factory.resolved
|
}
|
|
if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
|
return factory.loadingComp
|
}
|
|
if (isDef(factory.contexts)) {
|
// already pending
|
factory.contexts.push(context)
|
} else {
|
var contexts = (factory.contexts = [context])
|
var sync = true
|
|
var forceRender = function() {
|
for (var i = 0, l = contexts.length; i < l; i++) {
|
contexts[i].$forceUpdate()
|
}
|
}
|
|
var resolve = once(function(res) {
|
// cache resolved
|
factory.resolved = ensureCtor(res, baseCtor)
|
// invoke callbacks only if this is not a synchronous resolve
|
// (async resolves are shimmed as synchronous during SSR)
|
if (!sync) {
|
forceRender()
|
}
|
})
|
|
var reject = once(function(reason) {
|
"production" !== "production" &&
|
warn(
|
"Failed to resolve async component: " +
|
String(factory) +
|
(reason ? "\nReason: " + reason : "")
|
)
|
if (isDef(factory.errorComp)) {
|
factory.error = true
|
forceRender()
|
}
|
})
|
|
var res = factory(resolve, reject)
|
|
if (isObject(res)) {
|
if (typeof res.then === "function") {
|
// () => Promise
|
if (isUndef(factory.resolved)) {
|
res.then(resolve, reject)
|
}
|
} else if (isDef(res.component) && typeof res.component.then === "function") {
|
res.component.then(resolve, reject)
|
|
if (isDef(res.error)) {
|
factory.errorComp = ensureCtor(res.error, baseCtor)
|
}
|
|
if (isDef(res.loading)) {
|
factory.loadingComp = ensureCtor(res.loading, baseCtor)
|
if (res.delay === 0) {
|
factory.loading = true
|
} else {
|
setTimeout(function() {
|
if (isUndef(factory.resolved) && isUndef(factory.error)) {
|
factory.loading = true
|
forceRender()
|
}
|
}, res.delay || 200)
|
}
|
}
|
|
if (isDef(res.timeout)) {
|
setTimeout(function() {
|
if (isUndef(factory.resolved)) {
|
reject(null)
|
}
|
}, res.timeout)
|
}
|
}
|
}
|
|
sync = false
|
// return in case resolved synchronously
|
return factory.loading ? factory.loadingComp : factory.resolved
|
}
|
}
|
|
/* */
|
|
function getFirstComponentChild(children) {
|
if (Array.isArray(children)) {
|
for (var i = 0; i < children.length; i++) {
|
var c = children[i]
|
if (isDef(c) && isDef(c.componentOptions)) {
|
return c
|
}
|
}
|
}
|
}
|
|
/* */
|
|
/* */
|
|
function initEvents(vm) {
|
vm._events = Object.create(null)
|
vm._hasHookEvent = false
|
// init parent attached events
|
var listeners = vm.$options._parentListeners
|
if (listeners) {
|
updateComponentListeners(vm, listeners)
|
}
|
}
|
|
var target
|
|
function add(event, fn, once$$1) {
|
if (once$$1) {
|
target.$once(event, fn)
|
} else {
|
target.$on(event, fn)
|
}
|
}
|
|
function remove$1(event, fn) {
|
target.$off(event, fn)
|
}
|
|
function updateComponentListeners(vm, listeners, oldListeners) {
|
target = vm
|
updateListeners(listeners, oldListeners || {}, add, remove$1, vm)
|
}
|
|
function eventsMixin(Vue) {
|
var hookRE = /^hook:/
|
Vue.prototype.$on = function(event, fn) {
|
var this$1 = this
|
|
var vm = this
|
if (Array.isArray(event)) {
|
for (var i = 0, l = event.length; i < l; i++) {
|
this$1.$on(event[i], fn)
|
}
|
} else {
|
;(vm._events[event] || (vm._events[event] = [])).push(fn)
|
// optimize hook:event cost by using a boolean flag marked at registration
|
// instead of a hash lookup
|
if (hookRE.test(event)) {
|
vm._hasHookEvent = true
|
}
|
}
|
return vm
|
}
|
|
Vue.prototype.$once = function(event, fn) {
|
var vm = this
|
|
function on() {
|
vm.$off(event, on)
|
fn.apply(vm, arguments)
|
}
|
on.fn = fn
|
vm.$on(event, on)
|
return vm
|
}
|
|
Vue.prototype.$off = function(event, fn) {
|
var this$1 = this
|
|
var vm = this
|
// all
|
if (!arguments.length) {
|
vm._events = Object.create(null)
|
return vm
|
}
|
// array of events
|
if (Array.isArray(event)) {
|
for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
|
this$1.$off(event[i$1], fn)
|
}
|
return vm
|
}
|
// specific event
|
var cbs = vm._events[event]
|
if (!cbs) {
|
return vm
|
}
|
if (arguments.length === 1) {
|
vm._events[event] = null
|
return vm
|
}
|
// specific handler
|
var cb
|
var i = cbs.length
|
while (i--) {
|
cb = cbs[i]
|
if (cb === fn || cb.fn === fn) {
|
cbs.splice(i, 1)
|
break
|
}
|
}
|
return vm
|
}
|
|
Vue.prototype.$emit = function(event) {
|
var vm = this
|
var cbs = vm._events[event]
|
if (cbs) {
|
cbs = cbs.length > 1 ? toArray(cbs) : cbs
|
var args = toArray(arguments, 1)
|
for (var i = 0, l = cbs.length; i < l; i++) {
|
try {
|
cbs[i].apply(vm, args)
|
} catch (e) {
|
handleError(e, vm, 'event handler for "' + event + '"')
|
}
|
}
|
}
|
return vm
|
}
|
}
|
|
/* */
|
|
/**
|
* Runtime helper for resolving raw children VNodes into a slot object.
|
*/
|
function resolveSlots(children, context) {
|
var slots = {}
|
if (!children) {
|
return slots
|
}
|
var defaultSlot = []
|
for (var i = 0, l = children.length; i < l; i++) {
|
var child = children[i]
|
// named slots should only be respected if the vnode was rendered in the
|
// same context.
|
if (
|
(child.context === context || child.functionalContext === context) &&
|
child.data &&
|
child.data.slot != null
|
) {
|
var name = child.data.slot
|
var slot = slots[name] || (slots[name] = [])
|
if (child.tag === "template") {
|
slot.push.apply(slot, child.children)
|
} else {
|
slot.push(child)
|
}
|
} else {
|
defaultSlot.push(child)
|
}
|
}
|
// ignore whitespace
|
if (!defaultSlot.every(isWhitespace)) {
|
slots.default = defaultSlot
|
}
|
return slots
|
}
|
|
function isWhitespace(node) {
|
return node.isComment || node.text === " "
|
}
|
|
function resolveScopedSlots(
|
fns, // see flow/vnode
|
res
|
) {
|
res = res || {}
|
for (var i = 0; i < fns.length; i++) {
|
if (Array.isArray(fns[i])) {
|
resolveScopedSlots(fns[i], res)
|
} else {
|
res[fns[i].key] = fns[i].fn
|
}
|
}
|
return res
|
}
|
|
/* */
|
|
var activeInstance = null
|
|
function initLifecycle(vm) {
|
var options = vm.$options
|
|
// locate first non-abstract parent
|
var parent = options.parent
|
if (parent && !options.abstract) {
|
while (parent.$options.abstract && parent.$parent) {
|
parent = parent.$parent
|
}
|
parent.$children.push(vm)
|
}
|
|
vm.$parent = parent
|
vm.$root = parent ? parent.$root : vm
|
|
vm.$children = []
|
vm.$refs = {}
|
|
vm._watcher = null
|
vm._inactive = null
|
vm._directInactive = false
|
vm._isMounted = false
|
vm._isDestroyed = false
|
vm._isBeingDestroyed = false
|
}
|
|
function lifecycleMixin(Vue) {
|
Vue.prototype._update = function(vnode, hydrating) {
|
var vm = this
|
if (vm._isMounted) {
|
callHook(vm, "beforeUpdate")
|
}
|
var prevEl = vm.$el
|
var prevVnode = vm._vnode
|
var prevActiveInstance = activeInstance
|
activeInstance = vm
|
vm._vnode = vnode
|
// Vue.prototype.__patch__ is injected in entry points
|
// based on the rendering backend used.
|
if (!prevVnode) {
|
// initial render
|
vm.$el = vm.__patch__(
|
vm.$el,
|
vnode,
|
hydrating,
|
false /* removeOnly */,
|
vm.$options._parentElm,
|
vm.$options._refElm
|
)
|
// no need for the ref nodes after initial patch
|
// this prevents keeping a detached DOM tree in memory (#5851)
|
vm.$options._parentElm = vm.$options._refElm = null
|
} else {
|
// updates
|
vm.$el = vm.__patch__(prevVnode, vnode)
|
}
|
activeInstance = prevActiveInstance
|
// update __vue__ reference
|
if (prevEl) {
|
prevEl.__vue__ = null
|
}
|
if (vm.$el) {
|
vm.$el.__vue__ = vm
|
}
|
// if parent is an HOC, update its $el as well
|
if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
|
vm.$parent.$el = vm.$el
|
}
|
// updated hook is called by the scheduler to ensure that children are
|
// updated in a parent's updated hook.
|
}
|
|
Vue.prototype.$forceUpdate = function() {
|
var vm = this
|
if (vm._watcher) {
|
vm._watcher.update()
|
}
|
}
|
|
Vue.prototype.$destroy = function() {
|
var vm = this
|
if (vm._isBeingDestroyed) {
|
return
|
}
|
callHook(vm, "beforeDestroy")
|
vm._isBeingDestroyed = true
|
// remove self from parent
|
var parent = vm.$parent
|
if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
|
remove(parent.$children, vm)
|
}
|
// teardown watchers
|
if (vm._watcher) {
|
vm._watcher.teardown()
|
}
|
var i = vm._watchers.length
|
while (i--) {
|
vm._watchers[i].teardown()
|
}
|
// remove reference from data ob
|
// frozen object may not have observer.
|
if (vm._data.__ob__) {
|
vm._data.__ob__.vmCount--
|
}
|
// call the last hook...
|
vm._isDestroyed = true
|
// invoke destroy hooks on current rendered tree
|
vm.__patch__(vm._vnode, null)
|
// fire destroyed hook
|
callHook(vm, "destroyed")
|
// turn off all instance listeners.
|
vm.$off()
|
// remove __vue__ reference
|
if (vm.$el) {
|
vm.$el.__vue__ = null
|
}
|
}
|
}
|
|
function mountComponent(vm, el, hydrating) {
|
vm.$el = el
|
if (!vm.$options.render) {
|
vm.$options.render = createEmptyVNode
|
}
|
callHook(vm, "beforeMount")
|
|
var updateComponent
|
/* istanbul ignore if */
|
if ("production" !== "production" && config.performance && mark) {
|
updateComponent = function() {
|
var name = vm._name
|
var id = vm._uid
|
var startTag = "vue-perf-start:" + id
|
var endTag = "vue-perf-end:" + id
|
|
mark(startTag)
|
var vnode = vm._render()
|
mark(endTag)
|
measure(name + " render", startTag, endTag)
|
|
mark(startTag)
|
vm._update(vnode, hydrating)
|
mark(endTag)
|
measure(name + " patch", startTag, endTag)
|
}
|
} else {
|
updateComponent = function() {
|
vm._update(vm._render(), hydrating)
|
}
|
}
|
|
vm._watcher = new Watcher(vm, updateComponent, noop)
|
hydrating = false
|
|
// manually mounted instance, call mounted on self
|
// mounted is called for render-created child components in its inserted hook
|
if (vm.$vnode == null) {
|
vm._isMounted = true
|
callHook(vm, "mounted")
|
}
|
return vm
|
}
|
|
function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
|
var hasChildren = !!(
|
renderChildren || // has new static slots
|
vm.$options._renderChildren || // has old static slots
|
parentVnode.data.scopedSlots || // has new scoped slots
|
vm.$scopedSlots !== emptyObject
|
) // has old scoped slots
|
|
vm.$options._parentVnode = parentVnode
|
vm.$vnode = parentVnode // update vm's placeholder node without re-render
|
|
if (vm._vnode) {
|
// update child tree's parent
|
vm._vnode.parent = parentVnode
|
}
|
vm.$options._renderChildren = renderChildren
|
|
// update $attrs and $listensers hash
|
// these are also reactive so they may trigger child update if the child
|
// used them during render
|
vm.$attrs = parentVnode.data && parentVnode.data.attrs
|
vm.$listeners = listeners
|
|
// update props
|
if (propsData && vm.$options.props) {
|
observerState.shouldConvert = false
|
var props = vm._props
|
var propKeys = vm.$options._propKeys || []
|
for (var i = 0; i < propKeys.length; i++) {
|
var key = propKeys[i]
|
props[key] = validateProp(key, vm.$options.props, propsData, vm)
|
}
|
observerState.shouldConvert = true
|
// keep a copy of raw propsData
|
vm.$options.propsData = propsData
|
}
|
|
// update listeners
|
if (listeners) {
|
var oldListeners = vm.$options._parentListeners
|
vm.$options._parentListeners = listeners
|
updateComponentListeners(vm, listeners, oldListeners)
|
}
|
// resolve slots + force update if has children
|
if (hasChildren) {
|
vm.$slots = resolveSlots(renderChildren, parentVnode.context)
|
vm.$forceUpdate()
|
}
|
}
|
|
function isInInactiveTree(vm) {
|
while (vm && (vm = vm.$parent)) {
|
if (vm._inactive) {
|
return true
|
}
|
}
|
return false
|
}
|
|
function activateChildComponent(vm, direct) {
|
if (direct) {
|
vm._directInactive = false
|
if (isInInactiveTree(vm)) {
|
return
|
}
|
} else if (vm._directInactive) {
|
return
|
}
|
if (vm._inactive || vm._inactive === null) {
|
vm._inactive = false
|
for (var i = 0; i < vm.$children.length; i++) {
|
activateChildComponent(vm.$children[i])
|
}
|
callHook(vm, "activated")
|
}
|
}
|
|
function deactivateChildComponent(vm, direct) {
|
if (direct) {
|
vm._directInactive = true
|
if (isInInactiveTree(vm)) {
|
return
|
}
|
}
|
if (!vm._inactive) {
|
vm._inactive = true
|
for (var i = 0; i < vm.$children.length; i++) {
|
deactivateChildComponent(vm.$children[i])
|
}
|
callHook(vm, "deactivated")
|
}
|
}
|
|
function callHook(vm, hook) {
|
var handlers = vm.$options[hook]
|
if (handlers) {
|
for (var i = 0, j = handlers.length; i < j; i++) {
|
try {
|
handlers[i].call(vm)
|
} catch (e) {
|
handleError(e, vm, hook + " hook")
|
}
|
}
|
}
|
if (vm._hasHookEvent) {
|
vm.$emit("hook:" + hook)
|
}
|
}
|
|
/* */
|
|
var MAX_UPDATE_COUNT = 100
|
|
var queue = []
|
var activatedChildren = []
|
var has = {}
|
var circular = {}
|
var waiting = false
|
var flushing = false
|
var index = 0
|
|
/**
|
* Reset the scheduler's state.
|
*/
|
function resetSchedulerState() {
|
index = queue.length = activatedChildren.length = 0
|
has = {}
|
waiting = flushing = false
|
}
|
|
/**
|
* Flush both queues and run the watchers.
|
*/
|
function flushSchedulerQueue() {
|
flushing = true
|
var watcher, id
|
|
// Sort queue before flush.
|
// This ensures that:
|
// 1. Components are updated from parent to child. (because parent is always
|
// created before the child)
|
// 2. A component's user watchers are run before its render watcher (because
|
// user watchers are created before the render watcher)
|
// 3. If a component is destroyed during a parent component's watcher run,
|
// its watchers can be skipped.
|
queue.sort(function(a, b) {
|
return a.id - b.id
|
})
|
|
// do not cache length because more watchers might be pushed
|
// as we run existing watchers
|
for (index = 0; index < queue.length; index++) {
|
watcher = queue[index]
|
id = watcher.id
|
has[id] = null
|
watcher.run()
|
// in dev build, check and stop circular updates.
|
if ("production" !== "production" && has[id] != null) {
|
circular[id] = (circular[id] || 0) + 1
|
if (circular[id] > MAX_UPDATE_COUNT) {
|
warn(
|
"You may have an infinite update loop " +
|
(watcher.user
|
? 'in watcher with expression "' + watcher.expression + '"'
|
: "in a component render function."),
|
watcher.vm
|
)
|
break
|
}
|
}
|
}
|
|
// keep copies of post queues before resetting state
|
var activatedQueue = activatedChildren.slice()
|
var updatedQueue = queue.slice()
|
|
resetSchedulerState()
|
|
// call component updated and activated hooks
|
callActivatedHooks(activatedQueue)
|
callUpdatedHooks(updatedQueue)
|
|
// devtool hook
|
/* istanbul ignore if */
|
if (devtools && config.devtools) {
|
devtools.emit("flush")
|
}
|
}
|
|
function callUpdatedHooks(queue) {
|
var i = queue.length
|
while (i--) {
|
var watcher = queue[i]
|
var vm = watcher.vm
|
if (vm._watcher === watcher && vm._isMounted) {
|
callHook(vm, "updated")
|
}
|
}
|
}
|
|
/**
|
* Queue a kept-alive component that was activated during patch.
|
* The queue will be processed after the entire tree has been patched.
|
*/
|
function queueActivatedComponent(vm) {
|
// setting _inactive to false here so that a render function can
|
// rely on checking whether it's in an inactive tree (e.g. router-view)
|
vm._inactive = false
|
activatedChildren.push(vm)
|
}
|
|
function callActivatedHooks(queue) {
|
for (var i = 0; i < queue.length; i++) {
|
queue[i]._inactive = true
|
activateChildComponent(queue[i], true /* true */)
|
}
|
}
|
|
/**
|
* Push a watcher into the watcher queue.
|
* Jobs with duplicate IDs will be skipped unless it's
|
* pushed when the queue is being flushed.
|
*/
|
function queueWatcher(watcher) {
|
var id = watcher.id
|
if (has[id] == null) {
|
has[id] = true
|
if (!flushing) {
|
queue.push(watcher)
|
} else {
|
// if already flushing, splice the watcher based on its id
|
// if already past its id, it will be run next immediately.
|
var i = queue.length - 1
|
while (i > index && queue[i].id > watcher.id) {
|
i--
|
}
|
queue.splice(i + 1, 0, watcher)
|
}
|
// queue the flush
|
if (!waiting) {
|
waiting = true
|
nextTick(flushSchedulerQueue)
|
}
|
}
|
}
|
|
/* */
|
|
var uid$2 = 0
|
|
/**
|
* A watcher parses an expression, collects dependencies,
|
* and fires callback when the expression value changes.
|
* This is used for both the $watch() api and directives.
|
*/
|
var Watcher = function Watcher(vm, expOrFn, cb, options) {
|
this.vm = vm
|
vm._watchers.push(this)
|
// options
|
if (options) {
|
this.deep = !!options.deep
|
this.user = !!options.user
|
this.lazy = !!options.lazy
|
this.sync = !!options.sync
|
} else {
|
this.deep = this.user = this.lazy = this.sync = false
|
}
|
this.cb = cb
|
this.id = ++uid$2 // uid for batching
|
this.active = true
|
this.dirty = this.lazy // for lazy watchers
|
this.deps = []
|
this.newDeps = []
|
this.depIds = new _Set()
|
this.newDepIds = new _Set()
|
this.expression = ""
|
// parse expression for getter
|
if (typeof expOrFn === "function") {
|
this.getter = expOrFn
|
} else {
|
this.getter = parsePath(expOrFn)
|
if (!this.getter) {
|
this.getter = function() {}
|
"production" !== "production" &&
|
warn(
|
'Failed watching path: "' +
|
expOrFn +
|
'" ' +
|
"Watcher only accepts simple dot-delimited paths. " +
|
"For full control, use a function instead.",
|
vm
|
)
|
}
|
}
|
this.value = this.lazy ? undefined : this.get()
|
}
|
|
/**
|
* Evaluate the getter, and re-collect dependencies.
|
*/
|
Watcher.prototype.get = function get() {
|
pushTarget(this)
|
var value
|
var vm = this.vm
|
try {
|
value = this.getter.call(vm, vm)
|
} catch (e) {
|
if (this.user) {
|
handleError(e, vm, 'getter for watcher "' + this.expression + '"')
|
} else {
|
throw e
|
}
|
} finally {
|
// "touch" every property so they are all tracked as
|
// dependencies for deep watching
|
if (this.deep) {
|
traverse(value)
|
}
|
popTarget()
|
this.cleanupDeps()
|
}
|
return value
|
}
|
|
/**
|
* Add a dependency to this directive.
|
*/
|
Watcher.prototype.addDep = function addDep(dep) {
|
var id = dep.id
|
if (!this.newDepIds.has(id)) {
|
this.newDepIds.add(id)
|
this.newDeps.push(dep)
|
if (!this.depIds.has(id)) {
|
dep.addSub(this)
|
}
|
}
|
}
|
|
/**
|
* Clean up for dependency collection.
|
*/
|
Watcher.prototype.cleanupDeps = function cleanupDeps() {
|
var this$1 = this
|
|
var i = this.deps.length
|
while (i--) {
|
var dep = this$1.deps[i]
|
if (!this$1.newDepIds.has(dep.id)) {
|
dep.removeSub(this$1)
|
}
|
}
|
var tmp = this.depIds
|
this.depIds = this.newDepIds
|
this.newDepIds = tmp
|
this.newDepIds.clear()
|
tmp = this.deps
|
this.deps = this.newDeps
|
this.newDeps = tmp
|
this.newDeps.length = 0
|
}
|
|
/**
|
* Subscriber interface.
|
* Will be called when a dependency changes.
|
*/
|
Watcher.prototype.update = function update() {
|
/* istanbul ignore else */
|
if (this.lazy) {
|
this.dirty = true
|
} else if (this.sync) {
|
this.run()
|
} else {
|
queueWatcher(this)
|
}
|
}
|
|
/**
|
* Scheduler job interface.
|
* Will be called by the scheduler.
|
*/
|
Watcher.prototype.run = function run() {
|
if (this.active) {
|
var value = this.get()
|
if (
|
value !== this.value ||
|
// Deep watchers and watchers on Object/Arrays should fire even
|
// when the value is the same, because the value may
|
// have mutated.
|
isObject(value) ||
|
this.deep
|
) {
|
// set new value
|
var oldValue = this.value
|
this.value = value
|
if (this.user) {
|
try {
|
this.cb.call(this.vm, value, oldValue)
|
} catch (e) {
|
handleError(e, this.vm, 'callback for watcher "' + this.expression + '"')
|
}
|
} else {
|
this.cb.call(this.vm, value, oldValue)
|
}
|
}
|
}
|
}
|
|
/**
|
* Evaluate the value of the watcher.
|
* This only gets called for lazy watchers.
|
*/
|
Watcher.prototype.evaluate = function evaluate() {
|
this.value = this.get()
|
this.dirty = false
|
}
|
|
/**
|
* Depend on all deps collected by this watcher.
|
*/
|
Watcher.prototype.depend = function depend() {
|
var this$1 = this
|
|
var i = this.deps.length
|
while (i--) {
|
this$1.deps[i].depend()
|
}
|
}
|
|
/**
|
* Remove self from all dependencies' subscriber list.
|
*/
|
Watcher.prototype.teardown = function teardown() {
|
var this$1 = this
|
|
if (this.active) {
|
// remove self from vm's watcher list
|
// this is a somewhat expensive operation so we skip it
|
// if the vm is being destroyed.
|
if (!this.vm._isBeingDestroyed) {
|
remove(this.vm._watchers, this)
|
}
|
var i = this.deps.length
|
while (i--) {
|
this$1.deps[i].removeSub(this$1)
|
}
|
this.active = false
|
}
|
}
|
|
/**
|
* Recursively traverse an object to evoke all converted
|
* getters, so that every nested property inside the object
|
* is collected as a "deep" dependency.
|
*/
|
var seenObjects = new _Set()
|
|
function traverse(val) {
|
seenObjects.clear()
|
_traverse(val, seenObjects)
|
}
|
|
function _traverse(val, seen) {
|
var i, keys
|
var isA = Array.isArray(val)
|
if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {
|
return
|
}
|
if (val.__ob__) {
|
var depId = val.__ob__.dep.id
|
if (seen.has(depId)) {
|
return
|
}
|
seen.add(depId)
|
}
|
if (isA) {
|
i = val.length
|
while (i--) {
|
_traverse(val[i], seen)
|
}
|
} else {
|
keys = Object.keys(val)
|
i = keys.length
|
while (i--) {
|
_traverse(val[keys[i]], seen)
|
}
|
}
|
}
|
|
/* */
|
|
var sharedPropertyDefinition = {
|
enumerable: true,
|
configurable: true,
|
get: noop,
|
set: noop
|
}
|
|
function proxy(target, sourceKey, key) {
|
sharedPropertyDefinition.get = function proxyGetter() {
|
return this[sourceKey][key]
|
}
|
sharedPropertyDefinition.set = function proxySetter(val) {
|
this[sourceKey][key] = val
|
}
|
Object.defineProperty(target, key, sharedPropertyDefinition)
|
}
|
|
function initState(vm) {
|
vm._watchers = []
|
var opts = vm.$options
|
if (opts.props) {
|
initProps(vm, opts.props)
|
}
|
if (opts.methods) {
|
initMethods(vm, opts.methods)
|
}
|
if (opts.data) {
|
initData(vm)
|
} else {
|
observe((vm._data = {}), true /* asRootData */)
|
}
|
if (opts.computed) {
|
initComputed(vm, opts.computed)
|
}
|
if (opts.watch && opts.watch !== nativeWatch) {
|
initWatch(vm, opts.watch)
|
}
|
}
|
|
function checkOptionType(vm, name) {
|
var option = vm.$options[name]
|
if (!isPlainObject(option)) {
|
warn('component option "' + name + '" should be an object.', vm)
|
}
|
}
|
|
function initProps(vm, propsOptions) {
|
var propsData = vm.$options.propsData || {}
|
var props = (vm._props = {})
|
// cache prop keys so that future props updates can iterate using Array
|
// instead of dynamic object key enumeration.
|
var keys = (vm.$options._propKeys = [])
|
var isRoot = !vm.$parent
|
// root instance props should be converted
|
observerState.shouldConvert = isRoot
|
var loop = function(key) {
|
keys.push(key)
|
var value = validateProp(key, propsOptions, propsData, vm)
|
/* istanbul ignore else */
|
{
|
defineReactive$$1(props, key, value)
|
}
|
// static props are already proxied on the component's prototype
|
// during Vue.extend(). We only need to proxy props defined at
|
// instantiation here.
|
if (!(key in vm)) {
|
proxy(vm, "_props", key)
|
}
|
}
|
|
for (var key in propsOptions) loop(key)
|
observerState.shouldConvert = true
|
}
|
|
function initData(vm) {
|
var data = vm.$options.data
|
data = vm._data = typeof data === "function" ? getData(data, vm) : data || {}
|
if (!isPlainObject(data)) {
|
data = {}
|
"production" !== "production" &&
|
warn(
|
"data functions should return an object:\n" +
|
"https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function",
|
vm
|
)
|
}
|
// proxy data on instance
|
var keys = Object.keys(data)
|
var props = vm.$options.props
|
var methods = vm.$options.methods
|
var i = keys.length
|
while (i--) {
|
var key = keys[i]
|
if (props && hasOwn(props, key)) {
|
"production" !== "production" &&
|
warn(
|
'The data property "' +
|
key +
|
'" is already declared as a prop. ' +
|
"Use prop default value instead.",
|
vm
|
)
|
} else if (!isReserved(key)) {
|
proxy(vm, "_data", key)
|
}
|
}
|
// observe data
|
observe(data, true /* asRootData */)
|
}
|
|
function getData(data, vm) {
|
try {
|
return data.call(vm)
|
} catch (e) {
|
handleError(e, vm, "data()")
|
return {}
|
}
|
}
|
|
var computedWatcherOptions = {
|
lazy: true
|
}
|
|
function initComputed(vm, computed) {
|
"production" !== "production" && checkOptionType(vm, "computed")
|
var watchers = (vm._computedWatchers = Object.create(null))
|
|
for (var key in computed) {
|
var userDef = computed[key]
|
var getter = typeof userDef === "function" ? userDef : userDef.get
|
watchers[key] = new Watcher(vm, getter, noop, computedWatcherOptions)
|
|
// component-defined computed properties are already defined on the
|
// component prototype. We only need to define computed properties defined
|
// at instantiation here.
|
if (!(key in vm)) {
|
defineComputed(vm, key, userDef)
|
} else {
|
}
|
}
|
}
|
|
function defineComputed(target, key, userDef) {
|
if (typeof userDef === "function") {
|
sharedPropertyDefinition.get = createComputedGetter(key)
|
sharedPropertyDefinition.set = noop
|
} else {
|
sharedPropertyDefinition.get = userDef.get
|
? userDef.cache !== false
|
? createComputedGetter(key)
|
: userDef.get
|
: noop
|
sharedPropertyDefinition.set = userDef.set ? userDef.set : noop
|
}
|
Object.defineProperty(target, key, sharedPropertyDefinition)
|
}
|
|
function createComputedGetter(key) {
|
return function computedGetter() {
|
var watcher = this._computedWatchers && this._computedWatchers[key]
|
if (watcher) {
|
if (watcher.dirty) {
|
watcher.evaluate()
|
}
|
if (Dep.target) {
|
watcher.depend()
|
}
|
return watcher.value
|
}
|
}
|
}
|
|
function initMethods(vm, methods) {
|
"production" !== "production" && checkOptionType(vm, "methods")
|
var props = vm.$options.props
|
for (var key in methods) {
|
vm[key] = methods[key] == null ? noop : bind(methods[key], vm)
|
}
|
}
|
|
function initWatch(vm, watch) {
|
"production" !== "production" && checkOptionType(vm, "watch")
|
for (var key in watch) {
|
var handler = watch[key]
|
if (Array.isArray(handler)) {
|
for (var i = 0; i < handler.length; i++) {
|
createWatcher(vm, key, handler[i])
|
}
|
} else {
|
createWatcher(vm, key, handler)
|
}
|
}
|
}
|
|
function createWatcher(vm, keyOrFn, handler, options) {
|
if (isPlainObject(handler)) {
|
options = handler
|
handler = handler.handler
|
}
|
if (typeof handler === "string") {
|
handler = vm[handler]
|
}
|
return vm.$watch(keyOrFn, handler, options)
|
}
|
|
function stateMixin(Vue) {
|
// flow somehow has problems with directly declared definition object
|
// when using Object.defineProperty, so we have to procedurally build up
|
// the object here.
|
var dataDef = {}
|
dataDef.get = function() {
|
return this._data
|
}
|
var propsDef = {}
|
propsDef.get = function() {
|
return this._props
|
}
|
Object.defineProperty(Vue.prototype, "$data", dataDef)
|
Object.defineProperty(Vue.prototype, "$props", propsDef)
|
|
Vue.prototype.$set = set
|
Vue.prototype.$delete = del
|
|
Vue.prototype.$watch = function(expOrFn, cb, options) {
|
var vm = this
|
if (isPlainObject(cb)) {
|
return createWatcher(vm, expOrFn, cb, options)
|
}
|
options = options || {}
|
options.user = true
|
var watcher = new Watcher(vm, expOrFn, cb, options)
|
if (options.immediate) {
|
cb.call(vm, watcher.value)
|
}
|
return function unwatchFn() {
|
watcher.teardown()
|
}
|
}
|
}
|
|
/* */
|
|
function initProvide(vm) {
|
var provide = vm.$options.provide
|
if (provide) {
|
vm._provided = typeof provide === "function" ? provide.call(vm) : provide
|
}
|
}
|
|
function initInjections(vm) {
|
var result = resolveInject(vm.$options.inject, vm)
|
if (result) {
|
observerState.shouldConvert = false
|
Object.keys(result).forEach(function(key) {
|
/* istanbul ignore else */
|
{
|
defineReactive$$1(vm, key, result[key])
|
}
|
})
|
observerState.shouldConvert = true
|
}
|
}
|
|
function resolveInject(inject, vm) {
|
if (inject) {
|
// inject is :any because flow is not smart enough to figure out cached
|
var result = Object.create(null)
|
var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject)
|
|
for (var i = 0; i < keys.length; i++) {
|
var key = keys[i]
|
var provideKey = inject[key]
|
var source = vm
|
while (source) {
|
if (source._provided && provideKey in source._provided) {
|
result[key] = source._provided[provideKey]
|
break
|
}
|
source = source.$parent
|
}
|
if ("production" !== "production" && !hasOwn(result, key)) {
|
warn('Injection "' + key + '" not found', vm)
|
}
|
}
|
return result
|
}
|
}
|
|
/* */
|
|
function createFunctionalComponent(Ctor, propsData, data, context, children) {
|
var props = {}
|
var propOptions = Ctor.options.props
|
if (isDef(propOptions)) {
|
for (var key in propOptions) {
|
props[key] = validateProp(key, propOptions, propsData || {})
|
}
|
} else {
|
if (isDef(data.attrs)) {
|
mergeProps(props, data.attrs)
|
}
|
if (isDef(data.props)) {
|
mergeProps(props, data.props)
|
}
|
}
|
// ensure the createElement function in functional components
|
// gets a unique context - this is necessary for correct named slot check
|
var _context = Object.create(context)
|
var h = function(a, b, c, d) {
|
return createElement(_context, a, b, c, d, true)
|
}
|
var vnode = Ctor.options.render.call(null, h, {
|
data: data,
|
props: props,
|
children: children,
|
parent: context,
|
listeners: data.on || {},
|
injections: resolveInject(Ctor.options.inject, context),
|
slots: function() {
|
return resolveSlots(children, context)
|
}
|
})
|
if (vnode instanceof VNode) {
|
vnode.functionalContext = context
|
vnode.functionalOptions = Ctor.options
|
if (data.slot) {
|
;(vnode.data || (vnode.data = {})).slot = data.slot
|
}
|
}
|
return vnode
|
}
|
|
function mergeProps(to, from) {
|
for (var key in from) {
|
to[camelize(key)] = from[key]
|
}
|
}
|
|
/* */
|
|
// hooks to be invoked on component VNodes during patch
|
var componentVNodeHooks = {
|
init: function init(vnode, hydrating, parentElm, refElm) {
|
if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {
|
var child = (vnode.componentInstance = createComponentInstanceForVnode(
|
vnode,
|
activeInstance,
|
parentElm,
|
refElm
|
))
|
child.$mount(hydrating ? vnode.elm : undefined, hydrating)
|
} else if (vnode.data.keepAlive) {
|
// kept-alive components, treat as a patch
|
var mountedNode = vnode // work around flow
|
componentVNodeHooks.prepatch(mountedNode, mountedNode)
|
}
|
},
|
|
prepatch: function prepatch(oldVnode, vnode) {
|
var options = vnode.componentOptions
|
var child = (vnode.componentInstance = oldVnode.componentInstance)
|
updateChildComponent(
|
child,
|
options.propsData, // updated props
|
options.listeners, // updated listeners
|
vnode, // new parent vnode
|
options.children // new children
|
)
|
},
|
|
insert: function insert(vnode) {
|
var context = vnode.context
|
var componentInstance = vnode.componentInstance
|
|
if (!componentInstance._isMounted) {
|
componentInstance._isMounted = true
|
callHook(componentInstance, "mounted")
|
}
|
if (vnode.data.keepAlive) {
|
if (context._isMounted) {
|
// vue-router#1212
|
// During updates, a kept-alive component's child components may
|
// change, so directly walking the tree here may call activated hooks
|
// on incorrect children. Instead we push them into a queue which will
|
// be processed after the whole patch process ended.
|
queueActivatedComponent(componentInstance)
|
} else {
|
activateChildComponent(componentInstance, true /* direct */)
|
}
|
}
|
},
|
|
destroy: function destroy(vnode) {
|
var componentInstance = vnode.componentInstance
|
if (!componentInstance._isDestroyed) {
|
if (!vnode.data.keepAlive) {
|
componentInstance.$destroy()
|
} else {
|
deactivateChildComponent(componentInstance, true /* direct */)
|
}
|
}
|
}
|
}
|
|
var hooksToMerge = Object.keys(componentVNodeHooks)
|
|
function createComponent(Ctor, data, context, children, tag) {
|
if (isUndef(Ctor)) {
|
return
|
}
|
|
var baseCtor = context.$options._base
|
|
// plain options object: turn it into a constructor
|
if (isObject(Ctor)) {
|
Ctor = baseCtor.extend(Ctor)
|
}
|
|
// if at this stage it's not a constructor or an async component factory,
|
// reject.
|
if (typeof Ctor !== "function") {
|
return
|
}
|
|
// async component
|
var asyncFactory
|
if (isUndef(Ctor.cid)) {
|
asyncFactory = Ctor
|
Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context)
|
if (Ctor === undefined) {
|
// return a placeholder node for async component, which is rendered
|
// as a comment node but preserves all the raw information for the node.
|
// the information will be used for async server-rendering and hydration.
|
return createAsyncPlaceholder(asyncFactory, data, context, children, tag)
|
}
|
}
|
|
data = data || {}
|
|
// resolve constructor options in case global mixins are applied after
|
// component constructor creation
|
resolveConstructorOptions(Ctor)
|
|
// transform component v-model data into props & events
|
if (isDef(data.model)) {
|
transformModel(Ctor.options, data)
|
}
|
|
// extract props
|
var propsData = extractPropsFromVNodeData(data, Ctor, tag)
|
|
// functional component
|
if (isTrue(Ctor.options.functional)) {
|
return createFunctionalComponent(Ctor, propsData, data, context, children)
|
}
|
|
// keep listeners
|
var listeners = data.on
|
|
if (isTrue(Ctor.options.abstract)) {
|
// abstract components do not keep anything
|
// other than props & listeners & slot
|
|
// work around flow
|
var slot = data.slot
|
data = {}
|
if (slot) {
|
data.slot = slot
|
}
|
}
|
|
// merge component management hooks onto the placeholder node
|
mergeHooks(data)
|
|
// return a placeholder vnode
|
var name = Ctor.options.name || tag
|
var vnode = new VNode(
|
"vue-component-" + Ctor.cid + (name ? "-" + name : ""),
|
data,
|
undefined,
|
undefined,
|
undefined,
|
context,
|
{
|
Ctor: Ctor,
|
propsData: propsData,
|
listeners: listeners,
|
tag: tag,
|
children: children
|
},
|
asyncFactory
|
)
|
return vnode
|
}
|
|
function createComponentInstanceForVnode(
|
vnode, // we know it's MountedComponentVNode but flow doesn't
|
parent, // activeInstance in lifecycle state
|
parentElm,
|
refElm
|
) {
|
var vnodeComponentOptions = vnode.componentOptions
|
var options = {
|
_isComponent: true,
|
parent: parent,
|
propsData: vnodeComponentOptions.propsData,
|
_componentTag: vnodeComponentOptions.tag,
|
_parentVnode: vnode,
|
_parentListeners: vnodeComponentOptions.listeners,
|
_renderChildren: vnodeComponentOptions.children,
|
_parentElm: parentElm || null,
|
_refElm: refElm || null
|
}
|
// check inline-template render functions
|
var inlineTemplate = vnode.data.inlineTemplate
|
if (isDef(inlineTemplate)) {
|
options.render = inlineTemplate.render
|
options.staticRenderFns = inlineTemplate.staticRenderFns
|
}
|
return new vnodeComponentOptions.Ctor(options)
|
}
|
|
function mergeHooks(data) {
|
if (!data.hook) {
|
data.hook = {}
|
}
|
for (var i = 0; i < hooksToMerge.length; i++) {
|
var key = hooksToMerge[i]
|
var fromParent = data.hook[key]
|
var ours = componentVNodeHooks[key]
|
data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours
|
}
|
}
|
|
function mergeHook$1(one, two) {
|
return function(a, b, c, d) {
|
one(a, b, c, d)
|
two(a, b, c, d)
|
}
|
}
|
|
// transform component v-model info (value and callback) into
|
// prop and event handler respectively.
|
function transformModel(options, data) {
|
var prop = (options.model && options.model.prop) || "value"
|
var event = (options.model && options.model.event) || "input"
|
;(data.props || (data.props = {}))[prop] = data.model.value
|
var on = data.on || (data.on = {})
|
if (isDef(on[event])) {
|
on[event] = [data.model.callback].concat(on[event])
|
} else {
|
on[event] = data.model.callback
|
}
|
}
|
|
/* */
|
|
var SIMPLE_NORMALIZE = 1
|
var ALWAYS_NORMALIZE = 2
|
|
// wrapper function for providing a more flexible interface
|
// without getting yelled at by flow
|
function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
|
if (Array.isArray(data) || isPrimitive(data)) {
|
normalizationType = children
|
children = data
|
data = undefined
|
}
|
if (isTrue(alwaysNormalize)) {
|
normalizationType = ALWAYS_NORMALIZE
|
}
|
return _createElement(context, tag, data, children, normalizationType)
|
}
|
|
function _createElement(context, tag, data, children, normalizationType) {
|
if (isDef(data) && isDef(data.__ob__)) {
|
"production" !== "production" &&
|
warn(
|
"Avoid using observed data object as vnode data: " +
|
JSON.stringify(data) +
|
"\n" +
|
"Always create fresh vnode data objects in each render!",
|
context
|
)
|
return createEmptyVNode()
|
}
|
// object syntax in v-bind
|
if (isDef(data) && isDef(data.is)) {
|
tag = data.is
|
}
|
if (!tag) {
|
// in case of component :is set to falsy value
|
return createEmptyVNode()
|
}
|
// warn against non-primitive key
|
if (
|
"production" !== "production" &&
|
isDef(data) &&
|
isDef(data.key) &&
|
!isPrimitive(data.key)
|
) {
|
warn(
|
"Avoid using non-primitive value as key, " + "use string/number value instead.",
|
context
|
)
|
}
|
// support single function children as default scoped slot
|
if (Array.isArray(children) && typeof children[0] === "function") {
|
data = data || {}
|
data.scopedSlots = {
|
default: children[0]
|
}
|
children.length = 0
|
}
|
if (normalizationType === ALWAYS_NORMALIZE) {
|
children = normalizeChildren(children)
|
} else if (normalizationType === SIMPLE_NORMALIZE) {
|
children = simpleNormalizeChildren(children)
|
}
|
var vnode, ns
|
if (typeof tag === "string") {
|
var Ctor
|
ns = config.getTagNamespace(tag)
|
if (config.isReservedTag(tag)) {
|
// platform built-in elements
|
vnode = new VNode(
|
config.parsePlatformTagName(tag),
|
data,
|
children,
|
undefined,
|
undefined,
|
context
|
)
|
} else if (isDef((Ctor = resolveAsset(context.$options, "components", tag)))) {
|
// component
|
vnode = createComponent(Ctor, data, context, children, tag)
|
} else {
|
// unknown or unlisted namespaced elements
|
// check at runtime because it may get assigned a namespace when its
|
// parent normalizes children
|
vnode = new VNode(tag, data, children, undefined, undefined, context)
|
}
|
} else {
|
// direct component options / constructor
|
vnode = createComponent(tag, data, context, children)
|
}
|
if (isDef(vnode)) {
|
if (ns) {
|
applyNS(vnode, ns)
|
}
|
return vnode
|
} else {
|
return createEmptyVNode()
|
}
|
}
|
|
function applyNS(vnode, ns) {
|
vnode.ns = ns
|
if (vnode.tag === "foreignObject") {
|
// use default namespace inside foreignObject
|
return
|
}
|
if (isDef(vnode.children)) {
|
for (var i = 0, l = vnode.children.length; i < l; i++) {
|
var child = vnode.children[i]
|
if (isDef(child.tag) && isUndef(child.ns)) {
|
applyNS(child, ns)
|
}
|
}
|
}
|
}
|
|
/* */
|
|
/**
|
* Runtime helper for rendering v-for lists.
|
*/
|
function renderList(val, render) {
|
var ret, i, l, keys, key
|
if (Array.isArray(val) || typeof val === "string") {
|
ret = new Array(val.length)
|
for (i = 0, l = val.length; i < l; i++) {
|
ret[i] = render(val[i], i)
|
}
|
} else if (typeof val === "number") {
|
ret = new Array(val)
|
for (i = 0; i < val; i++) {
|
ret[i] = render(i + 1, i)
|
}
|
} else if (isObject(val)) {
|
keys = Object.keys(val)
|
ret = new Array(keys.length)
|
for (i = 0, l = keys.length; i < l; i++) {
|
key = keys[i]
|
ret[i] = render(val[key], key, i)
|
}
|
}
|
if (isDef(ret)) {
|
ret._isVList = true
|
}
|
return ret
|
}
|
|
/* */
|
|
/**
|
* Runtime helper for rendering <slot>
|
*/
|
function renderSlot(name, fallback, props, bindObject) {
|
var scopedSlotFn = this.$scopedSlots[name]
|
if (scopedSlotFn) {
|
// scoped slot
|
props = props || {}
|
if (bindObject) {
|
props = extend(extend({}, bindObject), props)
|
}
|
return scopedSlotFn(props) || fallback
|
} else {
|
var slotNodes = this.$slots[name]
|
// warn duplicate slot usage
|
if (slotNodes && "production" !== "production") {
|
slotNodes._rendered &&
|
warn(
|
'Duplicate presence of slot "' +
|
name +
|
'" found in the same render tree ' +
|
"- this will likely cause render errors.",
|
this
|
)
|
slotNodes._rendered = true
|
}
|
return slotNodes || fallback
|
}
|
}
|
|
/* */
|
|
/**
|
* Runtime helper for resolving filters
|
*/
|
function resolveFilter(id) {
|
return resolveAsset(this.$options, "filters", id, true) || identity
|
}
|
|
/* */
|
|
/**
|
* Runtime helper for checking keyCodes from config.
|
*/
|
function checkKeyCodes(eventKeyCode, key, builtInAlias) {
|
var keyCodes = config.keyCodes[key] || builtInAlias
|
if (Array.isArray(keyCodes)) {
|
return keyCodes.indexOf(eventKeyCode) === -1
|
} else {
|
return keyCodes !== eventKeyCode
|
}
|
}
|
|
/* */
|
|
/**
|
* Runtime helper for merging v-bind="object" into a VNode's data.
|
*/
|
function bindObjectProps(data, tag, value, asProp, isSync) {
|
if (value) {
|
if (!isObject(value)) {
|
"production" !== "production" &&
|
warn("v-bind without argument expects an Object or Array value", this)
|
} else {
|
if (Array.isArray(value)) {
|
value = toObject(value)
|
}
|
var hash
|
var loop = function(key) {
|
if (key === "class" || key === "style" || isReservedAttribute(key)) {
|
hash = data
|
} else {
|
var type = data.attrs && data.attrs.type
|
hash =
|
asProp || config.mustUseProp(tag, type, key)
|
? data.domProps || (data.domProps = {})
|
: data.attrs || (data.attrs = {})
|
}
|
if (!(key in hash)) {
|
hash[key] = value[key]
|
|
if (isSync) {
|
var on = data.on || (data.on = {})
|
on["update:" + key] = function($event) {
|
value[key] = $event
|
}
|
}
|
}
|
}
|
|
for (var key in value) loop(key)
|
}
|
}
|
return data
|
}
|
|
/* */
|
|
/**
|
* Runtime helper for rendering static trees.
|
*/
|
function renderStatic(index, isInFor) {
|
var tree = this._staticTrees[index]
|
// if has already-rendered static tree and not inside v-for,
|
// we can reuse the same tree by doing a shallow clone.
|
if (tree && !isInFor) {
|
return Array.isArray(tree) ? cloneVNodes(tree) : cloneVNode(tree)
|
}
|
// otherwise, render a fresh tree.
|
tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(
|
this._renderProxy
|
)
|
markStatic(tree, "__static__" + index, false)
|
return tree
|
}
|
|
/**
|
* Runtime helper for v-once.
|
* Effectively it means marking the node as static with a unique key.
|
*/
|
function markOnce(tree, index, key) {
|
markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true)
|
return tree
|
}
|
|
function markStatic(tree, key, isOnce) {
|
if (Array.isArray(tree)) {
|
for (var i = 0; i < tree.length; i++) {
|
if (tree[i] && typeof tree[i] !== "string") {
|
markStaticNode(tree[i], key + "_" + i, isOnce)
|
}
|
}
|
} else {
|
markStaticNode(tree, key, isOnce)
|
}
|
}
|
|
function markStaticNode(node, key, isOnce) {
|
node.isStatic = true
|
node.key = key
|
node.isOnce = isOnce
|
}
|
|
/* */
|
|
function bindObjectListeners(data, value) {
|
if (value) {
|
if (!isPlainObject(value)) {
|
"production" !== "production" &&
|
warn("v-on without argument expects an Object value", this)
|
} else {
|
var on = (data.on = data.on ? extend({}, data.on) : {})
|
for (var key in value) {
|
var existing = on[key]
|
var ours = value[key]
|
on[key] = existing ? [].concat(ours, existing) : ours
|
}
|
}
|
}
|
return data
|
}
|
|
/* */
|
|
function initRender(vm) {
|
vm._vnode = null // the root of the child tree
|
vm._staticTrees = null
|
var parentVnode = (vm.$vnode = vm.$options._parentVnode) // the placeholder node in parent tree
|
var renderContext = parentVnode && parentVnode.context
|
vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext)
|
vm.$scopedSlots = emptyObject
|
// bind the createElement fn to this instance
|
// so that we get proper render context inside it.
|
// args order: tag, data, children, normalizationType, alwaysNormalize
|
// internal version is used by render functions compiled from templates
|
vm._c = function(a, b, c, d) {
|
return createElement(vm, a, b, c, d, false)
|
}
|
// normalization is always applied for the public version, used in
|
// user-written render functions.
|
vm.$createElement = function(a, b, c, d) {
|
return createElement(vm, a, b, c, d, true)
|
}
|
|
// $attrs & $listeners are exposed for easier HOC creation.
|
// they need to be reactive so that HOCs using them are always updated
|
var parentData = parentVnode && parentVnode.data
|
/* istanbul ignore else */
|
{
|
defineReactive$$1(vm, "$attrs", parentData && parentData.attrs, null, true)
|
defineReactive$$1(vm, "$listeners", parentData && parentData.on, null, true)
|
}
|
}
|
|
function renderMixin(Vue) {
|
Vue.prototype.$nextTick = function(fn) {
|
return nextTick(fn, this)
|
}
|
|
Vue.prototype._render = function() {
|
var vm = this
|
var ref = vm.$options
|
var render = ref.render
|
var staticRenderFns = ref.staticRenderFns
|
var _parentVnode = ref._parentVnode
|
|
if (vm._isMounted) {
|
// clone slot nodes on re-renders
|
for (var key in vm.$slots) {
|
vm.$slots[key] = cloneVNodes(vm.$slots[key])
|
}
|
}
|
|
vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject
|
|
if (staticRenderFns && !vm._staticTrees) {
|
vm._staticTrees = []
|
}
|
// set parent vnode. this allows render functions to have access
|
// to the data on the placeholder node.
|
vm.$vnode = _parentVnode
|
// render self
|
var vnode
|
try {
|
vnode = render.call(vm._renderProxy, vm.$createElement)
|
} catch (e) {
|
handleError(e, vm, "render function")
|
// return error render result,
|
// or previous vnode to prevent render error causing blank component
|
/* istanbul ignore else */
|
{
|
vnode = vm._vnode
|
}
|
}
|
// return empty vnode in case the render function errored out
|
if (!(vnode instanceof VNode)) {
|
if ("production" !== "production" && Array.isArray(vnode)) {
|
warn(
|
"Multiple root nodes returned from render function. Render function " +
|
"should return a single root node.",
|
vm
|
)
|
}
|
vnode = createEmptyVNode()
|
}
|
// set parent
|
vnode.parent = _parentVnode
|
return vnode
|
}
|
|
// internal render helpers.
|
// these are exposed on the instance prototype to reduce generated render
|
// code size.
|
Vue.prototype._o = markOnce
|
Vue.prototype._n = toNumber
|
Vue.prototype._s = toString
|
Vue.prototype._l = renderList
|
Vue.prototype._t = renderSlot
|
Vue.prototype._q = looseEqual
|
Vue.prototype._i = looseIndexOf
|
Vue.prototype._m = renderStatic
|
Vue.prototype._f = resolveFilter
|
Vue.prototype._k = checkKeyCodes
|
Vue.prototype._b = bindObjectProps
|
Vue.prototype._v = createTextVNode
|
Vue.prototype._e = createEmptyVNode
|
Vue.prototype._u = resolveScopedSlots
|
Vue.prototype._g = bindObjectListeners
|
}
|
|
/* */
|
|
var uid = 0
|
|
function initMixin(Vue) {
|
Vue.prototype._init = function(options) {
|
var vm = this
|
// a uid
|
vm._uid = uid++
|
|
var startTag, endTag
|
/* istanbul ignore if */
|
if ("production" !== "production" && config.performance && mark) {
|
startTag = "vue-perf-init:" + vm._uid
|
endTag = "vue-perf-end:" + vm._uid
|
mark(startTag)
|
}
|
|
// a flag to avoid this being observed
|
vm._isVue = true
|
// merge options
|
if (options && options._isComponent) {
|
// optimize internal component instantiation
|
// since dynamic options merging is pretty slow, and none of the
|
// internal component options needs special treatment.
|
initInternalComponent(vm, options)
|
} else {
|
vm.$options = mergeOptions(
|
resolveConstructorOptions(vm.constructor),
|
options || {},
|
vm
|
)
|
}
|
/* istanbul ignore else */
|
{
|
vm._renderProxy = vm
|
}
|
// expose real self
|
vm._self = vm
|
initLifecycle(vm)
|
initEvents(vm)
|
initRender(vm)
|
callHook(vm, "beforeCreate")
|
initInjections(vm) // resolve injections before data/props
|
initState(vm)
|
initProvide(vm) // resolve provide after data/props
|
callHook(vm, "created")
|
|
/* istanbul ignore if */
|
if ("production" !== "production" && config.performance && mark) {
|
vm._name = formatComponentName(vm, false)
|
mark(endTag)
|
measure(vm._name + " init", startTag, endTag)
|
}
|
|
if (vm.$options.el) {
|
vm.$mount(vm.$options.el)
|
}
|
}
|
}
|
|
function initInternalComponent(vm, options) {
|
var opts = (vm.$options = Object.create(vm.constructor.options))
|
// doing this because it's faster than dynamic enumeration.
|
opts.parent = options.parent
|
opts.propsData = options.propsData
|
opts._parentVnode = options._parentVnode
|
opts._parentListeners = options._parentListeners
|
opts._renderChildren = options._renderChildren
|
opts._componentTag = options._componentTag
|
opts._parentElm = options._parentElm
|
opts._refElm = options._refElm
|
if (options.render) {
|
opts.render = options.render
|
opts.staticRenderFns = options.staticRenderFns
|
}
|
}
|
|
function resolveConstructorOptions(Ctor) {
|
var options = Ctor.options
|
if (Ctor.super) {
|
var superOptions = resolveConstructorOptions(Ctor.super)
|
var cachedSuperOptions = Ctor.superOptions
|
if (superOptions !== cachedSuperOptions) {
|
// super option changed,
|
// need to resolve new options.
|
Ctor.superOptions = superOptions
|
// check if there are any late-modified/attached options (#4976)
|
var modifiedOptions = resolveModifiedOptions(Ctor)
|
// update base extend options
|
if (modifiedOptions) {
|
extend(Ctor.extendOptions, modifiedOptions)
|
}
|
options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions)
|
if (options.name) {
|
options.components[options.name] = Ctor
|
}
|
}
|
}
|
return options
|
}
|
|
function resolveModifiedOptions(Ctor) {
|
var modified
|
var latest = Ctor.options
|
var extended = Ctor.extendOptions
|
var sealed = Ctor.sealedOptions
|
for (var key in latest) {
|
if (latest[key] !== sealed[key]) {
|
if (!modified) {
|
modified = {}
|
}
|
modified[key] = dedupe(latest[key], extended[key], sealed[key])
|
}
|
}
|
return modified
|
}
|
|
function dedupe(latest, extended, sealed) {
|
// compare latest and sealed to ensure lifecycle hooks won't be duplicated
|
// between merges
|
if (Array.isArray(latest)) {
|
var res = []
|
sealed = Array.isArray(sealed) ? sealed : [sealed]
|
extended = Array.isArray(extended) ? extended : [extended]
|
for (var i = 0; i < latest.length; i++) {
|
// push original options and not sealed options to exclude duplicated options
|
if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {
|
res.push(latest[i])
|
}
|
}
|
return res
|
} else {
|
return latest
|
}
|
}
|
|
function Vue$3(options) {
|
if ("production" !== "production" && !(this instanceof Vue$3)) {
|
warn("Vue is a constructor and should be called with the `new` keyword")
|
}
|
this._init(options)
|
}
|
|
initMixin(Vue$3)
|
stateMixin(Vue$3)
|
eventsMixin(Vue$3)
|
lifecycleMixin(Vue$3)
|
renderMixin(Vue$3)
|
|
/* */
|
|
function initUse(Vue) {
|
Vue.use = function(plugin) {
|
var installedPlugins = this._installedPlugins || (this._installedPlugins = [])
|
if (installedPlugins.indexOf(plugin) > -1) {
|
return this
|
}
|
|
// additional parameters
|
var args = toArray(arguments, 1)
|
args.unshift(this)
|
if (typeof plugin.install === "function") {
|
plugin.install.apply(plugin, args)
|
} else if (typeof plugin === "function") {
|
plugin.apply(null, args)
|
}
|
installedPlugins.push(plugin)
|
return this
|
}
|
}
|
|
/* */
|
|
function initMixin$1(Vue) {
|
Vue.mixin = function(mixin) {
|
this.options = mergeOptions(this.options, mixin)
|
return this
|
}
|
}
|
|
/* */
|
|
function initExtend(Vue) {
|
/**
|
* Each instance constructor, including Vue, has a unique
|
* cid. This enables us to create wrapped "child
|
* constructors" for prototypal inheritance and cache them.
|
*/
|
Vue.cid = 0
|
var cid = 1
|
|
/**
|
* Class inheritance
|
*/
|
Vue.extend = function(extendOptions) {
|
extendOptions = extendOptions || {}
|
var Super = this
|
var SuperId = Super.cid
|
var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {})
|
if (cachedCtors[SuperId]) {
|
return cachedCtors[SuperId]
|
}
|
|
var name = extendOptions.name || Super.options.name
|
var Sub = function VueComponent(options) {
|
this._init(options)
|
}
|
Sub.prototype = Object.create(Super.prototype)
|
Sub.prototype.constructor = Sub
|
Sub.cid = cid++
|
Sub.options = mergeOptions(Super.options, extendOptions)
|
Sub["super"] = Super
|
|
// For props and computed properties, we define the proxy getters on
|
// the Vue instances at extension time, on the extended prototype. This
|
// avoids Object.defineProperty calls for each instance created.
|
if (Sub.options.props) {
|
initProps$1(Sub)
|
}
|
if (Sub.options.computed) {
|
initComputed$1(Sub)
|
}
|
|
// allow further extension/mixin/plugin usage
|
Sub.extend = Super.extend
|
Sub.mixin = Super.mixin
|
Sub.use = Super.use
|
|
// create asset registers, so extended classes
|
// can have their private assets too.
|
ASSET_TYPES.forEach(function(type) {
|
Sub[type] = Super[type]
|
})
|
// enable recursive self-lookup
|
if (name) {
|
Sub.options.components[name] = Sub
|
}
|
|
// keep a reference to the super options at extension time.
|
// later at instantiation we can check if Super's options have
|
// been updated.
|
Sub.superOptions = Super.options
|
Sub.extendOptions = extendOptions
|
Sub.sealedOptions = extend({}, Sub.options)
|
|
// cache constructor
|
cachedCtors[SuperId] = Sub
|
return Sub
|
}
|
}
|
|
function initProps$1(Comp) {
|
var props = Comp.options.props
|
for (var key in props) {
|
proxy(Comp.prototype, "_props", key)
|
}
|
}
|
|
function initComputed$1(Comp) {
|
var computed = Comp.options.computed
|
for (var key in computed) {
|
defineComputed(Comp.prototype, key, computed[key])
|
}
|
}
|
|
/* */
|
|
function initAssetRegisters(Vue) {
|
/**
|
* Create asset registration methods.
|
*/
|
ASSET_TYPES.forEach(function(type) {
|
Vue[type] = function(id, definition) {
|
if (!definition) {
|
return this.options[type + "s"][id]
|
} else {
|
/* istanbul ignore if */
|
if (type === "component" && isPlainObject(definition)) {
|
definition.name = definition.name || id
|
definition = this.options._base.extend(definition)
|
}
|
if (type === "directive" && typeof definition === "function") {
|
definition = {
|
bind: definition,
|
update: definition
|
}
|
}
|
this.options[type + "s"][id] = definition
|
return definition
|
}
|
}
|
})
|
}
|
|
/* */
|
|
var patternTypes = [String, RegExp, Array]
|
|
function getComponentName(opts) {
|
return opts && (opts.Ctor.options.name || opts.tag)
|
}
|
|
function matches(pattern, name) {
|
if (Array.isArray(pattern)) {
|
return pattern.indexOf(name) > -1
|
} else if (typeof pattern === "string") {
|
return pattern.split(",").indexOf(name) > -1
|
} else if (isRegExp(pattern)) {
|
return pattern.test(name)
|
}
|
/* istanbul ignore next */
|
return false
|
}
|
|
function pruneCache(cache, current, filter) {
|
for (var key in cache) {
|
var cachedNode = cache[key]
|
if (cachedNode) {
|
var name = getComponentName(cachedNode.componentOptions)
|
if (name && !filter(name)) {
|
if (cachedNode !== current) {
|
pruneCacheEntry(cachedNode)
|
}
|
cache[key] = null
|
}
|
}
|
}
|
}
|
|
function pruneCacheEntry(vnode) {
|
if (vnode) {
|
vnode.componentInstance.$destroy()
|
}
|
}
|
|
var KeepAlive = {
|
name: "keep-alive",
|
abstract: true,
|
|
props: {
|
include: patternTypes,
|
exclude: patternTypes
|
},
|
|
created: function created() {
|
this.cache = Object.create(null)
|
},
|
|
destroyed: function destroyed() {
|
var this$1 = this
|
|
for (var key in this$1.cache) {
|
pruneCacheEntry(this$1.cache[key])
|
}
|
},
|
|
watch: {
|
include: function include(val) {
|
pruneCache(this.cache, this._vnode, function(name) {
|
return matches(val, name)
|
})
|
},
|
exclude: function exclude(val) {
|
pruneCache(this.cache, this._vnode, function(name) {
|
return !matches(val, name)
|
})
|
}
|
},
|
|
render: function render() {
|
var vnode = getFirstComponentChild(this.$slots.default)
|
var componentOptions = vnode && vnode.componentOptions
|
if (componentOptions) {
|
// check pattern
|
var name = getComponentName(componentOptions)
|
if (
|
name &&
|
((this.include && !matches(this.include, name)) ||
|
(this.exclude && matches(this.exclude, name)))
|
) {
|
return vnode
|
}
|
var key =
|
vnode.key == null
|
? // same constructor may get registered as different local components
|
// so cid alone is not enough (#3269)
|
componentOptions.Ctor.cid +
|
(componentOptions.tag ? "::" + componentOptions.tag : "")
|
: vnode.key
|
if (this.cache[key]) {
|
vnode.componentInstance = this.cache[key].componentInstance
|
} else {
|
this.cache[key] = vnode
|
}
|
vnode.data.keepAlive = true
|
}
|
return vnode
|
}
|
}
|
|
var builtInComponents = {
|
KeepAlive: KeepAlive
|
}
|
|
/* */
|
|
function initGlobalAPI(Vue) {
|
// config
|
var configDef = {}
|
configDef.get = function() {
|
return config
|
}
|
Object.defineProperty(Vue, "config", configDef)
|
|
// exposed util methods.
|
// NOTE: these are not considered part of the public API - avoid relying on
|
// them unless you are aware of the risk.
|
Vue.util = {
|
warn: warn,
|
extend: extend,
|
mergeOptions: mergeOptions,
|
defineReactive: defineReactive$$1
|
}
|
|
Vue.set = set
|
Vue.delete = del
|
Vue.nextTick = nextTick
|
|
Vue.options = Object.create(null)
|
ASSET_TYPES.forEach(function(type) {
|
Vue.options[type + "s"] = Object.create(null)
|
})
|
|
// this is used to identify the "base" constructor to extend all plain-object
|
// components with in Weex's multi-instance scenarios.
|
Vue.options._base = Vue
|
|
extend(Vue.options.components, builtInComponents)
|
|
initUse(Vue)
|
initMixin$1(Vue)
|
initExtend(Vue)
|
initAssetRegisters(Vue)
|
}
|
|
initGlobalAPI(Vue$3)
|
|
Object.defineProperty(Vue$3.prototype, "$isServer", {
|
get: isServerRendering
|
})
|
|
Object.defineProperty(Vue$3.prototype, "$ssrContext", {
|
get: function get() {
|
/* istanbul ignore next */
|
return this.$vnode && this.$vnode.ssrContext
|
}
|
})
|
|
Vue$3.version = "2.4.1"
|
Vue$3.mpvueVersion = "1.0.12"
|
|
/* globals renderer */
|
|
var isReservedTag = makeMap(
|
"template,script,style,element,content,slot,link,meta,svg,view," +
|
"a,div,img,image,text,span,richtext,input,switch,textarea,spinner,select," +
|
"slider,slider-neighbor,indicator,trisition,trisition-group,canvas," +
|
"list,cell,header,loading,loading-indicator,refresh,scrollable,scroller," +
|
"video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown",
|
true
|
)
|
|
// these are reserved for web because they are directly compiled away
|
// during template compilation
|
var isReservedAttr = makeMap("style,class")
|
|
// Elements that you can, intentionally, leave open (and which close themselves)
|
// more flexable than web
|
var canBeLeftOpenTag = makeMap(
|
"web,spinner,switch,video,textarea,canvas," + "indicator,marquee,countdown",
|
true
|
)
|
|
var isUnaryTag = makeMap("embed,img,image,input,link,meta", true)
|
|
function mustUseProp() {
|
/* console.log('mustUseProp') */
|
}
|
|
function getTagNamespace() {
|
/* console.log('getTagNamespace') */
|
}
|
|
function isUnknownElement() {
|
/* console.log('isUnknownElement') */
|
}
|
|
function getComKey(vm) {
|
return vm && vm.$attrs ? vm.$attrs["mpcomid"] : "0"
|
}
|
|
// 用于小程序的 event type 到 web 的 event
|
var eventTypeMap = {
|
tap: ["tap", "click"],
|
touchstart: ["touchstart"],
|
touchmove: ["touchmove"],
|
touchcancel: ["touchcancel"],
|
touchend: ["touchend"],
|
longtap: ["longtap"],
|
input: ["input"],
|
blur: ["change", "blur"],
|
submit: ["submit"],
|
focus: ["focus"],
|
scrolltoupper: ["scrolltoupper"],
|
scrolltolower: ["scrolltolower"],
|
scroll: ["scroll"]
|
}
|
|
/* */
|
|
// import { namespaceMap } from 'mp/util/index'
|
|
var obj = {}
|
|
function createElement$1(tagName, vnode) {
|
return obj
|
}
|
|
function createElementNS(namespace, tagName) {
|
return obj
|
}
|
|
function createTextNode(text) {
|
return obj
|
}
|
|
function createComment(text) {
|
return obj
|
}
|
|
function insertBefore(parentNode, newNode, referenceNode) {}
|
|
function removeChild(node, child) {}
|
|
function appendChild(node, child) {}
|
|
function parentNode(node) {
|
return obj
|
}
|
|
function nextSibling(node) {
|
return obj
|
}
|
|
function tagName(node) {
|
return "div"
|
}
|
|
function setTextContent(node, text) {
|
return obj
|
}
|
|
function setAttribute(node, key, val) {
|
return obj
|
}
|
|
var nodeOps = Object.freeze({
|
createElement: createElement$1,
|
createElementNS: createElementNS,
|
createTextNode: createTextNode,
|
createComment: createComment,
|
insertBefore: insertBefore,
|
removeChild: removeChild,
|
appendChild: appendChild,
|
parentNode: parentNode,
|
nextSibling: nextSibling,
|
tagName: tagName,
|
setTextContent: setTextContent,
|
setAttribute: setAttribute
|
})
|
|
/* */
|
|
var ref = {
|
create: function create(_, vnode) {
|
registerRef(vnode)
|
},
|
update: function update(oldVnode, vnode) {
|
if (oldVnode.data.ref !== vnode.data.ref) {
|
registerRef(oldVnode, true)
|
registerRef(vnode)
|
}
|
},
|
destroy: function destroy(vnode) {
|
registerRef(vnode, true)
|
}
|
}
|
|
function registerRef(vnode, isRemoval) {
|
var key = vnode.data.ref
|
if (!key) {
|
return
|
}
|
|
var vm = vnode.context
|
var ref = vnode.componentInstance || vnode.elm
|
var refs = vm.$refs
|
if (isRemoval) {
|
if (Array.isArray(refs[key])) {
|
remove(refs[key], ref)
|
} else if (refs[key] === ref) {
|
refs[key] = undefined
|
}
|
} else {
|
if (vnode.data.refInFor) {
|
if (!Array.isArray(refs[key])) {
|
refs[key] = [ref]
|
} else if (refs[key].indexOf(ref) < 0) {
|
// $flow-disable-line
|
refs[key].push(ref)
|
}
|
} else {
|
refs[key] = ref
|
}
|
}
|
}
|
|
/**
|
* Virtual DOM patching algorithm based on Snabbdom by
|
* Simon Friis Vindum (@paldepind)
|
* Licensed under the MIT License
|
* https://github.com/paldepind/snabbdom/blob/master/LICENSE
|
*
|
* modified by Evan You (@yyx990803)
|
*
|
|
/*
|
* Not type-checking this because this file is perf-critical and the cost
|
* of making flow understand it is not worth it.
|
*/
|
|
var emptyNode = new VNode("", {}, [])
|
|
var hooks = ["create", "activate", "update", "remove", "destroy"]
|
|
function sameVnode(a, b) {
|
return (
|
a.key === b.key &&
|
((a.tag === b.tag &&
|
a.isComment === b.isComment &&
|
isDef(a.data) === isDef(b.data) &&
|
sameInputType(a, b)) ||
|
(isTrue(a.isAsyncPlaceholder) &&
|
a.asyncFactory === b.asyncFactory &&
|
isUndef(b.asyncFactory.error)))
|
)
|
}
|
|
// Some browsers do not support dynamically changing type for <input>
|
// so they need to be treated as different nodes
|
function sameInputType(a, b) {
|
if (a.tag !== "input") {
|
return true
|
}
|
var i
|
var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type
|
var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type
|
return typeA === typeB
|
}
|
|
function createKeyToOldIdx(children, beginIdx, endIdx) {
|
var i, key
|
var map = {}
|
for (i = beginIdx; i <= endIdx; ++i) {
|
key = children[i].key
|
if (isDef(key)) {
|
map[key] = i
|
}
|
}
|
return map
|
}
|
|
function createPatchFunction(backend) {
|
var i, j
|
var cbs = {}
|
|
var modules = backend.modules
|
var nodeOps = backend.nodeOps
|
|
for (i = 0; i < hooks.length; ++i) {
|
cbs[hooks[i]] = []
|
for (j = 0; j < modules.length; ++j) {
|
if (isDef(modules[j][hooks[i]])) {
|
cbs[hooks[i]].push(modules[j][hooks[i]])
|
}
|
}
|
}
|
|
function emptyNodeAt(elm) {
|
return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
|
}
|
|
function createRmCb(childElm, listeners) {
|
function remove$$1() {
|
if (--remove$$1.listeners === 0) {
|
removeNode(childElm)
|
}
|
}
|
remove$$1.listeners = listeners
|
return remove$$1
|
}
|
|
function removeNode(el) {
|
var parent = nodeOps.parentNode(el)
|
// element may have already been removed due to v-html / v-text
|
if (isDef(parent)) {
|
nodeOps.removeChild(parent, el)
|
}
|
}
|
|
var inPre = 0
|
|
function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested) {
|
vnode.isRootInsert = !nested // for transition enter check
|
if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
|
return
|
}
|
|
var data = vnode.data
|
var children = vnode.children
|
var tag = vnode.tag
|
if (isDef(tag)) {
|
vnode.elm = vnode.ns
|
? nodeOps.createElementNS(vnode.ns, tag)
|
: nodeOps.createElement(tag, vnode)
|
setScope(vnode)
|
|
/* istanbul ignore if */
|
{
|
createChildren(vnode, children, insertedVnodeQueue)
|
if (isDef(data)) {
|
invokeCreateHooks(vnode, insertedVnodeQueue)
|
}
|
insert(parentElm, vnode.elm, refElm)
|
}
|
|
if ("production" !== "production" && data && data.pre) {
|
inPre--
|
}
|
} else if (isTrue(vnode.isComment)) {
|
vnode.elm = nodeOps.createComment(vnode.text)
|
insert(parentElm, vnode.elm, refElm)
|
} else {
|
vnode.elm = nodeOps.createTextNode(vnode.text)
|
insert(parentElm, vnode.elm, refElm)
|
}
|
}
|
|
function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
|
var i = vnode.data
|
if (isDef(i)) {
|
var isReactivated = isDef(vnode.componentInstance) && i.keepAlive
|
if (isDef((i = i.hook)) && isDef((i = i.init))) {
|
i(vnode, false /* hydrating */, parentElm, refElm)
|
}
|
// after calling the init hook, if the vnode is a child component
|
// it should've created a child instance and mounted it. the child
|
// component also has set the placeholder vnode's elm.
|
// in that case we can just return the element and be done.
|
if (isDef(vnode.componentInstance)) {
|
initComponent(vnode, insertedVnodeQueue)
|
if (isTrue(isReactivated)) {
|
reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
|
}
|
return true
|
}
|
}
|
}
|
|
function initComponent(vnode, insertedVnodeQueue) {
|
if (isDef(vnode.data.pendingInsert)) {
|
insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert)
|
vnode.data.pendingInsert = null
|
}
|
vnode.elm = vnode.componentInstance.$el
|
if (isPatchable(vnode)) {
|
invokeCreateHooks(vnode, insertedVnodeQueue)
|
setScope(vnode)
|
} else {
|
// empty component root.
|
// skip all element-related modules except for ref (#3455)
|
registerRef(vnode)
|
// make sure to invoke the insert hook
|
insertedVnodeQueue.push(vnode)
|
}
|
}
|
|
function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
|
var i
|
// hack for #4339: a reactivated component with inner transition
|
// does not trigger because the inner node's created hooks are not called
|
// again. It's not ideal to involve module-specific logic in here but
|
// there doesn't seem to be a better way to do it.
|
var innerNode = vnode
|
while (innerNode.componentInstance) {
|
innerNode = innerNode.componentInstance._vnode
|
if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
|
for (i = 0; i < cbs.activate.length; ++i) {
|
cbs.activate[i](emptyNode, innerNode)
|
}
|
insertedVnodeQueue.push(innerNode)
|
break
|
}
|
}
|
// unlike a newly created component,
|
// a reactivated keep-alive component doesn't insert itself
|
insert(parentElm, vnode.elm, refElm)
|
}
|
|
function insert(parent, elm, ref$$1) {
|
if (isDef(parent)) {
|
if (isDef(ref$$1)) {
|
if (ref$$1.parentNode === parent) {
|
nodeOps.insertBefore(parent, elm, ref$$1)
|
}
|
} else {
|
nodeOps.appendChild(parent, elm)
|
}
|
}
|
}
|
|
function createChildren(vnode, children, insertedVnodeQueue) {
|
if (Array.isArray(children)) {
|
for (var i = 0; i < children.length; ++i) {
|
createElm(children[i], insertedVnodeQueue, vnode.elm, null, true)
|
}
|
} else if (isPrimitive(vnode.text)) {
|
nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text))
|
}
|
}
|
|
function isPatchable(vnode) {
|
while (vnode.componentInstance) {
|
vnode = vnode.componentInstance._vnode
|
}
|
return isDef(vnode.tag)
|
}
|
|
function invokeCreateHooks(vnode, insertedVnodeQueue) {
|
for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
|
cbs.create[i$1](emptyNode, vnode)
|
}
|
i = vnode.data.hook // Reuse variable
|
if (isDef(i)) {
|
if (isDef(i.create)) {
|
i.create(emptyNode, vnode)
|
}
|
if (isDef(i.insert)) {
|
insertedVnodeQueue.push(vnode)
|
}
|
}
|
}
|
|
// set scope id attribute for scoped CSS.
|
// this is implemented as a special case to avoid the overhead
|
// of going through the normal attribute patching process.
|
function setScope(vnode) {
|
var i
|
var ancestor = vnode
|
while (ancestor) {
|
if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
|
nodeOps.setAttribute(vnode.elm, i, "")
|
}
|
ancestor = ancestor.parent
|
}
|
// for slot content they should also get the scopeId from the host instance.
|
if (
|
isDef((i = activeInstance)) &&
|
i !== vnode.context &&
|
isDef((i = i.$options._scopeId))
|
) {
|
nodeOps.setAttribute(vnode.elm, i, "")
|
}
|
}
|
|
function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
|
for (; startIdx <= endIdx; ++startIdx) {
|
createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm)
|
}
|
}
|
|
function invokeDestroyHook(vnode) {
|
var i, j
|
var data = vnode.data
|
if (isDef(data)) {
|
if (isDef((i = data.hook)) && isDef((i = i.destroy))) {
|
i(vnode)
|
}
|
for (i = 0; i < cbs.destroy.length; ++i) {
|
cbs.destroy[i](vnode)
|
}
|
}
|
if (isDef((i = vnode.children))) {
|
for (j = 0; j < vnode.children.length; ++j) {
|
invokeDestroyHook(vnode.children[j])
|
}
|
}
|
}
|
|
function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
|
for (; startIdx <= endIdx; ++startIdx) {
|
var ch = vnodes[startIdx]
|
if (isDef(ch)) {
|
if (isDef(ch.tag)) {
|
removeAndInvokeRemoveHook(ch)
|
invokeDestroyHook(ch)
|
} else {
|
// Text node
|
removeNode(ch.elm)
|
}
|
}
|
}
|
}
|
|
function removeAndInvokeRemoveHook(vnode, rm) {
|
if (isDef(rm) || isDef(vnode.data)) {
|
var i
|
var listeners = cbs.remove.length + 1
|
if (isDef(rm)) {
|
// we have a recursively passed down rm callback
|
// increase the listeners count
|
rm.listeners += listeners
|
} else {
|
// directly removing
|
rm = createRmCb(vnode.elm, listeners)
|
}
|
// recursively invoke hooks on child component root node
|
if (
|
isDef((i = vnode.componentInstance)) &&
|
isDef((i = i._vnode)) &&
|
isDef(i.data)
|
) {
|
removeAndInvokeRemoveHook(i, rm)
|
}
|
for (i = 0; i < cbs.remove.length; ++i) {
|
cbs.remove[i](vnode, rm)
|
}
|
if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
|
i(vnode, rm)
|
} else {
|
rm()
|
}
|
} else {
|
removeNode(vnode.elm)
|
}
|
}
|
|
function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
|
var oldStartIdx = 0
|
var newStartIdx = 0
|
var oldEndIdx = oldCh.length - 1
|
var oldStartVnode = oldCh[0]
|
var oldEndVnode = oldCh[oldEndIdx]
|
var newEndIdx = newCh.length - 1
|
var newStartVnode = newCh[0]
|
var newEndVnode = newCh[newEndIdx]
|
var oldKeyToIdx, idxInOld, elmToMove, refElm
|
|
// removeOnly is a special flag used only by <transition-group>
|
// to ensure removed elements stay in correct relative positions
|
// during leaving transitions
|
var canMove = !removeOnly
|
|
while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
|
if (isUndef(oldStartVnode)) {
|
oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
|
} else if (isUndef(oldEndVnode)) {
|
oldEndVnode = oldCh[--oldEndIdx]
|
} else if (sameVnode(oldStartVnode, newStartVnode)) {
|
patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue)
|
oldStartVnode = oldCh[++oldStartIdx]
|
newStartVnode = newCh[++newStartIdx]
|
} else if (sameVnode(oldEndVnode, newEndVnode)) {
|
patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue)
|
oldEndVnode = oldCh[--oldEndIdx]
|
newEndVnode = newCh[--newEndIdx]
|
} else if (sameVnode(oldStartVnode, newEndVnode)) {
|
// Vnode moved right
|
patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue)
|
canMove &&
|
nodeOps.insertBefore(
|
parentElm,
|
oldStartVnode.elm,
|
nodeOps.nextSibling(oldEndVnode.elm)
|
)
|
oldStartVnode = oldCh[++oldStartIdx]
|
newEndVnode = newCh[--newEndIdx]
|
} else if (sameVnode(oldEndVnode, newStartVnode)) {
|
// Vnode moved left
|
patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue)
|
canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
|
oldEndVnode = oldCh[--oldEndIdx]
|
newStartVnode = newCh[++newStartIdx]
|
} else {
|
if (isUndef(oldKeyToIdx)) {
|
oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
|
}
|
idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null
|
if (isUndef(idxInOld)) {
|
// New element
|
createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)
|
newStartVnode = newCh[++newStartIdx]
|
} else {
|
elmToMove = oldCh[idxInOld]
|
/* istanbul ignore if */
|
if ("production" !== "production" && !elmToMove) {
|
warn(
|
"It seems there are duplicate keys that is causing an update error. " +
|
"Make sure each v-for item has a unique key."
|
)
|
}
|
if (sameVnode(elmToMove, newStartVnode)) {
|
patchVnode(elmToMove, newStartVnode, insertedVnodeQueue)
|
oldCh[idxInOld] = undefined
|
canMove &&
|
nodeOps.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm)
|
newStartVnode = newCh[++newStartIdx]
|
} else {
|
// same key but different element. treat as new element
|
createElm(
|
newStartVnode,
|
insertedVnodeQueue,
|
parentElm,
|
oldStartVnode.elm
|
)
|
newStartVnode = newCh[++newStartIdx]
|
}
|
}
|
}
|
}
|
if (oldStartIdx > oldEndIdx) {
|
refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
|
addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)
|
} else if (newStartIdx > newEndIdx) {
|
removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx)
|
}
|
}
|
|
function patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly) {
|
if (oldVnode === vnode) {
|
return
|
}
|
|
var elm = (vnode.elm = oldVnode.elm)
|
|
if (isTrue(oldVnode.isAsyncPlaceholder)) {
|
if (isDef(vnode.asyncFactory.resolved)) {
|
hydrate(oldVnode.elm, vnode, insertedVnodeQueue)
|
} else {
|
vnode.isAsyncPlaceholder = true
|
}
|
return
|
}
|
|
// reuse element for static trees.
|
// note we only do this if the vnode is cloned -
|
// if the new node is not cloned it means the render functions have been
|
// reset by the hot-reload-api and we need to do a proper re-render.
|
if (
|
isTrue(vnode.isStatic) &&
|
isTrue(oldVnode.isStatic) &&
|
vnode.key === oldVnode.key &&
|
(isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
|
) {
|
vnode.componentInstance = oldVnode.componentInstance
|
return
|
}
|
|
var i
|
var data = vnode.data
|
if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
|
i(oldVnode, vnode)
|
}
|
|
var oldCh = oldVnode.children
|
var ch = vnode.children
|
if (isDef(data) && isPatchable(vnode)) {
|
for (i = 0; i < cbs.update.length; ++i) {
|
cbs.update[i](oldVnode, vnode)
|
}
|
if (isDef((i = data.hook)) && isDef((i = i.update))) {
|
i(oldVnode, vnode)
|
}
|
}
|
if (isUndef(vnode.text)) {
|
if (isDef(oldCh) && isDef(ch)) {
|
if (oldCh !== ch) {
|
updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
|
}
|
} else if (isDef(ch)) {
|
if (isDef(oldVnode.text)) {
|
nodeOps.setTextContent(elm, "")
|
}
|
addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)
|
} else if (isDef(oldCh)) {
|
removeVnodes(elm, oldCh, 0, oldCh.length - 1)
|
} else if (isDef(oldVnode.text)) {
|
nodeOps.setTextContent(elm, "")
|
}
|
} else if (oldVnode.text !== vnode.text) {
|
nodeOps.setTextContent(elm, vnode.text)
|
}
|
if (isDef(data)) {
|
if (isDef((i = data.hook)) && isDef((i = i.postpatch))) {
|
i(oldVnode, vnode)
|
}
|
}
|
}
|
|
function invokeInsertHook(vnode, queue, initial) {
|
// delay insert hooks for component root nodes, invoke them after the
|
// element is really inserted
|
if (isTrue(initial) && isDef(vnode.parent)) {
|
vnode.parent.data.pendingInsert = queue
|
} else {
|
for (var i = 0; i < queue.length; ++i) {
|
queue[i].data.hook.insert(queue[i])
|
}
|
}
|
}
|
|
var bailed = false
|
// list of modules that can skip create hook during hydration because they
|
// are already rendered on the client or has no need for initialization
|
var isRenderedModule = makeMap("attrs,style,class,staticClass,staticStyle,key")
|
|
// Note: this is a browser-only function so we can assume elms are DOM nodes.
|
function hydrate(elm, vnode, insertedVnodeQueue) {
|
if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
|
vnode.elm = elm
|
vnode.isAsyncPlaceholder = true
|
return true
|
}
|
vnode.elm = elm
|
var tag = vnode.tag
|
var data = vnode.data
|
var children = vnode.children
|
if (isDef(data)) {
|
if (isDef((i = data.hook)) && isDef((i = i.init))) {
|
i(vnode, true /* hydrating */)
|
}
|
if (isDef((i = vnode.componentInstance))) {
|
// child component. it should have hydrated its own tree.
|
initComponent(vnode, insertedVnodeQueue)
|
return true
|
}
|
}
|
if (isDef(tag)) {
|
if (isDef(children)) {
|
// empty element, allow client to pick up and populate children
|
if (!elm.hasChildNodes()) {
|
createChildren(vnode, children, insertedVnodeQueue)
|
} else {
|
var childrenMatch = true
|
var childNode = elm.firstChild
|
for (var i$1 = 0; i$1 < children.length; i$1++) {
|
if (
|
!childNode ||
|
!hydrate(childNode, children[i$1], insertedVnodeQueue)
|
) {
|
childrenMatch = false
|
break
|
}
|
childNode = childNode.nextSibling
|
}
|
// if childNode is not null, it means the actual childNodes list is
|
// longer than the virtual children list.
|
if (!childrenMatch || childNode) {
|
if (
|
"production" !== "production" &&
|
typeof console !== "undefined" &&
|
!bailed
|
) {
|
bailed = true
|
console.warn("Parent: ", elm)
|
console.warn(
|
"Mismatching childNodes vs. VNodes: ",
|
elm.childNodes,
|
children
|
)
|
}
|
return false
|
}
|
}
|
}
|
if (isDef(data)) {
|
for (var key in data) {
|
if (!isRenderedModule(key)) {
|
invokeCreateHooks(vnode, insertedVnodeQueue)
|
break
|
}
|
}
|
}
|
} else if (elm.data !== vnode.text) {
|
elm.data = vnode.text
|
}
|
return true
|
}
|
|
return function patch(oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {
|
if (isUndef(vnode)) {
|
if (isDef(oldVnode)) {
|
invokeDestroyHook(oldVnode)
|
}
|
return
|
}
|
|
var isInitialPatch = false
|
var insertedVnodeQueue = []
|
|
if (isUndef(oldVnode)) {
|
// empty mount (likely as component), create new root element
|
isInitialPatch = true
|
createElm(vnode, insertedVnodeQueue, parentElm, refElm)
|
} else {
|
var isRealElement = isDef(oldVnode.nodeType)
|
if (!isRealElement && sameVnode(oldVnode, vnode)) {
|
// patch existing root node
|
patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly)
|
} else {
|
if (isRealElement) {
|
// mounting to a real element
|
// check if this is server-rendered content and if we can perform
|
// a successful hydration.
|
if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
|
oldVnode.removeAttribute(SSR_ATTR)
|
hydrating = true
|
}
|
if (isTrue(hydrating)) {
|
if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
|
invokeInsertHook(vnode, insertedVnodeQueue, true)
|
return oldVnode
|
} else {
|
}
|
}
|
// either not server-rendered, or hydration failed.
|
// create an empty node and replace it
|
oldVnode = emptyNodeAt(oldVnode)
|
}
|
// replacing existing element
|
var oldElm = oldVnode.elm
|
var parentElm$1 = nodeOps.parentNode(oldElm)
|
createElm(
|
vnode,
|
insertedVnodeQueue,
|
// extremely rare edge case: do not insert if old element is in a
|
// leaving transition. Only happens when combining transition +
|
// keep-alive + HOCs. (#4590)
|
oldElm._leaveCb ? null : parentElm$1,
|
nodeOps.nextSibling(oldElm)
|
)
|
|
if (isDef(vnode.parent)) {
|
// component root element replaced.
|
// update parent placeholder node element, recursively
|
var ancestor = vnode.parent
|
while (ancestor) {
|
ancestor.elm = vnode.elm
|
ancestor = ancestor.parent
|
}
|
if (isPatchable(vnode)) {
|
for (var i = 0; i < cbs.create.length; ++i) {
|
cbs.create[i](emptyNode, vnode.parent)
|
}
|
}
|
}
|
|
if (isDef(parentElm$1)) {
|
removeVnodes(parentElm$1, [oldVnode], 0, 0)
|
} else if (isDef(oldVnode.tag)) {
|
invokeDestroyHook(oldVnode)
|
}
|
}
|
}
|
|
invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
|
return vnode.elm
|
}
|
}
|
|
/* */
|
|
// import baseModules from 'core/vdom/modules/index'
|
// const platformModules = []
|
// import platformModules from 'web/runtime/modules/index'
|
|
// the directive module should be applied last, after all
|
// built-in modules have been applied.
|
// const modules = platformModules.concat(baseModules)
|
var modules = [ref]
|
|
var corePatch = createPatchFunction({
|
nodeOps: nodeOps,
|
modules: modules
|
})
|
|
function patch() {
|
corePatch.apply(this, arguments)
|
this.$updateDataToMP()
|
}
|
|
function callHook$1(vm, hook, params) {
|
var handlers = vm.$options[hook]
|
if (hook === "onError" && handlers) {
|
handlers = [handlers]
|
}
|
|
var ret
|
if (handlers) {
|
for (var i = 0, j = handlers.length; i < j; i++) {
|
try {
|
ret = handlers[i].call(vm, params)
|
} catch (e) {
|
handleError(e, vm, hook + " hook")
|
}
|
}
|
}
|
if (vm._hasHookEvent) {
|
vm.$emit("hook:" + hook)
|
}
|
|
// for child
|
if (vm.$children.length) {
|
vm.$children.forEach(function(v) {
|
return callHook$1(v, hook, params)
|
})
|
}
|
|
return ret
|
}
|
|
// mpType 小程序实例的类型，可能的值是 'app', 'page'
|
// rootVueVM 是 vue 的根组件实例，子组件中访问 this.$root 可得
|
function getGlobalData(app, rootVueVM) {
|
var mp = rootVueVM.$mp
|
if (app && app.globalData) {
|
mp.appOptions = app.globalData.appOptions
|
}
|
}
|
|
// 格式化 properties 属性，并给每个属性加上 observer 方法
|
|
// properties 的 一些类型 https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/component.html
|
// properties: {
|
// paramA: Number,
|
// myProperty: { // 属性名
|
// type: String, // 类型（必填），目前接受的类型包括：String, Number, Boolean, Object, Array, null（表示任意类型）
|
// value: '', // 属性初始值（可选），如果未指定则会根据类型选择一个
|
// observer: function(newVal, oldVal, changedPath) {
|
// // 属性被改变时执行的函数（可选），也可以写成在methods段中定义的方法名字符串, 如：'_propertyChange'
|
// // 通常 newVal 就是新设置的数据， oldVal 是旧数据
|
// }
|
// },
|
// }
|
|
// props 的一些类型 https://cn.vuejs.org/v2/guide/components-props.html#ad
|
// props: {
|
// // 基础的类型检查 (`null` 匹配任何类型)
|
// propA: Number,
|
// // 多个可能的类型
|
// propB: [String, Number],
|
// // 必填的字符串
|
// propC: {
|
// type: String,
|
// required: true
|
// },
|
// // 带有默认值的数字
|
// propD: {
|
// type: Number,
|
// default: 100
|
// },
|
// // 带有默认值的对象
|
// propE: {
|
// type: Object,
|
// // 对象或数组且一定会从一个工厂函数返回默认值
|
// default: function () {
|
// return { message: 'hello' }
|
// }
|
// },
|
// // 自定义验证函数
|
// propF: {
|
// validator: function (value) {
|
// // 这个值必须匹配下列字符串中的一个
|
// return ['success', 'warning', 'danger'].indexOf(value) !== -1
|
// }
|
// }
|
// }
|
|
// core/util/options
|
function normalizeProps$1(props, res, vm) {
|
if (!props) {
|
return
|
}
|
var i, val, name
|
if (Array.isArray(props)) {
|
i = props.length
|
while (i--) {
|
val = props[i]
|
if (typeof val === "string") {
|
name = camelize(val)
|
res[name] = {
|
type: null
|
}
|
} else {
|
}
|
}
|
} else if (isPlainObject(props)) {
|
for (var key in props) {
|
val = props[key]
|
name = camelize(key)
|
res[name] = isPlainObject(val)
|
? val
|
: {
|
type: val
|
}
|
}
|
}
|
|
// fix vueProps to properties
|
for (var key$1 in res) {
|
if (res.hasOwnProperty(key$1)) {
|
var item = res[key$1]
|
if (item.default) {
|
item.value = item.default
|
}
|
var oldObserver = item.observer
|
item.observer = function(newVal, oldVal) {
|
vm[name] = newVal
|
// 先修改值再触发原始的 observer，跟 watch 行为保持一致
|
if (typeof oldObserver === "function") {
|
oldObserver.call(vm, newVal, oldVal)
|
}
|
}
|
}
|
}
|
|
return res
|
}
|
|
function normalizeProperties(vm) {
|
var properties = vm.$options.properties
|
var vueProps = vm.$options.props
|
var res = {}
|
|
normalizeProps$1(properties, res, vm)
|
normalizeProps$1(vueProps, res, vm)
|
|
return res
|
}
|
|
/**
|
* 把 properties 中的属性 proxy 到 vm 上
|
*/
|
function initMpProps(vm) {
|
var mpProps = (vm._mpProps = {})
|
var keys = Object.keys(vm.$options.properties || {})
|
keys.forEach(function(key) {
|
if (!(key in vm)) {
|
proxy(vm, "_mpProps", key)
|
mpProps[key] = undefined // for observe
|
}
|
})
|
observe(mpProps, true)
|
}
|
|
function initMP(mpType, next) {
|
var rootVueVM = this.$root
|
if (!rootVueVM.$mp) {
|
rootVueVM.$mp = {}
|
}
|
|
var mp = rootVueVM.$mp
|
|
// Please do not register multiple Pages
|
// if (mp.registered) {
|
if (mp.status) {
|
// 处理子组件的小程序生命周期
|
if (mpType === "app") {
|
callHook$1(this, "onLaunch", mp.appOptions)
|
} else {
|
this.__wxWebviewId__ = rootVueVM.__wxWebviewId__
|
this.__wxExparserNodeId__ = rootVueVM.__wxExparserNodeId__
|
callHook$1(this, "onLoad", mp.query)
|
// callHook$1(this, "onReady") // 避免 onReady触发两次
|
}
|
return next()
|
}
|
// mp.registered = true
|
|
mp.mpType = mpType
|
mp.status = "register"
|
|
if (mpType === "app") {
|
global.App({
|
// 页面的初始数据
|
globalData: {
|
appOptions: {}
|
},
|
|
handleProxy: function handleProxy(e) {
|
return rootVueVM.$handleProxyWithVue(e)
|
},
|
|
// Do something initial when launch.
|
onLaunch: function onLaunch(options) {
|
if (options === void 0) options = {}
|
|
mp.app = this
|
mp.status = "launch"
|
this.globalData.appOptions = mp.appOptions = options
|
callHook$1(rootVueVM, "onLaunch", options)
|
next()
|
},
|
|
// Do something when app show.
|
onShow: function onShow(options) {
|
if (options === void 0) options = {}
|
|
mp.status = "show"
|
this.globalData.appOptions = mp.appOptions = options
|
callHook$1(rootVueVM, "onShow", options)
|
},
|
|
// Do something when app hide.
|
onHide: function onHide() {
|
mp.status = "hide"
|
callHook$1(rootVueVM, "onHide")
|
},
|
|
onError: function onError(err) {
|
callHook$1(rootVueVM, "onError", err)
|
},
|
//fixed by xxxxxx
|
onUniNViewMessage: function onUniNViewMessage(e) {
|
callHook$1(rootVueVM, "onUniNViewMessage", e)
|
}
|
})
|
} else if (mpType === "component") {
|
initMpProps(rootVueVM)
|
|
global.Component({
|
// 小程序原生的组件属性
|
properties: normalizeProperties(rootVueVM),
|
// 页面的初始数据
|
data: {
|
$root: {}
|
},
|
methods: {
|
handleProxy: function handleProxy(e) {
|
return rootVueVM.$handleProxyWithVue(e)
|
}
|
},
|
// mp lifecycle for vue
|
// 组件生命周期函数，在组件实例进入页面节点树时执行，注意此时不能调用 setData
|
created: function created() {
|
mp.status = "created"
|
mp.page = this
|
},
|
// 组件生命周期函数，在组件实例进入页面节点树时执行
|
attached: function attached() {
|
mp.status = "attached"
|
callHook$1(rootVueVM, "attached")
|
},
|
// 组件生命周期函数，在组件布局完成后执行，此时可以获取节点信息（使用 SelectorQuery ）
|
ready: function ready() {
|
mp.status = "ready"
|
|
callHook$1(rootVueVM, "ready")
|
next()
|
|
// 只有页面需要 setData
|
rootVueVM.$nextTick(function() {
|
rootVueVM._initDataToMP()
|
})
|
},
|
// 组件生命周期函数，在组件实例被移动到节点树另一个位置时执行
|
moved: function moved() {
|
callHook$1(rootVueVM, "moved")
|
},
|
// 组件生命周期函数，在组件实例被从页面节点树移除时执行
|
detached: function detached() {
|
mp.status = "detached"
|
callHook$1(rootVueVM, "detached")
|
}
|
})
|
} else {
|
var app = global.getApp()
|
|
|
global.Page({
|
// 页面的初始数据
|
data: {
|
$root: {}
|
},
|
|
handleProxy: function handleProxy(e) {
|
return rootVueVM.$handleProxyWithVue(e)
|
},
|
|
// mp lifecycle for vue
|
// 生命周期函数--监听页面加载
|
onLoad: function onLoad(query) {
|
rootVueVM.__wxWebviewId__ = this.__wxWebviewId__//fixed by xxxxxx(createIntersectionObserver)
|
rootVueVM.__wxExparserNodeId__ = this.__wxExparserNodeId__
|
mp.page = this
|
mp.query = query
|
mp.status = "load"
|
getGlobalData(app, rootVueVM)
|
//仅load时重置数据
|
if (rootVueVM.$options && typeof rootVueVM.$options.data === "function") {
|
Object.assign(rootVueVM.$data, rootVueVM.$options.data())
|
}
|
callHook$1(rootVueVM, "onLoad", query)
|
},
|
|
// 生命周期函数--监听页面显示
|
onShow: function onShow() {
|
rootVueVM.__wxWebviewId__ = this.__wxWebviewId__//fixed by xxxxxx(createIntersectionObserver)
|
rootVueVM.__wxExparserNodeId__ = this.__wxExparserNodeId__
|
mp.page = this
|
mp.status = "show"
|
|
callHook$1(rootVueVM, "onShow")
|
|
// // 只有页面需要 setData
|
rootVueVM.$nextTick(function () {
|
rootVueVM._initDataToMP();
|
});
|
},
|
|
// 生命周期函数--监听页面初次渲染完成
|
onReady: function onReady() {
|
mp.status = "ready"
|
|
callHook$1(rootVueVM, "onReady")
|
next()
|
},
|
|
// 生命周期函数--监听页面隐藏
|
onHide: function onHide() {
|
mp.status = "hide"
|
callHook$1(rootVueVM, "onHide")
|
},
|
|
// 生命周期函数--监听页面卸载
|
onUnload: function onUnload() {
|
mp.status = "unload"
|
callHook$1(rootVueVM, "onUnload")
|
mp.page = null
|
},
|
|
// 页面相关事件处理函数--监听用户下拉动作
|
onPullDownRefresh: function onPullDownRefresh() {
|
callHook$1(rootVueVM, "onPullDownRefresh")
|
},
|
|
// 页面上拉触底事件的处理函数
|
onReachBottom: function onReachBottom() {
|
callHook$1(rootVueVM, "onReachBottom")
|
},
|
|
// 用户点击右上角分享
|
onShareAppMessage: rootVueVM.$options.onShareAppMessage
|
? function(options) {
|
return callHook$1(rootVueVM, "onShareAppMessage", options)
|
}
|
: null,
|
|
// Do something when page scroll
|
onPageScroll: function onPageScroll(options) {
|
callHook$1(rootVueVM, "onPageScroll", options)
|
},
|
|
// 当前是 tab 页时，点击 tab 时触发
|
onTabItemTap: function onTabItemTap(options) {
|
callHook$1(rootVueVM, "onTabItemTap", options)
|
}
|
})
|
}
|
}
|
|
// 节流方法，性能优化
|
// 全局的命名约定，为了节省编译的包大小一律采取形象的缩写，说明如下。
|
// $c === $child
|
// $k === $comKey
|
|
// 新型的被拍平的数据结构
|
// {
|
// $root: {
|
// '1-1'{
|
// // ... data
|
// },
|
// '1.2-1': {
|
// // ... data1
|
// },
|
// '1.2-2': {
|
// // ... data2
|
// }
|
// }
|
// }
|
|
function getVmData(vm) {
|
// 确保当前 vm 所有数据被同步
|
var dataKeys = [].concat(
|
Object.keys(vm._data || {}),
|
Object.keys(vm._props || {}),
|
Object.keys(vm._mpProps || {}),
|
Object.keys(vm._computedWatchers || {})
|
)
|
return dataKeys.reduce(function(res, key) {
|
res[key] = vm[key]
|
return res
|
}, {})
|
}
|
|
function getParentComKey(vm, res) {
|
if (res === void 0) res = []
|
|
var ref = vm || {}
|
var $parent = ref.$parent
|
if (!$parent) {
|
return res
|
}
|
res.unshift(getComKey($parent))
|
if ($parent.$parent) {
|
return getParentComKey($parent, res)
|
}
|
return res
|
}
|
|
function formatVmData(vm) {
|
var $p = getParentComKey(vm).join(",")
|
var $k = $p + ($p ? "," : "") + getComKey(vm)
|
|
// getVmData 这儿获取当前组件内的所有数据，包含 props、computed 的数据
|
// 改动 vue.runtime 所获的的核心能力
|
var data = Object.assign(getVmData(vm), {
|
$k: $k,
|
$kk: $k + ",",
|
$p: $p
|
})
|
var key = "$root." + $k
|
var res = {}
|
res[key] = data
|
return res
|
}
|
|
function collectVmData(vm, res) {
|
if (res === void 0) res = {}
|
|
var vms = vm.$children
|
if (vms && vms.length) {
|
vms.forEach(function(v) {
|
return collectVmData(v, res)
|
})
|
}
|
return Object.assign(res, formatVmData(vm))
|
}
|
|
/**
|
* 频率控制 返回函数连续调用时，func 执行频率限定为 次 / wait
|
* 自动合并 data
|
*
|
* @param {function} func 传入函数
|
* @param {number} wait 表示时间窗口的间隔
|
* @param {object} options 如果想忽略开始边界上的调用，传入{leading: false}。
|
* 如果想忽略结尾边界上的调用，传入{trailing: false}
|
* @return {function} 返回客户调用函数
|
*/
|
function throttle(func, wait, options) {
|
var context, args, result
|
var timeout = null
|
// 上次执行时间点
|
var previous = 0
|
if (!options) {
|
options = {}
|
}
|
// 延迟执行函数
|
function later() {
|
// 若设定了开始边界不执行选项，上次执行时间始终为0
|
previous = options.leading === false ? 0 : Date.now()
|
timeout = null
|
result = func.apply(context, args)
|
if (!timeout) {
|
context = args = null
|
}
|
}
|
return function(handle, data) {
|
var now = Date.now()
|
// 首次执行时，如果设定了开始边界不执行选项，将上次执行时间设定为当前时间。
|
if (!previous && options.leading === false) {
|
previous = now
|
}
|
// 延迟执行时间间隔
|
var remaining = wait - (now - previous)
|
context = this
|
args = args ? [handle, Object.assign(args[1], data)] : [handle, data]
|
// 延迟时间间隔remaining小于等于0，表示上次执行至此所间隔时间已经超过一个时间窗口
|
// remaining大于时间窗口wait，表示客户端系统时间被调整过
|
if (remaining <= 0 || remaining > wait) {
|
clearTimeout(timeout)
|
timeout = null
|
previous = now
|
result = func.apply(context, args)
|
if (!timeout) {
|
context = args = null
|
}
|
// 如果延迟执行不存在，且没有设定结尾边界不执行选项
|
} else if (!timeout && options.trailing !== false) {
|
timeout = setTimeout(later, remaining)
|
}
|
return result
|
}
|
}
|
|
// 优化频繁的 setData: https://mp.weixin.qq.com/debug/wxadoc/dev/framework/performance/tips.html
|
var throttleSetData = throttle(function(handle, data) {
|
handle && handle(data)
|
}, 50)
|
|
function getPage(vm) {
|
var rootVueVM = vm.$root
|
var ref = rootVueVM.$mp || {}
|
var mpType = ref.mpType
|
if (mpType === void 0) mpType = ""
|
var page = ref.page
|
|
// 优化后台态页面进行 setData: https://mp.weixin.qq.com/debug/wxadoc/dev/framework/performance/tips.html
|
if (mpType === "app" || !page || typeof page.setData !== "function") {
|
return
|
}
|
return page
|
}
|
|
// 优化每次 setData 都传递大量新数据
|
function updateDataToMP() {
|
var page = getPage(this)
|
if (!page) {
|
return
|
}
|
|
var data = JSON.parse(JSON.stringify(formatVmData(this)))
|
//fixed by xxxxxx
|
throttleSetData(page.setData.bind(page), diff(data, page.data))
|
}
|
|
function initDataToMP() {
|
var page = getPage(this)
|
if (!page) {
|
return
|
}
|
|
var data = collectVmData(this.$root)
|
//fixed by xxxxxx
|
page.setData(JSON.parse(JSON.stringify(data)))
|
}
|
|
function getVM(vm, comkeys) {
|
if (comkeys === void 0) comkeys = []
|
|
var keys = comkeys.slice(1)
|
if (!keys.length) {
|
return vm
|
}
|
|
return keys.reduce(function(res, key) {
|
var len = res.$children.length
|
for (var i = 0; i < len; i++) {
|
var v = res.$children[i]
|
var k = getComKey(v)
|
if (k === key) {
|
res = v
|
return res
|
}
|
}
|
return res
|
}, vm)
|
}
|
|
function getHandle(vnode, eventid, eventTypes) {
|
if (eventTypes === void 0) eventTypes = []
|
|
var res = []
|
if (!vnode || !vnode.tag) {
|
return res
|
}
|
|
var ref = vnode || {}
|
var data = ref.data
|
if (data === void 0) data = {}
|
var children = ref.children
|
if (children === void 0) children = []
|
var componentInstance = ref.componentInstance
|
if (componentInstance) {
|
// 增加 slot 情况的处理
|
// Object.values 会多增加几行编译后的代码
|
Object.keys(componentInstance.$slots).forEach(function(slotKey) {
|
var slot = componentInstance.$slots[slotKey]
|
var slots = Array.isArray(slot) ? slot : [slot]
|
slots.forEach(function(node) {
|
res = res.concat(getHandle(node, eventid, eventTypes))
|
})
|
})
|
} else {
|
// 避免遍历超出当前组件的 vm
|
children.forEach(function(node) {
|
res = res.concat(getHandle(node, eventid, eventTypes))
|
})
|
}
|
|
var attrs = data.attrs
|
var on = data.on
|
if (attrs && on && attrs["eventid"] === eventid) {
|
eventTypes.forEach(function(et) {
|
var h = on[et]
|
if (typeof h === "function") {
|
res.push(h)
|
} else if (Array.isArray(h)) {
|
res = res.concat(h)
|
}
|
})
|
return res
|
}
|
|
return res
|
}
|
|
function getWebEventByMP(e) {
|
var type = e.type
|
var timeStamp = e.timeStamp
|
var touches = e.touches
|
var detail = e.detail
|
if (detail === void 0) detail = {}
|
var target = e.target
|
if (target === void 0) target = {}
|
var currentTarget = e.currentTarget
|
if (currentTarget === void 0) currentTarget = {}
|
var x = detail.x
|
var y = detail.y
|
var event = {
|
mp: e,
|
type: type,
|
timeStamp: timeStamp,
|
x: x,
|
y: y,
|
target: Object.assign({}, target, detail),
|
detail: detail, //fixed by xxxxxx
|
currentTarget: currentTarget,
|
stopPropagation: noop,
|
preventDefault: noop
|
}
|
|
if (touches && touches.length) {
|
Object.assign(event, touches[0])
|
event.touches = touches
|
}
|
return event
|
}
|
|
function handleProxyWithVue(e) {
|
var rootVueVM = this.$root
|
var type = e.type
|
var target = e.target
|
if (target === void 0) target = {}
|
var currentTarget = e.currentTarget
|
var ref = currentTarget || target
|
var dataset = ref.dataset
|
if (dataset === void 0) dataset = {}
|
var comkey = dataset.comkey
|
if (comkey === void 0) comkey = ""
|
var eventid = dataset.eventid
|
var vm = getVM(rootVueVM, comkey.split(","))
|
|
if (!vm) {
|
return
|
}
|
|
var webEventTypes = eventTypeMap[type] || [type]
|
var handles = getHandle(vm._vnode, eventid, webEventTypes)
|
|
// TODO, enevt 还需要处理更多
|
// https://developer.mozilla.org/zh-CN/docs/Web/API/Event
|
if (handles.length) {
|
var event = getWebEventByMP(e)
|
if (handles.length === 1) {
|
var result = handles[0](event)
|
return result
|
}
|
handles.forEach(function(h) {
|
return h(event)
|
})
|
}
|
}
|
|
// for platforms
|
// import config from 'core/config'
|
// install platform specific utils
|
Vue$3.config.mustUseProp = mustUseProp
|
Vue$3.config.isReservedTag = isReservedTag
|
Vue$3.config.isReservedAttr = isReservedAttr
|
Vue$3.config.getTagNamespace = getTagNamespace
|
Vue$3.config.isUnknownElement = isUnknownElement
|
|
// install platform patch function
|
Vue$3.prototype.__patch__ = patch
|
|
// public mount method
|
Vue$3.prototype.$mount = function(el, hydrating) {
|
var this$1 = this
|
|
// el = el && inBrowser ? query(el) : undefined
|
// return mountComponent(this, el, hydrating)
|
|
// 初始化小程序生命周期相关
|
var options = this.$options
|
|
if (options && (options.render || options.mpType)) {
|
var mpType = options.mpType
|
if (mpType === void 0) mpType = "page"
|
return this._initMP(mpType, function() {
|
return mountComponent(this$1, undefined, undefined)
|
})
|
} else {
|
return mountComponent(this, undefined, undefined)
|
}
|
}
|
|
// for mp
|
Vue$3.prototype._initMP = initMP
|
|
Vue$3.prototype.$updateDataToMP = updateDataToMP
|
Vue$3.prototype._initDataToMP = initDataToMP
|
|
Vue$3.prototype.$handleProxyWithVue = handleProxyWithVue
|
|
/* */
|
|
return Vue$3
|
})
|
