You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10733 lines
272 KiB
10733 lines
272 KiB
/*! |
|
* Vue.js v2.5.8 |
|
* (c) 2014-2017 Evan You |
|
* Released under the MIT License. |
|
*/ |
|
/* */ |
|
|
|
const emptyObject = Object.freeze({}); |
|
|
|
// 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' || |
|
typeof value === 'boolean' |
|
) |
|
} |
|
|
|
/** |
|
* 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' |
|
} |
|
|
|
/** |
|
* Get the raw type string of a value e.g. [object Object] |
|
*/ |
|
const _toString = Object.prototype.toString; |
|
|
|
function toRawType (value) { |
|
return _toString.call(value).slice(8, -1) |
|
} |
|
|
|
/** |
|
* 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) { |
|
const n = parseFloat(String(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) { |
|
const 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 |
|
) { |
|
const map = Object.create(null); |
|
const list = str.split(','); |
|
for (let i = 0; i < list.length; i++) { |
|
map[list[i]] = true; |
|
} |
|
return expectsLowerCase |
|
? val => map[val.toLowerCase()] |
|
: val => map[val] |
|
} |
|
|
|
/** |
|
* Check if a tag is a built-in tag. |
|
*/ |
|
const isBuiltInTag = makeMap('slot,component', true); |
|
|
|
/** |
|
* Check if a attribute is a reserved attribute. |
|
*/ |
|
const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); |
|
|
|
/** |
|
* Remove an item from an array |
|
*/ |
|
function remove (arr, item) { |
|
if (arr.length) { |
|
const index = arr.indexOf(item); |
|
if (index > -1) { |
|
return arr.splice(index, 1) |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Check whether the object has the property. |
|
*/ |
|
const hasOwnProperty = Object.prototype.hasOwnProperty; |
|
function hasOwn (obj, key) { |
|
return hasOwnProperty.call(obj, key) |
|
} |
|
|
|
/** |
|
* Create a cached version of a pure function. |
|
*/ |
|
function cached (fn) { |
|
const cache = Object.create(null); |
|
return (function cachedFn (str) { |
|
const hit = cache[str]; |
|
return hit || (cache[str] = fn(str)) |
|
}) |
|
} |
|
|
|
/** |
|
* Camelize a hyphen-delimited string. |
|
*/ |
|
const camelizeRE = /-(\w)/g; |
|
const camelize = cached((str) => { |
|
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '') |
|
}); |
|
|
|
/** |
|
* Capitalize a string. |
|
*/ |
|
const capitalize = cached((str) => { |
|
return str.charAt(0).toUpperCase() + str.slice(1) |
|
}); |
|
|
|
/** |
|
* Hyphenate a camelCase string. |
|
*/ |
|
const hyphenateRE = /\B([A-Z])/g; |
|
const hyphenate = cached((str) => { |
|
return str.replace(hyphenateRE, '-$1').toLowerCase() |
|
}); |
|
|
|
/** |
|
* Simple bind, faster than native |
|
*/ |
|
function bind (fn, ctx) { |
|
function boundFn (a) { |
|
const 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; |
|
let i = list.length - start; |
|
const ret = new Array(i); |
|
while (i--) { |
|
ret[i] = list[i + start]; |
|
} |
|
return ret |
|
} |
|
|
|
/** |
|
* Mix properties into target object. |
|
*/ |
|
function extend (to, _from) { |
|
for (const key in _from) { |
|
to[key] = _from[key]; |
|
} |
|
return to |
|
} |
|
|
|
/** |
|
* Merge an Array of Objects into a single Object. |
|
*/ |
|
function toObject (arr) { |
|
const res = {}; |
|
for (let 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. |
|
*/ |
|
const no = (a, b, c) => false; |
|
|
|
/** |
|
* Return same value |
|
*/ |
|
const identity = (_) => _; |
|
|
|
/** |
|
* Generate a static keys string from compiler modules. |
|
*/ |
|
function genStaticKeys (modules) { |
|
return modules.reduce((keys, m) => { |
|
return keys.concat(m.staticKeys || []) |
|
}, []).join(',') |
|
} |
|
|
|
/** |
|
* Check if two values are loosely equal - that is, |
|
* if they are plain objects, do they have the same shape? |
|
*/ |
|
function looseEqual (a, b) { |
|
if (a === b) return true |
|
const isObjectA = isObject(a); |
|
const isObjectB = isObject(b); |
|
if (isObjectA && isObjectB) { |
|
try { |
|
const isArrayA = Array.isArray(a); |
|
const isArrayB = Array.isArray(b); |
|
if (isArrayA && isArrayB) { |
|
return a.length === b.length && a.every((e, i) => { |
|
return looseEqual(e, b[i]) |
|
}) |
|
} else if (!isArrayA && !isArrayB) { |
|
const keysA = Object.keys(a); |
|
const keysB = Object.keys(b); |
|
return keysA.length === keysB.length && keysA.every(key => { |
|
return looseEqual(a[key], b[key]) |
|
}) |
|
} else { |
|
/* istanbul ignore next */ |
|
return false |
|
} |
|
} catch (e) { |
|
/* istanbul ignore next */ |
|
return false |
|
} |
|
} else if (!isObjectA && !isObjectB) { |
|
return String(a) === String(b) |
|
} else { |
|
return false |
|
} |
|
} |
|
|
|
function looseIndexOf (arr, val) { |
|
for (let 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) { |
|
let called = false; |
|
return function () { |
|
if (!called) { |
|
called = true; |
|
fn.apply(this, arguments); |
|
} |
|
} |
|
} |
|
|
|
const SSR_ATTR = 'data-server-rendered'; |
|
|
|
const ASSET_TYPES = [ |
|
'component', |
|
'directive', |
|
'filter' |
|
]; |
|
|
|
const LIFECYCLE_HOOKS = [ |
|
'beforeCreate', |
|
'created', |
|
'beforeMount', |
|
'mounted', |
|
'beforeUpdate', |
|
'updated', |
|
'beforeDestroy', |
|
'destroyed', |
|
'activated', |
|
'deactivated', |
|
'errorCaptured' |
|
]; |
|
|
|
/* */ |
|
|
|
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: "development" !== 'production', |
|
|
|
/** |
|
* Whether to enable devtools |
|
*/ |
|
devtools: "development" !== '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 |
|
}); |
|
|
|
/* */ |
|
|
|
/** |
|
* Check if a string starts with $ or _ |
|
*/ |
|
function isReserved (str) { |
|
const 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. |
|
*/ |
|
const bailRE = /[^\w.$]/; |
|
function parsePath (path) { |
|
if (bailRE.test(path)) { |
|
return |
|
} |
|
const segments = path.split('.'); |
|
return function (obj) { |
|
for (let i = 0; i < segments.length; i++) { |
|
if (!obj) return |
|
obj = obj[segments[i]]; |
|
} |
|
return obj |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
|
|
// can we use __proto__? |
|
const hasProto = '__proto__' in {}; |
|
|
|
// Browser environment sniffing |
|
const inBrowser = typeof window !== 'undefined'; |
|
const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform; |
|
const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase(); |
|
const UA = inBrowser && window.navigator.userAgent.toLowerCase(); |
|
const isIE = UA && /msie|trident/.test(UA); |
|
const isIE9 = UA && UA.indexOf('msie 9.0') > 0; |
|
const isEdge = UA && UA.indexOf('edge/') > 0; |
|
const isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android'); |
|
const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios'); |
|
const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge; |
|
|
|
// Firefox has a "watch" function on Object.prototype... |
|
const nativeWatch = ({}).watch; |
|
|
|
let supportsPassive = false; |
|
if (inBrowser) { |
|
try { |
|
const opts = {}; |
|
Object.defineProperty(opts, 'passive', ({ |
|
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 |
|
let _isServer; |
|
const isServerRendering = () => { |
|
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 |
|
const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; |
|
|
|
/* istanbul ignore next */ |
|
function isNative (Ctor) { |
|
return typeof Ctor === 'function' && /native code/.test(Ctor.toString()) |
|
} |
|
|
|
const hasSymbol = |
|
typeof Symbol !== 'undefined' && isNative(Symbol) && |
|
typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys); |
|
|
|
let _Set; |
|
/* istanbul ignore if */ // $flow-disable-line |
|
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 = class Set { |
|
|
|
constructor () { |
|
this.set = Object.create(null); |
|
} |
|
has (key) { |
|
return this.set[key] === true |
|
} |
|
add (key) { |
|
this.set[key] = true; |
|
} |
|
clear () { |
|
this.set = Object.create(null); |
|
} |
|
}; |
|
} |
|
|
|
/* */ |
|
|
|
let warn = noop; |
|
let tip = noop; |
|
let generateComponentTrace = (noop); // work around flow check |
|
let formatComponentName = (noop); |
|
|
|
{ |
|
const hasConsole = typeof console !== 'undefined'; |
|
const classifyRE = /(?:^|[-_])(\w)/g; |
|
const classify = str => str |
|
.replace(classifyRE, c => c.toUpperCase()) |
|
.replace(/[-_]/g, ''); |
|
|
|
warn = (msg, vm) => { |
|
const trace = vm ? generateComponentTrace(vm) : ''; |
|
|
|
if (config.warnHandler) { |
|
config.warnHandler.call(null, msg, vm, trace); |
|
} else if (hasConsole && (!config.silent)) { |
|
console.error(`[Vue warn]: ${msg}${trace}`); |
|
} |
|
}; |
|
|
|
tip = (msg, vm) => { |
|
if (hasConsole && (!config.silent)) { |
|
console.warn(`[Vue tip]: ${msg}` + ( |
|
vm ? generateComponentTrace(vm) : '' |
|
)); |
|
} |
|
}; |
|
|
|
formatComponentName = (vm, includeFile) => { |
|
if (vm.$root === vm) { |
|
return '<Root>' |
|
} |
|
const options = typeof vm === 'function' && vm.cid != null |
|
? vm.options |
|
: vm._isVue |
|
? vm.$options || vm.constructor.options |
|
: vm || {}; |
|
let name = options.name || options._componentTag; |
|
const file = options.__file; |
|
if (!name && file) { |
|
const match = file.match(/([^/\\]+)\.vue$/); |
|
name = match && match[1]; |
|
} |
|
|
|
return ( |
|
(name ? `<${classify(name)}>` : `<Anonymous>`) + |
|
(file && includeFile !== false ? ` at ${file}` : '') |
|
) |
|
}; |
|
|
|
const repeat = (str, n) => { |
|
let res = ''; |
|
while (n) { |
|
if (n % 2 === 1) res += str; |
|
if (n > 1) str += str; |
|
n >>= 1; |
|
} |
|
return res |
|
}; |
|
|
|
generateComponentTrace = vm => { |
|
if (vm._isVue && vm.$parent) { |
|
const tree = []; |
|
let currentRecursiveSequence = 0; |
|
while (vm) { |
|
if (tree.length > 0) { |
|
const last = tree[tree.length - 1]; |
|
if (last.constructor === vm.constructor) { |
|
currentRecursiveSequence++; |
|
vm = vm.$parent; |
|
continue |
|
} else if (currentRecursiveSequence > 0) { |
|
tree[tree.length - 1] = [last, currentRecursiveSequence]; |
|
currentRecursiveSequence = 0; |
|
} |
|
} |
|
tree.push(vm); |
|
vm = vm.$parent; |
|
} |
|
return '\n\nfound in\n\n' + tree |
|
.map((vm, i) => `${ |
|
i === 0 ? '---> ' : repeat(' ', 5 + i * 2) |
|
}${ |
|
Array.isArray(vm) |
|
? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)` |
|
: formatComponentName(vm) |
|
}`) |
|
.join('\n') |
|
} else { |
|
return `\n\n(found in ${formatComponentName(vm)})` |
|
} |
|
}; |
|
} |
|
|
|
/* */ |
|
|
|
|
|
let uid = 0; |
|
|
|
/** |
|
* A dep is an observable that can have multiple |
|
* directives subscribing to it. |
|
*/ |
|
class Dep { |
|
|
|
|
|
|
|
|
|
constructor () { |
|
this.id = uid++; |
|
this.subs = []; |
|
} |
|
|
|
addSub (sub) { |
|
this.subs.push(sub); |
|
} |
|
|
|
removeSub (sub) { |
|
remove(this.subs, sub); |
|
} |
|
|
|
depend () { |
|
if (Dep.target) { |
|
Dep.target.addDep(this); |
|
} |
|
} |
|
|
|
notify () { |
|
// stabilize the subscriber list first |
|
const subs = this.subs.slice(); |
|
for (let 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; |
|
const targetStack = []; |
|
|
|
function pushTarget (_target) { |
|
if (Dep.target) targetStack.push(Dep.target); |
|
Dep.target = _target; |
|
} |
|
|
|
function popTarget () { |
|
Dep.target = targetStack.pop(); |
|
} |
|
|
|
/* */ |
|
|
|
class VNode { |
|
|
|
|
|
|
|
|
|
|
|
|
|
// rendered in this component's scope |
|
|
|
|
|
// component instance |
|
// component placeholder node |
|
|
|
// strictly internal |
|
// contains raw HTML? (server only) |
|
// hoisted static node |
|
// necessary for enter transition check |
|
// empty comment placeholder? |
|
// is a cloned node? |
|
// is a v-once node? |
|
// async component factory function |
|
|
|
|
|
|
|
// real context vm for functional nodes |
|
// for SSR caching |
|
// functioanl scope id support |
|
|
|
constructor ( |
|
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.functionalOptions = undefined; |
|
this.functionalScopeId = 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; |
|
} |
|
|
|
// DEPRECATED: alias for componentInstance for backwards compat. |
|
/* istanbul ignore next */ |
|
get child () { |
|
return this.componentInstance |
|
} |
|
} |
|
|
|
const createEmptyVNode = (text = '') => { |
|
const 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, deep) { |
|
const componentOptions = vnode.componentOptions; |
|
const cloned = new VNode( |
|
vnode.tag, |
|
vnode.data, |
|
vnode.children, |
|
vnode.text, |
|
vnode.elm, |
|
vnode.context, |
|
componentOptions, |
|
vnode.asyncFactory |
|
); |
|
cloned.ns = vnode.ns; |
|
cloned.isStatic = vnode.isStatic; |
|
cloned.key = vnode.key; |
|
cloned.isComment = vnode.isComment; |
|
cloned.isCloned = true; |
|
if (deep) { |
|
if (vnode.children) { |
|
cloned.children = cloneVNodes(vnode.children, true); |
|
} |
|
if (componentOptions && componentOptions.children) { |
|
componentOptions.children = cloneVNodes(componentOptions.children, true); |
|
} |
|
} |
|
return cloned |
|
} |
|
|
|
function cloneVNodes (vnodes, deep) { |
|
const len = vnodes.length; |
|
const res = new Array(len); |
|
for (let i = 0; i < len; i++) { |
|
res[i] = cloneVNode(vnodes[i], deep); |
|
} |
|
return res |
|
} |
|
|
|
/* |
|
* not type checking this file because flow doesn't play well with |
|
* dynamically accessing methods on Array prototype |
|
*/ |
|
|
|
const arrayProto = Array.prototype; |
|
const arrayMethods = Object.create(arrayProto);[ |
|
'push', |
|
'pop', |
|
'shift', |
|
'unshift', |
|
'splice', |
|
'sort', |
|
'reverse' |
|
] |
|
.forEach(function (method) { |
|
// cache original method |
|
const original = arrayProto[method]; |
|
def(arrayMethods, method, function mutator (...args) { |
|
const result = original.apply(this, args); |
|
const ob = this.__ob__; |
|
let 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 |
|
}); |
|
}); |
|
|
|
/* */ |
|
|
|
const 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. |
|
*/ |
|
const 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. |
|
*/ |
|
class Observer { |
|
|
|
|
|
// number of vms that has this object as root $data |
|
|
|
constructor (value) { |
|
this.value = value; |
|
this.dep = new Dep(); |
|
this.vmCount = 0; |
|
def(value, '__ob__', this); |
|
if (Array.isArray(value)) { |
|
const 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. |
|
*/ |
|
walk (obj) { |
|
const keys = Object.keys(obj); |
|
for (let i = 0; i < keys.length; i++) { |
|
defineReactive(obj, keys[i], obj[keys[i]]); |
|
} |
|
} |
|
|
|
/** |
|
* Observe a list of Array items. |
|
*/ |
|
observeArray (items) { |
|
for (let 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 (let i = 0, l = keys.length; i < l; i++) { |
|
const 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) || value instanceof VNode) { |
|
return |
|
} |
|
let 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 ( |
|
obj, |
|
key, |
|
val, |
|
customSetter, |
|
shallow |
|
) { |
|
const dep = new Dep(); |
|
|
|
const property = Object.getOwnPropertyDescriptor(obj, key); |
|
if (property && property.configurable === false) { |
|
return |
|
} |
|
|
|
// cater for pre-defined getter/setters |
|
const getter = property && property.get; |
|
const setter = property && property.set; |
|
|
|
let childOb = !shallow && observe(val); |
|
Object.defineProperty(obj, key, { |
|
enumerable: true, |
|
configurable: true, |
|
get: function reactiveGetter () { |
|
const 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) { |
|
const 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 ("development" !== '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 (key in target && !(key in Object.prototype)) { |
|
target[key] = val; |
|
return val |
|
} |
|
const ob = (target).__ob__; |
|
if (target._isVue || (ob && ob.vmCount)) { |
|
"development" !== '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(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 |
|
} |
|
const ob = (target).__ob__; |
|
if (target._isVue || (ob && ob.vmCount)) { |
|
"development" !== '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 (let e, 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. |
|
*/ |
|
const strats = config.optionMergeStrategies; |
|
|
|
/** |
|
* Options with restrictions |
|
*/ |
|
{ |
|
strats.el = strats.propsData = function (parent, child, vm, key) { |
|
if (!vm) { |
|
warn( |
|
`option "${key}" can only be used during instance ` + |
|
'creation with the `new` keyword.' |
|
); |
|
} |
|
return defaultStrat(parent, child) |
|
}; |
|
} |
|
|
|
/** |
|
* Helper that recursively merges two data objects together. |
|
*/ |
|
function mergeData (to, from) { |
|
if (!from) return to |
|
let key, toVal, fromVal; |
|
const keys = Object.keys(from); |
|
for (let 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, |
|
typeof parentVal === 'function' ? parentVal.call(this) : parentVal |
|
) |
|
} |
|
} else { |
|
return function mergedInstanceDataFn () { |
|
// instance merge |
|
const instanceData = typeof childVal === 'function' |
|
? childVal.call(vm) |
|
: childVal; |
|
const defaultData = typeof parentVal === 'function' |
|
? parentVal.call(vm) |
|
: parentVal; |
|
if (instanceData) { |
|
return mergeData(instanceData, defaultData) |
|
} else { |
|
return defaultData |
|
} |
|
} |
|
} |
|
} |
|
|
|
strats.data = function ( |
|
parentVal, |
|
childVal, |
|
vm |
|
) { |
|
if (!vm) { |
|
if (childVal && typeof childVal !== 'function') { |
|
"development" !== 'production' && warn( |
|
'The "data" option should be a function ' + |
|
'that returns a per-instance value in component ' + |
|
'definitions.', |
|
vm |
|
); |
|
|
|
return parentVal |
|
} |
|
return mergeDataOrFn(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(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, |
|
vm, |
|
key |
|
) { |
|
const res = Object.create(parentVal || null); |
|
if (childVal) { |
|
"development" !== 'production' && assertObjectType(key, childVal, vm); |
|
return extend(res, childVal) |
|
} else { |
|
return 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, |
|
vm, |
|
key |
|
) { |
|
// 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) |
|
{ |
|
assertObjectType(key, childVal, vm); |
|
} |
|
if (!parentVal) return childVal |
|
const ret = {}; |
|
extend(ret, parentVal); |
|
for (const key in childVal) { |
|
let parent = ret[key]; |
|
const 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, |
|
vm, |
|
key |
|
) { |
|
if (childVal && "development" !== 'production') { |
|
assertObjectType(key, childVal, vm); |
|
} |
|
if (!parentVal) return childVal |
|
const ret = Object.create(null); |
|
extend(ret, parentVal); |
|
if (childVal) extend(ret, childVal); |
|
return ret |
|
}; |
|
strats.provide = mergeDataOrFn; |
|
|
|
/** |
|
* Default strategy. |
|
*/ |
|
const defaultStrat = function (parentVal, childVal) { |
|
return childVal === undefined |
|
? parentVal |
|
: childVal |
|
}; |
|
|
|
/** |
|
* Validate component names |
|
*/ |
|
function checkComponents (options) { |
|
for (const key in options.components) { |
|
const lower = key.toLowerCase(); |
|
if (isBuiltInTag(lower) || config.isReservedTag(lower)) { |
|
warn( |
|
'Do not use built-in or reserved HTML elements as component ' + |
|
'id: ' + key |
|
); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Ensure all props option syntax are normalized into the |
|
* Object-based format. |
|
*/ |
|
function normalizeProps (options, vm) { |
|
const props = options.props; |
|
if (!props) return |
|
const res = {}; |
|
let 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 { |
|
warn('props must be strings when using array syntax.'); |
|
} |
|
} |
|
} else if (isPlainObject(props)) { |
|
for (const key in props) { |
|
val = props[key]; |
|
name = camelize(key); |
|
res[name] = isPlainObject(val) |
|
? val |
|
: { type: val }; |
|
} |
|
} else { |
|
warn( |
|
`Invalid value for option "props": expected an Array or an Object, ` + |
|
`but got ${toRawType(props)}.`, |
|
vm |
|
); |
|
} |
|
options.props = res; |
|
} |
|
|
|
/** |
|
* Normalize all injections into Object-based format |
|
*/ |
|
function normalizeInject (options, vm) { |
|
const inject = options.inject; |
|
const normalized = options.inject = {}; |
|
if (Array.isArray(inject)) { |
|
for (let i = 0; i < inject.length; i++) { |
|
normalized[inject[i]] = { from: inject[i] }; |
|
} |
|
} else if (isPlainObject(inject)) { |
|
for (const key in inject) { |
|
const val = inject[key]; |
|
normalized[key] = isPlainObject(val) |
|
? extend({ from: key }, val) |
|
: { from: val }; |
|
} |
|
} else if ("development" !== 'production' && inject) { |
|
warn( |
|
`Invalid value for option "inject": expected an Array or an Object, ` + |
|
`but got ${toRawType(inject)}.`, |
|
vm |
|
); |
|
} |
|
} |
|
|
|
/** |
|
* Normalize raw function directives into object format. |
|
*/ |
|
function normalizeDirectives (options) { |
|
const dirs = options.directives; |
|
if (dirs) { |
|
for (const key in dirs) { |
|
const def = dirs[key]; |
|
if (typeof def === 'function') { |
|
dirs[key] = { bind: def, update: def }; |
|
} |
|
} |
|
} |
|
} |
|
|
|
function assertObjectType (name, value, vm) { |
|
if (!isPlainObject(value)) { |
|
warn( |
|
`Invalid value for option "${name}": expected an Object, ` + |
|
`but got ${toRawType(value)}.`, |
|
vm |
|
); |
|
} |
|
} |
|
|
|
/** |
|
* Merge two option objects into a new one. |
|
* Core utility used in both instantiation and inheritance. |
|
*/ |
|
function mergeOptions ( |
|
parent, |
|
child, |
|
vm |
|
) { |
|
{ |
|
checkComponents(child); |
|
} |
|
|
|
if (typeof child === 'function') { |
|
child = child.options; |
|
} |
|
|
|
normalizeProps(child, vm); |
|
normalizeInject(child, vm); |
|
normalizeDirectives(child); |
|
const extendsFrom = child.extends; |
|
if (extendsFrom) { |
|
parent = mergeOptions(parent, extendsFrom, vm); |
|
} |
|
if (child.mixins) { |
|
for (let i = 0, l = child.mixins.length; i < l; i++) { |
|
parent = mergeOptions(parent, child.mixins[i], vm); |
|
} |
|
} |
|
const options = {}; |
|
let key; |
|
for (key in parent) { |
|
mergeField(key); |
|
} |
|
for (key in child) { |
|
if (!hasOwn(parent, key)) { |
|
mergeField(key); |
|
} |
|
} |
|
function mergeField (key) { |
|
const 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 |
|
} |
|
const assets = options[type]; |
|
// check local registration variations first |
|
if (hasOwn(assets, id)) return assets[id] |
|
const camelizedId = camelize(id); |
|
if (hasOwn(assets, camelizedId)) return assets[camelizedId] |
|
const PascalCaseId = capitalize(camelizedId); |
|
if (hasOwn(assets, PascalCaseId)) return assets[PascalCaseId] |
|
// fallback to prototype chain |
|
const res = assets[id] || assets[camelizedId] || assets[PascalCaseId]; |
|
if ("development" !== 'production' && warnMissing && !res) { |
|
warn( |
|
'Failed to resolve ' + type.slice(0, -1) + ': ' + id, |
|
options |
|
); |
|
} |
|
return res |
|
} |
|
|
|
/* */ |
|
|
|
function validateProp ( |
|
key, |
|
propOptions, |
|
propsData, |
|
vm |
|
) { |
|
const prop = propOptions[key]; |
|
const absent = !hasOwn(propsData, key); |
|
let 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. |
|
const prevShouldConvert = observerState.shouldConvert; |
|
observerState.shouldConvert = true; |
|
observe(value); |
|
observerState.shouldConvert = prevShouldConvert; |
|
} |
|
{ |
|
assertProp(prop, key, value, vm, absent); |
|
} |
|
return value |
|
} |
|
|
|
/** |
|
* Get the default value of a prop. |
|
*/ |
|
function getPropDefaultValue (vm, prop, key) { |
|
// no default, return undefined |
|
if (!hasOwn(prop, 'default')) { |
|
return undefined |
|
} |
|
const def = prop.default; |
|
// warn against non-factory defaults for Object & Array |
|
if ("development" !== '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 |
|
} |
|
|
|
/** |
|
* Assert whether a prop is valid. |
|
*/ |
|
function assertProp ( |
|
prop, |
|
name, |
|
value, |
|
vm, |
|
absent |
|
) { |
|
if (prop.required && absent) { |
|
warn( |
|
'Missing required prop: "' + name + '"', |
|
vm |
|
); |
|
return |
|
} |
|
if (value == null && !prop.required) { |
|
return |
|
} |
|
let type = prop.type; |
|
let valid = !type || type === true; |
|
const expectedTypes = []; |
|
if (type) { |
|
if (!Array.isArray(type)) { |
|
type = [type]; |
|
} |
|
for (let i = 0; i < type.length && !valid; i++) { |
|
const assertedType = assertType(value, type[i]); |
|
expectedTypes.push(assertedType.expectedType || ''); |
|
valid = assertedType.valid; |
|
} |
|
} |
|
if (!valid) { |
|
warn( |
|
`Invalid prop: type check failed for prop "${name}".` + |
|
` Expected ${expectedTypes.map(capitalize).join(', ')}` + |
|
`, got ${toRawType(value)}.`, |
|
vm |
|
); |
|
return |
|
} |
|
const validator = prop.validator; |
|
if (validator) { |
|
if (!validator(value)) { |
|
warn( |
|
'Invalid prop: custom validator check failed for prop "' + name + '".', |
|
vm |
|
); |
|
} |
|
} |
|
} |
|
|
|
const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/; |
|
|
|
function assertType (value, type) { |
|
let valid; |
|
const expectedType = getType(type); |
|
if (simpleCheckRE.test(expectedType)) { |
|
const t = typeof value; |
|
valid = t === expectedType.toLowerCase(); |
|
// for primitive wrapper objects |
|
if (!valid && t === 'object') { |
|
valid = value instanceof type; |
|
} |
|
} else if (expectedType === 'Object') { |
|
valid = isPlainObject(value); |
|
} else if (expectedType === 'Array') { |
|
valid = Array.isArray(value); |
|
} else { |
|
valid = value instanceof type; |
|
} |
|
return { |
|
valid, |
|
expectedType |
|
} |
|
} |
|
|
|
/** |
|
* 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) { |
|
const 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 (let i = 0, len = fn.length; i < len; i++) { |
|
if (getType(fn[i]) === getType(type)) { |
|
return true |
|
} |
|
} |
|
/* istanbul ignore next */ |
|
return false |
|
} |
|
|
|
/* */ |
|
|
|
function handleError (err, vm, info) { |
|
if (vm) { |
|
let cur = vm; |
|
while ((cur = cur.$parent)) { |
|
const hooks = cur.$options.errorCaptured; |
|
if (hooks) { |
|
for (let i = 0; i < hooks.length; i++) { |
|
try { |
|
const capture = hooks[i].call(cur, err, vm, info) === false; |
|
if (capture) return |
|
} catch (e) { |
|
globalHandleError(e, cur, 'errorCaptured hook'); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
globalHandleError(err, vm, info); |
|
} |
|
|
|
function globalHandleError (err, vm, info) { |
|
if (config.errorHandler) { |
|
try { |
|
return config.errorHandler.call(null, err, vm, info) |
|
} catch (e) { |
|
logError(e, null, 'config.errorHandler'); |
|
} |
|
} |
|
logError(err, vm, info); |
|
} |
|
|
|
function logError (err, vm, info) { |
|
{ |
|
warn(`Error in ${info}: "${err.toString()}"`, vm); |
|
} |
|
/* istanbul ignore else */ |
|
if ((inBrowser || inWeex) && typeof console !== 'undefined') { |
|
console.error(err); |
|
} else { |
|
throw err |
|
} |
|
} |
|
|
|
/* */ |
|
/* globals MessageChannel */ |
|
|
|
const callbacks = []; |
|
let pending = false; |
|
|
|
function flushCallbacks () { |
|
pending = false; |
|
const copies = callbacks.slice(0); |
|
callbacks.length = 0; |
|
for (let i = 0; i < copies.length; i++) { |
|
copies[i](); |
|
} |
|
} |
|
|
|
// Here we have async deferring wrappers using both micro and macro tasks. |
|
// In < 2.4 we used micro tasks everywhere, but there are some scenarios where |
|
// micro tasks have too high a priority and fires in between supposedly |
|
// sequential events (e.g. #4521, #6690) or even between bubbling of the same |
|
// event (#6566). However, using macro tasks everywhere also has subtle problems |
|
// when state is changed right before repaint (e.g. #6813, out-in transitions). |
|
// Here we use micro task by default, but expose a way to force macro task when |
|
// needed (e.g. in event handlers attached by v-on). |
|
let microTimerFunc; |
|
let macroTimerFunc; |
|
let useMacroTask = false; |
|
|
|
// Determine (macro) Task defer implementation. |
|
// Technically setImmediate should be the ideal choice, but it's only available |
|
// in IE. The only polyfill that consistently queues the callback after all DOM |
|
// events triggered in the same loop is by using MessageChannel. |
|
/* istanbul ignore if */ |
|
if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) { |
|
macroTimerFunc = () => { |
|
setImmediate(flushCallbacks); |
|
}; |
|
} else if (typeof MessageChannel !== 'undefined' && ( |
|
isNative(MessageChannel) || |
|
// PhantomJS |
|
MessageChannel.toString() === '[object MessageChannelConstructor]' |
|
)) { |
|
const channel = new MessageChannel(); |
|
const port = channel.port2; |
|
channel.port1.onmessage = flushCallbacks; |
|
macroTimerFunc = () => { |
|
port.postMessage(1); |
|
}; |
|
} else { |
|
/* istanbul ignore next */ |
|
macroTimerFunc = () => { |
|
setTimeout(flushCallbacks, 0); |
|
}; |
|
} |
|
|
|
// Determine MicroTask defer implementation. |
|
/* istanbul ignore next, $flow-disable-line */ |
|
if (typeof Promise !== 'undefined' && isNative(Promise)) { |
|
const p = Promise.resolve(); |
|
microTimerFunc = () => { |
|
p.then(flushCallbacks); |
|
// 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 { |
|
// fallback to macro |
|
microTimerFunc = macroTimerFunc; |
|
} |
|
|
|
/** |
|
* Wrap a function so that if any code inside triggers state change, |
|
* the changes are queued using a Task instead of a MicroTask. |
|
*/ |
|
function withMacroTask (fn) { |
|
return fn._withTask || (fn._withTask = function () { |
|
useMacroTask = true; |
|
const res = fn.apply(null, arguments); |
|
useMacroTask = false; |
|
return res |
|
}) |
|
} |
|
|
|
function nextTick (cb, ctx) { |
|
let _resolve; |
|
callbacks.push(() => { |
|
if (cb) { |
|
try { |
|
cb.call(ctx); |
|
} catch (e) { |
|
handleError(e, ctx, 'nextTick'); |
|
} |
|
} else if (_resolve) { |
|
_resolve(ctx); |
|
} |
|
}); |
|
if (!pending) { |
|
pending = true; |
|
if (useMacroTask) { |
|
macroTimerFunc(); |
|
} else { |
|
microTimerFunc(); |
|
} |
|
} |
|
// $flow-disable-line |
|
if (!cb && typeof Promise !== 'undefined') { |
|
return new Promise(resolve => { |
|
_resolve = resolve; |
|
}) |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
let mark; |
|
let measure; |
|
|
|
{ |
|
const perf = inBrowser && window.performance; |
|
/* istanbul ignore if */ |
|
if ( |
|
perf && |
|
perf.mark && |
|
perf.measure && |
|
perf.clearMarks && |
|
perf.clearMeasures |
|
) { |
|
mark = tag => perf.mark(tag); |
|
measure = (name, startTag, endTag) => { |
|
perf.measure(name, startTag, endTag); |
|
perf.clearMarks(startTag); |
|
perf.clearMarks(endTag); |
|
perf.clearMeasures(name); |
|
}; |
|
} |
|
} |
|
|
|
/* not type checking this file because flow doesn't play well with Proxy */ |
|
|
|
let initProxy; |
|
|
|
{ |
|
const allowedGlobals = makeMap( |
|
'Infinity,undefined,NaN,isFinite,isNaN,' + |
|
'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + |
|
'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' + |
|
'require' // for Webpack/Browserify |
|
); |
|
|
|
const warnNonPresent = (target, key) => { |
|
warn( |
|
`Property or method "${key}" is not defined on the instance but ` + |
|
'referenced during render. Make sure that this property is reactive, ' + |
|
'either in the data option, or for class-based components, by ' + |
|
'initializing the property. ' + |
|
'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', |
|
target |
|
); |
|
}; |
|
|
|
const hasProxy = |
|
typeof Proxy !== 'undefined' && |
|
Proxy.toString().match(/native code/); |
|
|
|
if (hasProxy) { |
|
const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact'); |
|
config.keyCodes = new Proxy(config.keyCodes, { |
|
set (target, key, value) { |
|
if (isBuiltInModifier(key)) { |
|
warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`); |
|
return false |
|
} else { |
|
target[key] = value; |
|
return true |
|
} |
|
} |
|
}); |
|
} |
|
|
|
const hasHandler = { |
|
has (target, key) { |
|
const has = key in target; |
|
const isAllowed = allowedGlobals(key) || key.charAt(0) === '_'; |
|
if (!has && !isAllowed) { |
|
warnNonPresent(target, key); |
|
} |
|
return has || !isAllowed |
|
} |
|
}; |
|
|
|
const getHandler = { |
|
get (target, key) { |
|
if (typeof key === 'string' && !(key in target)) { |
|
warnNonPresent(target, key); |
|
} |
|
return target[key] |
|
} |
|
}; |
|
|
|
initProxy = function initProxy (vm) { |
|
if (hasProxy) { |
|
// determine which proxy handler to use |
|
const options = vm.$options; |
|
const handlers = options.render && options.render._withStripped |
|
? getHandler |
|
: hasHandler; |
|
vm._renderProxy = new Proxy(vm, handlers); |
|
} else { |
|
vm._renderProxy = vm; |
|
} |
|
}; |
|
} |
|
|
|
/* */ |
|
|
|
const seenObjects = new _Set(); |
|
|
|
/** |
|
* Recursively traverse an object to evoke all converted |
|
* getters, so that every nested property inside the object |
|
* is collected as a "deep" dependency. |
|
*/ |
|
function traverse (val) { |
|
_traverse(val, seenObjects); |
|
seenObjects.clear(); |
|
} |
|
|
|
function _traverse (val, seen) { |
|
let i, keys; |
|
const isA = Array.isArray(val); |
|
if ((!isA && !isObject(val)) || Object.isFrozen(val)) { |
|
return |
|
} |
|
if (val.__ob__) { |
|
const 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); |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
const normalizeEvent = cached((name) => { |
|
const passive = name.charAt(0) === '&'; |
|
name = passive ? name.slice(1) : name; |
|
const once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first |
|
name = once$$1 ? name.slice(1) : name; |
|
const capture = name.charAt(0) === '!'; |
|
name = capture ? name.slice(1) : name; |
|
return { |
|
name, |
|
once: once$$1, |
|
capture, |
|
passive |
|
} |
|
}); |
|
|
|
function createFnInvoker (fns) { |
|
function invoker () { |
|
const fns = invoker.fns; |
|
if (Array.isArray(fns)) { |
|
const cloned = fns.slice(); |
|
for (let i = 0; i < cloned.length; i++) { |
|
cloned[i].apply(null, arguments); |
|
} |
|
} 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 |
|
) { |
|
let name, cur, old, event; |
|
for (name in on) { |
|
cur = on[name]; |
|
old = oldOn[name]; |
|
event = normalizeEvent(name); |
|
if (isUndef(cur)) { |
|
"development" !== '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 mergeVNodeHook (def, hookKey, hook) { |
|
if (def instanceof VNode) { |
|
def = def.data.hook || (def.data.hook = {}); |
|
} |
|
let invoker; |
|
const oldHook = def[hookKey]; |
|
|
|
function wrappedHook () { |
|
hook.apply(this, arguments); |
|
// important: remove merged hook to ensure it's called only once |
|
// and prevent memory leak |
|
remove(invoker.fns, wrappedHook); |
|
} |
|
|
|
if (isUndef(oldHook)) { |
|
// no existing hook |
|
invoker = createFnInvoker([wrappedHook]); |
|
} else { |
|
/* istanbul ignore if */ |
|
if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { |
|
// already a merged invoker |
|
invoker = oldHook; |
|
invoker.fns.push(wrappedHook); |
|
} else { |
|
// existing plain hook |
|
invoker = createFnInvoker([oldHook, wrappedHook]); |
|
} |
|
} |
|
|
|
invoker.merged = true; |
|
def[hookKey] = invoker; |
|
} |
|
|
|
/* */ |
|
|
|
function extractPropsFromVNodeData ( |
|
data, |
|
Ctor, |
|
tag |
|
) { |
|
// we are only extracting raw values here. |
|
// validation and default values are handled in the child |
|
// component itself. |
|
const propOptions = Ctor.options.props; |
|
if (isUndef(propOptions)) { |
|
return |
|
} |
|
const res = {}; |
|
const { attrs, props } = data; |
|
if (isDef(attrs) || isDef(props)) { |
|
for (const key in propOptions) { |
|
const altKey = hyphenate(key); |
|
{ |
|
const keyInLowerCase = key.toLowerCase(); |
|
if ( |
|
key !== keyInLowerCase && |
|
attrs && hasOwn(attrs, keyInLowerCase) |
|
) { |
|
tip( |
|
`Prop "${keyInLowerCase}" is passed to component ` + |
|
`${formatComponentName(tag || Ctor)}, but the declared prop name is` + |
|
` "${key}". ` + |
|
`Note that HTML attributes are case-insensitive and camelCased ` + |
|
`props need to use their kebab-case equivalents when using in-DOM ` + |
|
`templates. You should probably use "${altKey}" instead of "${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 (let 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) { |
|
const res = []; |
|
let i, c, lastIndex, last; |
|
for (i = 0; i < children.length; i++) { |
|
c = children[i]; |
|
if (isUndef(c) || typeof c === 'boolean') continue |
|
lastIndex = res.length - 1; |
|
last = res[lastIndex]; |
|
// nested |
|
if (Array.isArray(c)) { |
|
if (c.length > 0) { |
|
c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`); |
|
// merge adjacent text nodes |
|
if (isTextNode(c[0]) && isTextNode(last)) { |
|
res[lastIndex] = createTextVNode(last.text + (c[0]).text); |
|
c.shift(); |
|
} |
|
res.push.apply(res, c); |
|
} |
|
} 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 |
|
res[lastIndex] = createTextVNode(last.text + c); |
|
} else if (c !== '') { |
|
// convert primitive to vnode |
|
res.push(createTextVNode(c)); |
|
} |
|
} else { |
|
if (isTextNode(c) && isTextNode(last)) { |
|
// merge adjacent text nodes |
|
res[lastIndex] = 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 || |
|
(hasSymbol && comp[Symbol.toStringTag] === 'Module') |
|
) { |
|
comp = comp.default; |
|
} |
|
return isObject(comp) |
|
? base.extend(comp) |
|
: comp |
|
} |
|
|
|
function createAsyncPlaceholder ( |
|
factory, |
|
data, |
|
context, |
|
children, |
|
tag |
|
) { |
|
const node = createEmptyVNode(); |
|
node.asyncFactory = factory; |
|
node.asyncMeta = { data, context, children, 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 { |
|
const contexts = factory.contexts = [context]; |
|
let sync = true; |
|
|
|
const forceRender = () => { |
|
for (let i = 0, l = contexts.length; i < l; i++) { |
|
contexts[i].$forceUpdate(); |
|
} |
|
}; |
|
|
|
const resolve = once((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(); |
|
} |
|
}); |
|
|
|
const reject = once(reason => { |
|
"development" !== 'production' && warn( |
|
`Failed to resolve async component: ${String(factory)}` + |
|
(reason ? `\nReason: ${reason}` : '') |
|
); |
|
if (isDef(factory.errorComp)) { |
|
factory.error = true; |
|
forceRender(); |
|
} |
|
}); |
|
|
|
const 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(() => { |
|
if (isUndef(factory.resolved) && isUndef(factory.error)) { |
|
factory.loading = true; |
|
forceRender(); |
|
} |
|
}, res.delay || 200); |
|
} |
|
} |
|
|
|
if (isDef(res.timeout)) { |
|
setTimeout(() => { |
|
if (isUndef(factory.resolved)) { |
|
reject( |
|
`timeout (${res.timeout}ms)` |
|
); |
|
} |
|
}, res.timeout); |
|
} |
|
} |
|
} |
|
|
|
sync = false; |
|
// return in case resolved synchronously |
|
return factory.loading |
|
? factory.loadingComp |
|
: factory.resolved |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function isAsyncPlaceholder (node) { |
|
return node.isComment && node.asyncFactory |
|
} |
|
|
|
/* */ |
|
|
|
function getFirstComponentChild (children) { |
|
if (Array.isArray(children)) { |
|
for (let i = 0; i < children.length; i++) { |
|
const c = children[i]; |
|
if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) { |
|
return c |
|
} |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
/* */ |
|
|
|
function initEvents (vm) { |
|
vm._events = Object.create(null); |
|
vm._hasHookEvent = false; |
|
// init parent attached events |
|
const listeners = vm.$options._parentListeners; |
|
if (listeners) { |
|
updateComponentListeners(vm, listeners); |
|
} |
|
} |
|
|
|
let target; |
|
|
|
function add (event, fn, once) { |
|
if (once) { |
|
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); |
|
target = undefined; |
|
} |
|
|
|
function eventsMixin (Vue) { |
|
const hookRE = /^hook:/; |
|
Vue.prototype.$on = function (event, fn) { |
|
const vm = this; |
|
if (Array.isArray(event)) { |
|
for (let i = 0, l = event.length; i < l; i++) { |
|
this.$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) { |
|
const 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) { |
|
const vm = this; |
|
// all |
|
if (!arguments.length) { |
|
vm._events = Object.create(null); |
|
return vm |
|
} |
|
// array of events |
|
if (Array.isArray(event)) { |
|
for (let i = 0, l = event.length; i < l; i++) { |
|
this.$off(event[i], fn); |
|
} |
|
return vm |
|
} |
|
// specific event |
|
const cbs = vm._events[event]; |
|
if (!cbs) { |
|
return vm |
|
} |
|
if (!fn) { |
|
vm._events[event] = null; |
|
return vm |
|
} |
|
if (fn) { |
|
// specific handler |
|
let cb; |
|
let 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) { |
|
const vm = this; |
|
{ |
|
const lowerCaseEvent = event.toLowerCase(); |
|
if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) { |
|
tip( |
|
`Event "${lowerCaseEvent}" is emitted in component ` + |
|
`${formatComponentName(vm)} but the handler is registered for "${event}". ` + |
|
`Note that HTML attributes are case-insensitive and you cannot use ` + |
|
`v-on to listen to camelCase events when using in-DOM templates. ` + |
|
`You should probably use "${hyphenate(event)}" instead of "${event}".` |
|
); |
|
} |
|
} |
|
let cbs = vm._events[event]; |
|
if (cbs) { |
|
cbs = cbs.length > 1 ? toArray(cbs) : cbs; |
|
const args = toArray(arguments, 1); |
|
for (let 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 |
|
) { |
|
const slots = {}; |
|
if (!children) { |
|
return slots |
|
} |
|
for (let i = 0, l = children.length; i < l; i++) { |
|
const child = children[i]; |
|
const data = child.data; |
|
// remove slot attribute if the node is resolved as a Vue slot node |
|
if (data && data.attrs && data.attrs.slot) { |
|
delete data.attrs.slot; |
|
} |
|
// named slots should only be respected if the vnode was rendered in the |
|
// same context. |
|
if ((child.context === context || child.functionalContext === context) && |
|
data && data.slot != null |
|
) { |
|
const name = child.data.slot; |
|
const slot = (slots[name] || (slots[name] = [])); |
|
if (child.tag === 'template') { |
|
slot.push.apply(slot, child.children); |
|
} else { |
|
slot.push(child); |
|
} |
|
} else { |
|
(slots.default || (slots.default = [])).push(child); |
|
} |
|
} |
|
// ignore slots that contains only whitespace |
|
for (const name in slots) { |
|
if (slots[name].every(isWhitespace)) { |
|
delete slots[name]; |
|
} |
|
} |
|
return slots |
|
} |
|
|
|
function isWhitespace (node) { |
|
return (node.isComment && !node.asyncFactory) || node.text === ' ' |
|
} |
|
|
|
function resolveScopedSlots ( |
|
fns, // see flow/vnode |
|
res |
|
) { |
|
res = res || {}; |
|
for (let 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 |
|
} |
|
|
|
/* */ |
|
|
|
let activeInstance = null; |
|
let isUpdatingChildComponent = false; |
|
|
|
function initLifecycle (vm) { |
|
const options = vm.$options; |
|
|
|
// locate first non-abstract parent |
|
let 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) { |
|
const vm = this; |
|
if (vm._isMounted) { |
|
callHook(vm, 'beforeUpdate'); |
|
} |
|
const prevEl = vm.$el; |
|
const prevVnode = vm._vnode; |
|
const 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 () { |
|
const vm = this; |
|
if (vm._watcher) { |
|
vm._watcher.update(); |
|
} |
|
}; |
|
|
|
Vue.prototype.$destroy = function () { |
|
const vm = this; |
|
if (vm._isBeingDestroyed) { |
|
return |
|
} |
|
callHook(vm, 'beforeDestroy'); |
|
vm._isBeingDestroyed = true; |
|
// remove self from parent |
|
const parent = vm.$parent; |
|
if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) { |
|
remove(parent.$children, vm); |
|
} |
|
// teardown watchers |
|
if (vm._watcher) { |
|
vm._watcher.teardown(); |
|
} |
|
let 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; |
|
} |
|
// release circular reference (#6759) |
|
if (vm.$vnode) { |
|
vm.$vnode.parent = null; |
|
} |
|
}; |
|
} |
|
|
|
function mountComponent ( |
|
vm, |
|
el, |
|
hydrating |
|
) { |
|
vm.$el = el; |
|
if (!vm.$options.render) { |
|
vm.$options.render = createEmptyVNode; |
|
{ |
|
/* istanbul ignore if */ |
|
if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') || |
|
vm.$options.el || el) { |
|
warn( |
|
'You are using the runtime-only build of Vue where the template ' + |
|
'compiler is not available. Either pre-compile the templates into ' + |
|
'render functions, or use the compiler-included build.', |
|
vm |
|
); |
|
} else { |
|
warn( |
|
'Failed to mount component: template or render function not defined.', |
|
vm |
|
); |
|
} |
|
} |
|
} |
|
callHook(vm, 'beforeMount'); |
|
|
|
let updateComponent; |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && config.performance && mark) { |
|
updateComponent = () => { |
|
const name = vm._name; |
|
const id = vm._uid; |
|
const startTag = `vue-perf-start:${id}`; |
|
const endTag = `vue-perf-end:${id}`; |
|
|
|
mark(startTag); |
|
const vnode = vm._render(); |
|
mark(endTag); |
|
measure(`vue ${name} render`, startTag, endTag); |
|
|
|
mark(startTag); |
|
vm._update(vnode, hydrating); |
|
mark(endTag); |
|
measure(`vue ${name} patch`, startTag, endTag); |
|
}; |
|
} else { |
|
updateComponent = () => { |
|
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 |
|
) { |
|
{ |
|
isUpdatingChildComponent = true; |
|
} |
|
|
|
// determine whether component has slot children |
|
// we need to do this before overwriting $options._renderChildren |
|
const 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 $listeners 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) || emptyObject; |
|
vm.$listeners = listeners || emptyObject; |
|
|
|
// update props |
|
if (propsData && vm.$options.props) { |
|
observerState.shouldConvert = false; |
|
const props = vm._props; |
|
const propKeys = vm.$options._propKeys || []; |
|
for (let i = 0; i < propKeys.length; i++) { |
|
const 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) { |
|
const 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(); |
|
} |
|
|
|
{ |
|
isUpdatingChildComponent = false; |
|
} |
|
} |
|
|
|
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 (let 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 (let i = 0; i < vm.$children.length; i++) { |
|
deactivateChildComponent(vm.$children[i]); |
|
} |
|
callHook(vm, 'deactivated'); |
|
} |
|
} |
|
|
|
function callHook (vm, hook) { |
|
const handlers = vm.$options[hook]; |
|
if (handlers) { |
|
for (let 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); |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
|
|
const MAX_UPDATE_COUNT = 100; |
|
|
|
const queue = []; |
|
const activatedChildren = []; |
|
let has = {}; |
|
let circular = {}; |
|
let waiting = false; |
|
let flushing = false; |
|
let index = 0; |
|
|
|
/** |
|
* Reset the scheduler's state. |
|
*/ |
|
function resetSchedulerState () { |
|
index = queue.length = activatedChildren.length = 0; |
|
has = {}; |
|
{ |
|
circular = {}; |
|
} |
|
waiting = flushing = false; |
|
} |
|
|
|
/** |
|
* Flush both queues and run the watchers. |
|
*/ |
|
function flushSchedulerQueue () { |
|
flushing = true; |
|
let 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((a, b) => 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 ("development" !== '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 |
|
const activatedQueue = activatedChildren.slice(); |
|
const 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) { |
|
let i = queue.length; |
|
while (i--) { |
|
const watcher = queue[i]; |
|
const 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 (let 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) { |
|
const 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. |
|
let 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); |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
let 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. |
|
*/ |
|
class Watcher { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
constructor ( |
|
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 = expOrFn.toString(); |
|
// parse expression for getter |
|
if (typeof expOrFn === 'function') { |
|
this.getter = expOrFn; |
|
} else { |
|
this.getter = parsePath(expOrFn); |
|
if (!this.getter) { |
|
this.getter = function () {}; |
|
"development" !== '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. |
|
*/ |
|
get () { |
|
pushTarget(this); |
|
let value; |
|
const 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. |
|
*/ |
|
addDep (dep) { |
|
const 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. |
|
*/ |
|
cleanupDeps () { |
|
let i = this.deps.length; |
|
while (i--) { |
|
const dep = this.deps[i]; |
|
if (!this.newDepIds.has(dep.id)) { |
|
dep.removeSub(this); |
|
} |
|
} |
|
let 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. |
|
*/ |
|
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. |
|
*/ |
|
run () { |
|
if (this.active) { |
|
const 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 |
|
const 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. |
|
*/ |
|
evaluate () { |
|
this.value = this.get(); |
|
this.dirty = false; |
|
} |
|
|
|
/** |
|
* Depend on all deps collected by this watcher. |
|
*/ |
|
depend () { |
|
let i = this.deps.length; |
|
while (i--) { |
|
this.deps[i].depend(); |
|
} |
|
} |
|
|
|
/** |
|
* Remove self from all dependencies' subscriber list. |
|
*/ |
|
teardown () { |
|
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); |
|
} |
|
let i = this.deps.length; |
|
while (i--) { |
|
this.deps[i].removeSub(this); |
|
} |
|
this.active = false; |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
const 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 = []; |
|
const 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 initProps (vm, propsOptions) { |
|
const propsData = vm.$options.propsData || {}; |
|
const props = vm._props = {}; |
|
// cache prop keys so that future props updates can iterate using Array |
|
// instead of dynamic object key enumeration. |
|
const keys = vm.$options._propKeys = []; |
|
const isRoot = !vm.$parent; |
|
// root instance props should be converted |
|
observerState.shouldConvert = isRoot; |
|
for (const key in propsOptions) { |
|
keys.push(key); |
|
const value = validateProp(key, propsOptions, propsData, vm); |
|
/* istanbul ignore else */ |
|
{ |
|
const hyphenatedKey = hyphenate(key); |
|
if (isReservedAttribute(hyphenatedKey) || |
|
config.isReservedAttr(hyphenatedKey)) { |
|
warn( |
|
`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, |
|
vm |
|
); |
|
} |
|
defineReactive(props, key, value, () => { |
|
if (vm.$parent && !isUpdatingChildComponent) { |
|
warn( |
|
`Avoid mutating a prop directly since the value will be ` + |
|
`overwritten whenever the parent component re-renders. ` + |
|
`Instead, use a data or computed property based on the prop's ` + |
|
`value. Prop being mutated: "${key}"`, |
|
vm |
|
); |
|
} |
|
}); |
|
} |
|
// 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); |
|
} |
|
} |
|
observerState.shouldConvert = true; |
|
} |
|
|
|
function initData (vm) { |
|
let data = vm.$options.data; |
|
data = vm._data = typeof data === 'function' |
|
? getData(data, vm) |
|
: data || {}; |
|
if (!isPlainObject(data)) { |
|
data = {}; |
|
"development" !== '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 |
|
const keys = Object.keys(data); |
|
const props = vm.$options.props; |
|
const methods = vm.$options.methods; |
|
let i = keys.length; |
|
while (i--) { |
|
const key = keys[i]; |
|
{ |
|
if (methods && hasOwn(methods, key)) { |
|
warn( |
|
`Method "${key}" has already been defined as a data property.`, |
|
vm |
|
); |
|
} |
|
} |
|
if (props && hasOwn(props, key)) { |
|
"development" !== '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, vm) |
|
} catch (e) { |
|
handleError(e, vm, `data()`); |
|
return {} |
|
} |
|
} |
|
|
|
const computedWatcherOptions = { lazy: true }; |
|
|
|
function initComputed (vm, computed) { |
|
const watchers = vm._computedWatchers = Object.create(null); |
|
// computed properties are just getters during SSR |
|
const isSSR = isServerRendering(); |
|
|
|
for (const key in computed) { |
|
const userDef = computed[key]; |
|
const getter = typeof userDef === 'function' ? userDef : userDef.get; |
|
if ("development" !== 'production' && getter == null) { |
|
warn( |
|
`Getter is missing for computed property "${key}".`, |
|
vm |
|
); |
|
} |
|
|
|
if (!isSSR) { |
|
// create internal watcher for the computed property. |
|
watchers[key] = new Watcher( |
|
vm, |
|
getter || noop, |
|
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 { |
|
if (key in vm.$data) { |
|
warn(`The computed property "${key}" is already defined in data.`, vm); |
|
} else if (vm.$options.props && key in vm.$options.props) { |
|
warn(`The computed property "${key}" is already defined as a prop.`, vm); |
|
} |
|
} |
|
} |
|
} |
|
|
|
function defineComputed ( |
|
target, |
|
key, |
|
userDef |
|
) { |
|
const shouldCache = !isServerRendering(); |
|
if (typeof userDef === 'function') { |
|
sharedPropertyDefinition.get = shouldCache |
|
? createComputedGetter(key) |
|
: userDef; |
|
sharedPropertyDefinition.set = noop; |
|
} else { |
|
sharedPropertyDefinition.get = userDef.get |
|
? shouldCache && userDef.cache !== false |
|
? createComputedGetter(key) |
|
: userDef.get |
|
: noop; |
|
sharedPropertyDefinition.set = userDef.set |
|
? userDef.set |
|
: noop; |
|
} |
|
if ("development" !== 'production' && |
|
sharedPropertyDefinition.set === noop) { |
|
sharedPropertyDefinition.set = function () { |
|
warn( |
|
`Computed property "${key}" was assigned to but it has no setter.`, |
|
this |
|
); |
|
}; |
|
} |
|
Object.defineProperty(target, key, sharedPropertyDefinition); |
|
} |
|
|
|
function createComputedGetter (key) { |
|
return function computedGetter () { |
|
const 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) { |
|
const props = vm.$options.props; |
|
for (const key in methods) { |
|
{ |
|
if (methods[key] == null) { |
|
warn( |
|
`Method "${key}" has an undefined value in the component definition. ` + |
|
`Did you reference the function correctly?`, |
|
vm |
|
); |
|
} |
|
if (props && hasOwn(props, key)) { |
|
warn( |
|
`Method "${key}" has already been defined as a prop.`, |
|
vm |
|
); |
|
} |
|
if ((key in vm) && isReserved(key)) { |
|
warn( |
|
`Method "${key}" conflicts with an existing Vue instance method. ` + |
|
`Avoid defining component methods that start with _ or $.` |
|
); |
|
} |
|
} |
|
vm[key] = methods[key] == null ? noop : bind(methods[key], vm); |
|
} |
|
} |
|
|
|
function initWatch (vm, watch) { |
|
for (const key in watch) { |
|
const handler = watch[key]; |
|
if (Array.isArray(handler)) { |
|
for (let 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. |
|
const dataDef = {}; |
|
dataDef.get = function () { return this._data }; |
|
const propsDef = {}; |
|
propsDef.get = function () { return this._props }; |
|
{ |
|
dataDef.set = function (newData) { |
|
warn( |
|
'Avoid replacing instance root $data. ' + |
|
'Use nested data properties instead.', |
|
this |
|
); |
|
}; |
|
propsDef.set = function () { |
|
warn(`$props is readonly.`, this); |
|
}; |
|
} |
|
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 |
|
) { |
|
const vm = this; |
|
if (isPlainObject(cb)) { |
|
return createWatcher(vm, expOrFn, cb, options) |
|
} |
|
options = options || {}; |
|
options.user = true; |
|
const watcher = new Watcher(vm, expOrFn, cb, options); |
|
if (options.immediate) { |
|
cb.call(vm, watcher.value); |
|
} |
|
return function unwatchFn () { |
|
watcher.teardown(); |
|
} |
|
}; |
|
} |
|
|
|
/* */ |
|
|
|
function initProvide (vm) { |
|
const provide = vm.$options.provide; |
|
if (provide) { |
|
vm._provided = typeof provide === 'function' |
|
? provide.call(vm) |
|
: provide; |
|
} |
|
} |
|
|
|
function initInjections (vm) { |
|
const result = resolveInject(vm.$options.inject, vm); |
|
if (result) { |
|
observerState.shouldConvert = false; |
|
Object.keys(result).forEach(key => { |
|
/* istanbul ignore else */ |
|
{ |
|
defineReactive(vm, key, result[key], () => { |
|
warn( |
|
`Avoid mutating an injected value directly since the changes will be ` + |
|
`overwritten whenever the provided component re-renders. ` + |
|
`injection being mutated: "${key}"`, |
|
vm |
|
); |
|
}); |
|
} |
|
}); |
|
observerState.shouldConvert = true; |
|
} |
|
} |
|
|
|
function resolveInject (inject, vm) { |
|
if (inject) { |
|
// inject is :any because flow is not smart enough to figure out cached |
|
const result = Object.create(null); |
|
const keys = hasSymbol |
|
? Reflect.ownKeys(inject).filter(key => { |
|
/* istanbul ignore next */ |
|
return Object.getOwnPropertyDescriptor(inject, key).enumerable |
|
}) |
|
: Object.keys(inject); |
|
|
|
for (let i = 0; i < keys.length; i++) { |
|
const key = keys[i]; |
|
const provideKey = inject[key].from; |
|
let source = vm; |
|
while (source) { |
|
if (source._provided && provideKey in source._provided) { |
|
result[key] = source._provided[provideKey]; |
|
break |
|
} |
|
source = source.$parent; |
|
} |
|
if (!source) { |
|
if ('default' in inject[key]) { |
|
const provideDefault = inject[key].default; |
|
result[key] = typeof provideDefault === 'function' |
|
? provideDefault.call(vm) |
|
: provideDefault; |
|
} else { |
|
warn(`Injection "${key}" not found`, vm); |
|
} |
|
} |
|
} |
|
return result |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
/** |
|
* Runtime helper for rendering v-for lists. |
|
*/ |
|
function renderList ( |
|
val, |
|
render |
|
) { |
|
let 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 |
|
) { |
|
const scopedSlotFn = this.$scopedSlots[name]; |
|
let nodes; |
|
if (scopedSlotFn) { // scoped slot |
|
props = props || {}; |
|
if (bindObject) { |
|
if ("development" !== 'production' && !isObject(bindObject)) { |
|
warn( |
|
'slot v-bind without argument expects an Object', |
|
this |
|
); |
|
} |
|
props = extend(extend({}, bindObject), props); |
|
} |
|
nodes = scopedSlotFn(props) || fallback; |
|
} else { |
|
const slotNodes = this.$slots[name]; |
|
// warn duplicate slot usage |
|
if (slotNodes) { |
|
if ("development" !== '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; |
|
} |
|
nodes = slotNodes || fallback; |
|
} |
|
|
|
const target = props && props.slot; |
|
if (target) { |
|
return this.$createElement('template', { slot: target }, nodes) |
|
} else { |
|
return nodes |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
/** |
|
* Runtime helper for resolving filters |
|
*/ |
|
function resolveFilter (id) { |
|
return resolveAsset(this.$options, 'filters', id, true) || identity |
|
} |
|
|
|
/* */ |
|
|
|
/** |
|
* Runtime helper for checking keyCodes from config. |
|
* exposed as Vue.prototype._k |
|
* passing in eventKeyName as last argument separately for backwards compat |
|
*/ |
|
function checkKeyCodes ( |
|
eventKeyCode, |
|
key, |
|
builtInAlias, |
|
eventKeyName |
|
) { |
|
const keyCodes = config.keyCodes[key] || builtInAlias; |
|
if (keyCodes) { |
|
if (Array.isArray(keyCodes)) { |
|
return keyCodes.indexOf(eventKeyCode) === -1 |
|
} else { |
|
return keyCodes !== eventKeyCode |
|
} |
|
} else if (eventKeyName) { |
|
return hyphenate(eventKeyName) !== key |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
/** |
|
* Runtime helper for merging v-bind="object" into a VNode's data. |
|
*/ |
|
function bindObjectProps ( |
|
data, |
|
tag, |
|
value, |
|
asProp, |
|
isSync |
|
) { |
|
if (value) { |
|
if (!isObject(value)) { |
|
"development" !== 'production' && warn( |
|
'v-bind without argument expects an Object or Array value', |
|
this |
|
); |
|
} else { |
|
if (Array.isArray(value)) { |
|
value = toObject(value); |
|
} |
|
let hash; |
|
for (const key in value) { |
|
if ( |
|
key === 'class' || |
|
key === 'style' || |
|
isReservedAttribute(key) |
|
) { |
|
hash = data; |
|
} else { |
|
const 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) { |
|
const on = data.on || (data.on = {}); |
|
on[`update:${key}`] = function ($event) { |
|
value[key] = $event; |
|
}; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
return data |
|
} |
|
|
|
/* */ |
|
|
|
/** |
|
* Runtime helper for rendering static trees. |
|
*/ |
|
function renderStatic ( |
|
index, |
|
isInFor, |
|
isOnce |
|
) { |
|
// render fns generated by compiler < 2.5.4 does not provide v-once |
|
// information to runtime so be conservative |
|
const isOldVersion = arguments.length < 3; |
|
// if a static tree is generated by v-once, it is cached on the instance; |
|
// otherwise it is purely static and can be cached on the shared options |
|
// across all instances. |
|
const renderFns = this.$options.staticRenderFns; |
|
const cached = isOldVersion || isOnce |
|
? (this._staticTrees || (this._staticTrees = [])) |
|
: (renderFns.cached || (renderFns.cached = [])); |
|
let tree = cached[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 = cached[index] = renderFns[index].call(this._renderProxy, null, this); |
|
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 (let 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)) { |
|
"development" !== 'production' && warn( |
|
'v-on without argument expects an Object value', |
|
this |
|
); |
|
} else { |
|
const on = data.on = data.on ? extend({}, data.on) : {}; |
|
for (const key in value) { |
|
const existing = on[key]; |
|
const ours = value[key]; |
|
on[key] = existing ? [].concat(existing, ours) : ours; |
|
} |
|
} |
|
} |
|
return data |
|
} |
|
|
|
/* */ |
|
|
|
function installRenderHelpers (target) { |
|
target._o = markOnce; |
|
target._n = toNumber; |
|
target._s = toString; |
|
target._l = renderList; |
|
target._t = renderSlot; |
|
target._q = looseEqual; |
|
target._i = looseIndexOf; |
|
target._m = renderStatic; |
|
target._f = resolveFilter; |
|
target._k = checkKeyCodes; |
|
target._b = bindObjectProps; |
|
target._v = createTextVNode; |
|
target._e = createEmptyVNode; |
|
target._u = resolveScopedSlots; |
|
target._g = bindObjectListeners; |
|
} |
|
|
|
/* */ |
|
|
|
function FunctionalRenderContext ( |
|
data, |
|
props, |
|
children, |
|
parent, |
|
Ctor |
|
) { |
|
const options = Ctor.options; |
|
this.data = data; |
|
this.props = props; |
|
this.children = children; |
|
this.parent = parent; |
|
this.listeners = data.on || emptyObject; |
|
this.injections = resolveInject(options.inject, parent); |
|
this.slots = () => resolveSlots(children, parent); |
|
|
|
// ensure the createElement function in functional components |
|
// gets a unique context - this is necessary for correct named slot check |
|
const contextVm = Object.create(parent); |
|
const isCompiled = isTrue(options._compiled); |
|
const needNormalization = !isCompiled; |
|
|
|
// support for compiled functional template |
|
if (isCompiled) { |
|
// exposing $options for renderStatic() |
|
this.$options = options; |
|
// pre-resolve slots for renderSlot() |
|
this.$slots = this.slots(); |
|
this.$scopedSlots = data.scopedSlots || emptyObject; |
|
} |
|
|
|
if (options._scopeId) { |
|
this._c = (a, b, c, d) => { |
|
const vnode = createElement(contextVm, a, b, c, d, needNormalization); |
|
if (vnode) { |
|
vnode.functionalScopeId = options._scopeId; |
|
vnode.functionalContext = parent; |
|
} |
|
return vnode |
|
}; |
|
} else { |
|
this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization); |
|
} |
|
} |
|
|
|
installRenderHelpers(FunctionalRenderContext.prototype); |
|
|
|
function createFunctionalComponent ( |
|
Ctor, |
|
propsData, |
|
data, |
|
contextVm, |
|
children |
|
) { |
|
const options = Ctor.options; |
|
const props = {}; |
|
const propOptions = options.props; |
|
if (isDef(propOptions)) { |
|
for (const key in propOptions) { |
|
props[key] = validateProp(key, propOptions, propsData || emptyObject); |
|
} |
|
} else { |
|
if (isDef(data.attrs)) mergeProps(props, data.attrs); |
|
if (isDef(data.props)) mergeProps(props, data.props); |
|
} |
|
|
|
const renderContext = new FunctionalRenderContext( |
|
data, |
|
props, |
|
children, |
|
contextVm, |
|
Ctor |
|
); |
|
|
|
const vnode = options.render.call(null, renderContext._c, renderContext); |
|
|
|
if (vnode instanceof VNode) { |
|
vnode.functionalContext = contextVm; |
|
vnode.functionalOptions = options; |
|
if (data.slot) { |
|
(vnode.data || (vnode.data = {})).slot = data.slot; |
|
} |
|
} |
|
|
|
return vnode |
|
} |
|
|
|
function mergeProps (to, from) { |
|
for (const key in from) { |
|
to[camelize(key)] = from[key]; |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
// hooks to be invoked on component VNodes during patch |
|
const componentVNodeHooks = { |
|
init ( |
|
vnode, |
|
hydrating, |
|
parentElm, |
|
refElm |
|
) { |
|
if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) { |
|
const 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 |
|
const mountedNode = vnode; // work around flow |
|
componentVNodeHooks.prepatch(mountedNode, mountedNode); |
|
} |
|
}, |
|
|
|
prepatch (oldVnode, vnode) { |
|
const options = vnode.componentOptions; |
|
const child = vnode.componentInstance = oldVnode.componentInstance; |
|
updateChildComponent( |
|
child, |
|
options.propsData, // updated props |
|
options.listeners, // updated listeners |
|
vnode, // new parent vnode |
|
options.children // new children |
|
); |
|
}, |
|
|
|
insert (vnode) { |
|
const { context, componentInstance } = vnode; |
|
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 (vnode) { |
|
const { componentInstance } = vnode; |
|
if (!componentInstance._isDestroyed) { |
|
if (!vnode.data.keepAlive) { |
|
componentInstance.$destroy(); |
|
} else { |
|
deactivateChildComponent(componentInstance, true /* direct */); |
|
} |
|
} |
|
} |
|
}; |
|
|
|
const hooksToMerge = Object.keys(componentVNodeHooks); |
|
|
|
function createComponent ( |
|
Ctor, |
|
data, |
|
context, |
|
children, |
|
tag |
|
) { |
|
if (isUndef(Ctor)) { |
|
return |
|
} |
|
|
|
const 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') { |
|
{ |
|
warn(`Invalid Component definition: ${String(Ctor)}`, context); |
|
} |
|
return |
|
} |
|
|
|
// async component |
|
let 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 |
|
const propsData = extractPropsFromVNodeData(data, Ctor, tag); |
|
|
|
// functional component |
|
if (isTrue(Ctor.options.functional)) { |
|
return createFunctionalComponent(Ctor, propsData, data, context, children) |
|
} |
|
|
|
// extract listeners, since these needs to be treated as |
|
// child component listeners instead of DOM listeners |
|
const listeners = data.on; |
|
// replace with listeners with .native modifier |
|
// so it gets processed during parent component patch. |
|
data.on = data.nativeOn; |
|
|
|
if (isTrue(Ctor.options.abstract)) { |
|
// abstract components do not keep anything |
|
// other than props & listeners & slot |
|
|
|
// work around flow |
|
const slot = data.slot; |
|
data = {}; |
|
if (slot) { |
|
data.slot = slot; |
|
} |
|
} |
|
|
|
// merge component management hooks onto the placeholder node |
|
mergeHooks(data); |
|
|
|
// return a placeholder vnode |
|
const name = Ctor.options.name || tag; |
|
const vnode = new VNode( |
|
`vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, |
|
data, undefined, undefined, undefined, context, |
|
{ Ctor, propsData, listeners, tag, children }, |
|
asyncFactory |
|
); |
|
return vnode |
|
} |
|
|
|
function createComponentInstanceForVnode ( |
|
vnode, // we know it's MountedComponentVNode but flow doesn't |
|
parent, // activeInstance in lifecycle state |
|
parentElm, |
|
refElm |
|
) { |
|
const vnodeComponentOptions = vnode.componentOptions; |
|
const options = { |
|
_isComponent: true, |
|
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 |
|
const 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 (let i = 0; i < hooksToMerge.length; i++) { |
|
const key = hooksToMerge[i]; |
|
const fromParent = data.hook[key]; |
|
const 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) { |
|
const prop = (options.model && options.model.prop) || 'value'; |
|
const event = (options.model && options.model.event) || 'input';(data.props || (data.props = {}))[prop] = data.model.value; |
|
const on = data.on || (data.on = {}); |
|
if (isDef(on[event])) { |
|
on[event] = [data.model.callback].concat(on[event]); |
|
} else { |
|
on[event] = data.model.callback; |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
const SIMPLE_NORMALIZE = 1; |
|
const 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__)) { |
|
"development" !== '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 ("development" !== '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); |
|
} |
|
let vnode, ns; |
|
if (typeof tag === 'string') { |
|
let Ctor; |
|
ns = (context.$vnode && context.$vnode.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, force) { |
|
vnode.ns = ns; |
|
if (vnode.tag === 'foreignObject') { |
|
// use default namespace inside foreignObject |
|
ns = undefined; |
|
force = true; |
|
} |
|
if (isDef(vnode.children)) { |
|
for (let i = 0, l = vnode.children.length; i < l; i++) { |
|
const child = vnode.children[i]; |
|
if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force))) { |
|
applyNS(child, ns, force); |
|
} |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function initRender (vm) { |
|
vm._vnode = null; // the root of the child tree |
|
vm._staticTrees = null; // v-once cached trees |
|
const options = vm.$options; |
|
const parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree |
|
const renderContext = parentVnode && parentVnode.context; |
|
vm.$slots = resolveSlots(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 = (a, b, c, d) => createElement(vm, a, b, c, d, false); |
|
// normalization is always applied for the public version, used in |
|
// user-written render functions. |
|
vm.$createElement = (a, b, c, d) => 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 |
|
const parentData = parentVnode && parentVnode.data; |
|
|
|
/* istanbul ignore else */ |
|
{ |
|
defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, () => { |
|
!isUpdatingChildComponent && warn(`$attrs is readonly.`, vm); |
|
}, true); |
|
defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => { |
|
!isUpdatingChildComponent && warn(`$listeners is readonly.`, vm); |
|
}, true); |
|
} |
|
} |
|
|
|
function renderMixin (Vue) { |
|
// install runtime convenience helpers |
|
installRenderHelpers(Vue.prototype); |
|
|
|
Vue.prototype.$nextTick = function (fn) { |
|
return nextTick(fn, this) |
|
}; |
|
|
|
Vue.prototype._render = function () { |
|
const vm = this; |
|
const { render, _parentVnode } = vm.$options; |
|
|
|
if (vm._isMounted) { |
|
// if the parent didn't update, the slot nodes will be the ones from |
|
// last render. They need to be cloned to ensure "freshness" for this render. |
|
for (const key in vm.$slots) { |
|
const slot = vm.$slots[key]; |
|
// _rendered is a flag added by renderSlot, but may not be present |
|
// if the slot is passed from manually written render functions |
|
if (slot._rendered || (slot[0] && slot[0].elm)) { |
|
vm.$slots[key] = cloneVNodes(slot, true /* deep */); |
|
} |
|
} |
|
} |
|
|
|
vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject; |
|
|
|
// set parent vnode. this allows render functions to have access |
|
// to the data on the placeholder node. |
|
vm.$vnode = _parentVnode; |
|
// render self |
|
let vnode; |
|
try { |
|
vnode = render.call(vm._renderProxy, vm.$createElement); |
|
} catch (e) { |
|
handleError(e, vm, `render`); |
|
// return error render result, |
|
// or previous vnode to prevent render error causing blank component |
|
/* istanbul ignore else */ |
|
{ |
|
if (vm.$options.renderError) { |
|
try { |
|
vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e); |
|
} catch (e) { |
|
handleError(e, vm, `renderError`); |
|
vnode = vm._vnode; |
|
} |
|
} else { |
|
vnode = vm._vnode; |
|
} |
|
} |
|
} |
|
// return empty vnode in case the render function errored out |
|
if (!(vnode instanceof VNode)) { |
|
if ("development" !== '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 |
|
}; |
|
} |
|
|
|
/* */ |
|
|
|
let uid$1 = 0; |
|
|
|
function initMixin (Vue) { |
|
Vue.prototype._init = function (options) { |
|
const vm = this; |
|
// a uid |
|
vm._uid = uid$1++; |
|
|
|
let startTag, endTag; |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && config.performance && mark) { |
|
startTag = `vue-perf-start:${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 */ |
|
{ |
|
initProxy(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 ("development" !== 'production' && config.performance && mark) { |
|
vm._name = formatComponentName(vm, false); |
|
mark(endTag); |
|
measure(`vue ${vm._name} init`, startTag, endTag); |
|
} |
|
|
|
if (vm.$options.el) { |
|
vm.$mount(vm.$options.el); |
|
} |
|
}; |
|
} |
|
|
|
function initInternalComponent (vm, options) { |
|
const 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) { |
|
let options = Ctor.options; |
|
if (Ctor.super) { |
|
const superOptions = resolveConstructorOptions(Ctor.super); |
|
const 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) |
|
const 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) { |
|
let modified; |
|
const latest = Ctor.options; |
|
const extended = Ctor.extendOptions; |
|
const sealed = Ctor.sealedOptions; |
|
for (const 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)) { |
|
const res = []; |
|
sealed = Array.isArray(sealed) ? sealed : [sealed]; |
|
extended = Array.isArray(extended) ? extended : [extended]; |
|
for (let 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 ("development" !== '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) { |
|
const installedPlugins = (this._installedPlugins || (this._installedPlugins = [])); |
|
if (installedPlugins.indexOf(plugin) > -1) { |
|
return this |
|
} |
|
|
|
// additional parameters |
|
const 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; |
|
let cid = 1; |
|
|
|
/** |
|
* Class inheritance |
|
*/ |
|
Vue.extend = function (extendOptions) { |
|
extendOptions = extendOptions || {}; |
|
const Super = this; |
|
const SuperId = Super.cid; |
|
const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {}); |
|
if (cachedCtors[SuperId]) { |
|
return cachedCtors[SuperId] |
|
} |
|
|
|
const name = extendOptions.name || Super.options.name; |
|
{ |
|
if (!/^[a-zA-Z][\w-]*$/.test(name)) { |
|
warn( |
|
'Invalid component name: "' + name + '". Component names ' + |
|
'can only contain alphanumeric characters and the hyphen, ' + |
|
'and must start with a letter.' |
|
); |
|
} |
|
} |
|
|
|
const 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) { |
|
const props = Comp.options.props; |
|
for (const key in props) { |
|
proxy(Comp.prototype, `_props`, key); |
|
} |
|
} |
|
|
|
function initComputed$1 (Comp) { |
|
const computed = Comp.options.computed; |
|
for (const key in computed) { |
|
defineComputed(Comp.prototype, key, computed[key]); |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function initAssetRegisters (Vue) { |
|
/** |
|
* Create asset registration methods. |
|
*/ |
|
ASSET_TYPES.forEach(type => { |
|
Vue[type] = function ( |
|
id, |
|
definition |
|
) { |
|
if (!definition) { |
|
return this.options[type + 's'][id] |
|
} else { |
|
/* istanbul ignore if */ |
|
{ |
|
if (type === 'component' && config.isReservedTag(id)) { |
|
warn( |
|
'Do not use built-in or reserved HTML elements as component ' + |
|
'id: ' + id |
|
); |
|
} |
|
} |
|
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 |
|
} |
|
}; |
|
}); |
|
} |
|
|
|
/* */ |
|
|
|
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 (keepAliveInstance, filter) { |
|
const { cache, keys, _vnode } = keepAliveInstance; |
|
for (const key in cache) { |
|
const cachedNode = cache[key]; |
|
if (cachedNode) { |
|
const name = getComponentName(cachedNode.componentOptions); |
|
if (name && !filter(name)) { |
|
pruneCacheEntry(cache, key, keys, _vnode); |
|
} |
|
} |
|
} |
|
} |
|
|
|
function pruneCacheEntry ( |
|
cache, |
|
key, |
|
keys, |
|
current |
|
) { |
|
const cached$$1 = cache[key]; |
|
if (cached$$1 && cached$$1 !== current) { |
|
cached$$1.componentInstance.$destroy(); |
|
} |
|
cache[key] = null; |
|
remove(keys, key); |
|
} |
|
|
|
const patternTypes = [String, RegExp, Array]; |
|
|
|
var KeepAlive = { |
|
name: 'keep-alive', |
|
abstract: true, |
|
|
|
props: { |
|
include: patternTypes, |
|
exclude: patternTypes, |
|
max: [String, Number] |
|
}, |
|
|
|
created () { |
|
this.cache = Object.create(null); |
|
this.keys = []; |
|
}, |
|
|
|
destroyed () { |
|
for (const key in this.cache) { |
|
pruneCacheEntry(this.cache, key, this.keys); |
|
} |
|
}, |
|
|
|
watch: { |
|
include (val) { |
|
pruneCache(this, name => matches(val, name)); |
|
}, |
|
exclude (val) { |
|
pruneCache(this, name => !matches(val, name)); |
|
} |
|
}, |
|
|
|
render () { |
|
const slot = this.$slots.default; |
|
const vnode = getFirstComponentChild(slot); |
|
const componentOptions = vnode && vnode.componentOptions; |
|
if (componentOptions) { |
|
// check pattern |
|
const name = getComponentName(componentOptions); |
|
const { include, exclude } = this; |
|
if ( |
|
// not included |
|
(include && (!name || !matches(include, name))) || |
|
// excluded |
|
(exclude && name && matches(exclude, name)) |
|
) { |
|
return vnode |
|
} |
|
|
|
const { cache, keys } = this; |
|
const 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 (cache[key]) { |
|
vnode.componentInstance = cache[key].componentInstance; |
|
// make current key freshest |
|
remove(keys, key); |
|
keys.push(key); |
|
} else { |
|
cache[key] = vnode; |
|
keys.push(key); |
|
// prune oldest entry |
|
if (this.max && keys.length > parseInt(this.max)) { |
|
pruneCacheEntry(cache, keys[0], keys, this._vnode); |
|
} |
|
} |
|
|
|
vnode.data.keepAlive = true; |
|
} |
|
return vnode || (slot && slot[0]) |
|
} |
|
}; |
|
|
|
var builtInComponents = { |
|
KeepAlive |
|
}; |
|
|
|
/* */ |
|
|
|
function initGlobalAPI (Vue) { |
|
// config |
|
const configDef = {}; |
|
configDef.get = () => config; |
|
{ |
|
configDef.set = () => { |
|
warn( |
|
'Do not replace the Vue.config object, set individual fields instead.' |
|
); |
|
}; |
|
} |
|
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, |
|
extend, |
|
mergeOptions, |
|
defineReactive |
|
}; |
|
|
|
Vue.set = set; |
|
Vue.delete = del; |
|
Vue.nextTick = nextTick; |
|
|
|
Vue.options = Object.create(null); |
|
ASSET_TYPES.forEach(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 () { |
|
/* istanbul ignore next */ |
|
return this.$vnode && this.$vnode.ssrContext |
|
} |
|
}); |
|
|
|
Vue$3.version = '2.5.8'; |
|
|
|
/* */ |
|
|
|
// these are reserved for web because they are directly compiled away |
|
// during template compilation |
|
const isReservedAttr = makeMap('style,class'); |
|
|
|
// attributes that should be using props for binding |
|
const acceptValue = makeMap('input,textarea,option,select,progress'); |
|
const mustUseProp = (tag, type, attr) => { |
|
return ( |
|
(attr === 'value' && acceptValue(tag)) && type !== 'button' || |
|
(attr === 'selected' && tag === 'option') || |
|
(attr === 'checked' && tag === 'input') || |
|
(attr === 'muted' && tag === 'video') |
|
) |
|
}; |
|
|
|
const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'); |
|
|
|
const isBooleanAttr = makeMap( |
|
'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + |
|
'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + |
|
'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + |
|
'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + |
|
'required,reversed,scoped,seamless,selected,sortable,translate,' + |
|
'truespeed,typemustmatch,visible' |
|
); |
|
|
|
const xlinkNS = 'http://www.w3.org/1999/xlink'; |
|
|
|
const isXlink = (name) => { |
|
return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink' |
|
}; |
|
|
|
const getXlinkProp = (name) => { |
|
return isXlink(name) ? name.slice(6, name.length) : '' |
|
}; |
|
|
|
const isFalsyAttrValue = (val) => { |
|
return val == null || val === false |
|
}; |
|
|
|
/* */ |
|
|
|
function genClassForVnode (vnode) { |
|
let data = vnode.data; |
|
let parentNode = vnode; |
|
let childNode = vnode; |
|
while (isDef(childNode.componentInstance)) { |
|
childNode = childNode.componentInstance._vnode; |
|
if (childNode.data) { |
|
data = mergeClassData(childNode.data, data); |
|
} |
|
} |
|
while (isDef(parentNode = parentNode.parent)) { |
|
if (parentNode.data) { |
|
data = mergeClassData(data, parentNode.data); |
|
} |
|
} |
|
return renderClass(data.staticClass, data.class) |
|
} |
|
|
|
function mergeClassData (child, parent) { |
|
return { |
|
staticClass: concat(child.staticClass, parent.staticClass), |
|
class: isDef(child.class) |
|
? [child.class, parent.class] |
|
: parent.class |
|
} |
|
} |
|
|
|
function renderClass ( |
|
staticClass, |
|
dynamicClass |
|
) { |
|
if (isDef(staticClass) || isDef(dynamicClass)) { |
|
return concat(staticClass, stringifyClass(dynamicClass)) |
|
} |
|
/* istanbul ignore next */ |
|
return '' |
|
} |
|
|
|
function concat (a, b) { |
|
return a ? b ? (a + ' ' + b) : a : (b || '') |
|
} |
|
|
|
function stringifyClass (value) { |
|
if (Array.isArray(value)) { |
|
return stringifyArray(value) |
|
} |
|
if (isObject(value)) { |
|
return stringifyObject(value) |
|
} |
|
if (typeof value === 'string') { |
|
return value |
|
} |
|
/* istanbul ignore next */ |
|
return '' |
|
} |
|
|
|
function stringifyArray (value) { |
|
let res = ''; |
|
let stringified; |
|
for (let i = 0, l = value.length; i < l; i++) { |
|
if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') { |
|
if (res) res += ' '; |
|
res += stringified; |
|
} |
|
} |
|
return res |
|
} |
|
|
|
function stringifyObject (value) { |
|
let res = ''; |
|
for (const key in value) { |
|
if (value[key]) { |
|
if (res) res += ' '; |
|
res += key; |
|
} |
|
} |
|
return res |
|
} |
|
|
|
/* */ |
|
|
|
const namespaceMap = { |
|
svg: 'http://www.w3.org/2000/svg', |
|
math: 'http://www.w3.org/1998/Math/MathML' |
|
}; |
|
|
|
const isHTMLTag = makeMap( |
|
'html,body,base,head,link,meta,style,title,' + |
|
'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + |
|
'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' + |
|
'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + |
|
's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + |
|
'embed,object,param,source,canvas,script,noscript,del,ins,' + |
|
'caption,col,colgroup,table,thead,tbody,td,th,tr,' + |
|
'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + |
|
'output,progress,select,textarea,' + |
|
'details,dialog,menu,menuitem,summary,' + |
|
'content,element,shadow,template,blockquote,iframe,tfoot' |
|
); |
|
|
|
// this map is intentionally selective, only covering SVG elements that may |
|
// contain child elements. |
|
const isSVG = makeMap( |
|
'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' + |
|
'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + |
|
'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', |
|
true |
|
); |
|
|
|
const isPreTag = (tag) => tag === 'pre'; |
|
|
|
const isReservedTag = (tag) => { |
|
return isHTMLTag(tag) || isSVG(tag) |
|
}; |
|
|
|
function getTagNamespace (tag) { |
|
if (isSVG(tag)) { |
|
return 'svg' |
|
} |
|
// basic support for MathML |
|
// note it doesn't support other MathML elements being component roots |
|
if (tag === 'math') { |
|
return 'math' |
|
} |
|
} |
|
|
|
const unknownElementCache = Object.create(null); |
|
function isUnknownElement (tag) { |
|
/* istanbul ignore if */ |
|
if (!inBrowser) { |
|
return true |
|
} |
|
if (isReservedTag(tag)) { |
|
return false |
|
} |
|
tag = tag.toLowerCase(); |
|
/* istanbul ignore if */ |
|
if (unknownElementCache[tag] != null) { |
|
return unknownElementCache[tag] |
|
} |
|
const el = document.createElement(tag); |
|
if (tag.indexOf('-') > -1) { |
|
// http://stackoverflow.com/a/28210364/1070244 |
|
return (unknownElementCache[tag] = ( |
|
el.constructor === window.HTMLUnknownElement || |
|
el.constructor === window.HTMLElement |
|
)) |
|
} else { |
|
return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString())) |
|
} |
|
} |
|
|
|
const isTextInputType = makeMap('text,number,password,search,email,tel,url'); |
|
|
|
/* */ |
|
|
|
/** |
|
* Query an element selector if it's not an element already. |
|
*/ |
|
function query (el) { |
|
if (typeof el === 'string') { |
|
const selected = document.querySelector(el); |
|
if (!selected) { |
|
"development" !== 'production' && warn( |
|
'Cannot find element: ' + el |
|
); |
|
return document.createElement('div') |
|
} |
|
return selected |
|
} else { |
|
return el |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function createElement$1 (tagName, vnode) { |
|
const elm = document.createElement(tagName); |
|
if (tagName !== 'select') { |
|
return elm |
|
} |
|
// false or null will remove the attribute but undefined will not |
|
if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) { |
|
elm.setAttribute('multiple', 'multiple'); |
|
} |
|
return elm |
|
} |
|
|
|
function createElementNS (namespace, tagName) { |
|
return document.createElementNS(namespaceMap[namespace], tagName) |
|
} |
|
|
|
function createTextNode (text) { |
|
return document.createTextNode(text) |
|
} |
|
|
|
function createComment (text) { |
|
return document.createComment(text) |
|
} |
|
|
|
function insertBefore (parentNode, newNode, referenceNode) { |
|
parentNode.insertBefore(newNode, referenceNode); |
|
} |
|
|
|
function removeChild (node, child) { |
|
node.removeChild(child); |
|
} |
|
|
|
function appendChild (node, child) { |
|
node.appendChild(child); |
|
} |
|
|
|
function parentNode (node) { |
|
return node.parentNode |
|
} |
|
|
|
function nextSibling (node) { |
|
return node.nextSibling |
|
} |
|
|
|
function tagName (node) { |
|
return node.tagName |
|
} |
|
|
|
function setTextContent (node, text) { |
|
node.textContent = text; |
|
} |
|
|
|
function setAttribute (node, key, val) { |
|
node.setAttribute(key, val); |
|
} |
|
|
|
|
|
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 (_, vnode) { |
|
registerRef(vnode); |
|
}, |
|
update (oldVnode, vnode) { |
|
if (oldVnode.data.ref !== vnode.data.ref) { |
|
registerRef(oldVnode, true); |
|
registerRef(vnode); |
|
} |
|
}, |
|
destroy (vnode) { |
|
registerRef(vnode, true); |
|
} |
|
}; |
|
|
|
function registerRef (vnode, isRemoval) { |
|
const key = vnode.data.ref; |
|
if (!key) return |
|
|
|
const vm = vnode.context; |
|
const ref = vnode.componentInstance || vnode.elm; |
|
const 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. |
|
*/ |
|
|
|
const emptyNode = new VNode('', {}, []); |
|
|
|
const 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) |
|
) |
|
) |
|
) |
|
} |
|
|
|
function sameInputType (a, b) { |
|
if (a.tag !== 'input') return true |
|
let i; |
|
const typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type; |
|
const typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type; |
|
return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB) |
|
} |
|
|
|
function createKeyToOldIdx (children, beginIdx, endIdx) { |
|
let i, key; |
|
const map = {}; |
|
for (i = beginIdx; i <= endIdx; ++i) { |
|
key = children[i].key; |
|
if (isDef(key)) map[key] = i; |
|
} |
|
return map |
|
} |
|
|
|
function createPatchFunction (backend) { |
|
let i, j; |
|
const cbs = {}; |
|
|
|
const { modules, nodeOps } = backend; |
|
|
|
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 () { |
|
if (--remove.listeners === 0) { |
|
removeNode(childElm); |
|
} |
|
} |
|
remove.listeners = listeners; |
|
return remove |
|
} |
|
|
|
function removeNode (el) { |
|
const parent = nodeOps.parentNode(el); |
|
// element may have already been removed due to v-html / v-text |
|
if (isDef(parent)) { |
|
nodeOps.removeChild(parent, el); |
|
} |
|
} |
|
|
|
function isUnknownElement$$1 (vnode, inVPre) { |
|
return ( |
|
!inVPre && |
|
!vnode.ns && |
|
!( |
|
config.ignoredElements.length && |
|
config.ignoredElements.some(ignore => { |
|
return isRegExp(ignore) |
|
? ignore.test(vnode.tag) |
|
: ignore === vnode.tag |
|
}) |
|
) && |
|
config.isUnknownElement(vnode.tag) |
|
) |
|
} |
|
|
|
let creatingElmInVPre = 0; |
|
function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) { |
|
vnode.isRootInsert = !nested; // for transition enter check |
|
if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) { |
|
return |
|
} |
|
|
|
const data = vnode.data; |
|
const children = vnode.children; |
|
const tag = vnode.tag; |
|
if (isDef(tag)) { |
|
{ |
|
if (data && data.pre) { |
|
creatingElmInVPre++; |
|
} |
|
if (isUnknownElement$$1(vnode, creatingElmInVPre)) { |
|
warn( |
|
'Unknown custom element: <' + tag + '> - did you ' + |
|
'register the component correctly? For recursive components, ' + |
|
'make sure to provide the "name" option.', |
|
vnode.context |
|
); |
|
} |
|
} |
|
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 ("development" !== 'production' && data && data.pre) { |
|
creatingElmInVPre--; |
|
} |
|
} 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) { |
|
let i = vnode.data; |
|
if (isDef(i)) { |
|
const 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) { |
|
let 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. |
|
let 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 (let 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 (let i = 0; i < cbs.create.length; ++i) { |
|
cbs.create[i](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) { |
|
let i; |
|
if (isDef(i = vnode.functionalScopeId)) { |
|
nodeOps.setAttribute(vnode.elm, i, ''); |
|
} else { |
|
let 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 && |
|
i !== vnode.functionalContext && |
|
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) { |
|
let i, j; |
|
const 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) { |
|
const 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)) { |
|
let i; |
|
const 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) { |
|
let oldStartIdx = 0; |
|
let newStartIdx = 0; |
|
let oldEndIdx = oldCh.length - 1; |
|
let oldStartVnode = oldCh[0]; |
|
let oldEndVnode = oldCh[oldEndIdx]; |
|
let newEndIdx = newCh.length - 1; |
|
let newStartVnode = newCh[0]; |
|
let newEndVnode = newCh[newEndIdx]; |
|
let oldKeyToIdx, idxInOld, vnodeToMove, refElm; |
|
|
|
// removeOnly is a special flag used only by <transition-group> |
|
// to ensure removed elements stay in correct relative positions |
|
// during leaving transitions |
|
const 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] |
|
: findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx); |
|
if (isUndef(idxInOld)) { // New element |
|
createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm); |
|
} else { |
|
vnodeToMove = oldCh[idxInOld]; |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && !vnodeToMove) { |
|
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(vnodeToMove, newStartVnode)) { |
|
patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue); |
|
oldCh[idxInOld] = undefined; |
|
canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm); |
|
} 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 findIdxInOld (node, oldCh, start, end) { |
|
for (let i = start; i < end; i++) { |
|
const c = oldCh[i]; |
|
if (isDef(c) && sameVnode(node, c)) return i |
|
} |
|
} |
|
|
|
function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) { |
|
if (oldVnode === vnode) { |
|
return |
|
} |
|
|
|
const 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 |
|
} |
|
|
|
let i; |
|
const data = vnode.data; |
|
if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) { |
|
i(oldVnode, vnode); |
|
} |
|
|
|
const oldCh = oldVnode.children; |
|
const 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 (let i = 0; i < queue.length; ++i) { |
|
queue[i].data.hook.insert(queue[i]); |
|
} |
|
} |
|
} |
|
|
|
let hydrationBailed = 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 |
|
// Note: style is excluded because it relies on initial clone for future |
|
// deep updates (#7063). |
|
const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key'); |
|
|
|
// Note: this is a browser-only function so we can assume elms are DOM nodes. |
|
function hydrate (elm, vnode, insertedVnodeQueue, inVPre) { |
|
let i; |
|
const { tag, data, children } = vnode; |
|
inVPre = inVPre || (data && data.pre); |
|
vnode.elm = elm; |
|
|
|
if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) { |
|
vnode.isAsyncPlaceholder = true; |
|
return true |
|
} |
|
// assert node match |
|
{ |
|
if (!assertNodeMatch(elm, vnode, inVPre)) { |
|
return false |
|
} |
|
} |
|
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 { |
|
// v-html and domProps: innerHTML |
|
if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) { |
|
if (i !== elm.innerHTML) { |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && |
|
typeof console !== 'undefined' && |
|
!hydrationBailed |
|
) { |
|
hydrationBailed = true; |
|
console.warn('Parent: ', elm); |
|
console.warn('server innerHTML: ', i); |
|
console.warn('client innerHTML: ', elm.innerHTML); |
|
} |
|
return false |
|
} |
|
} else { |
|
// iterate and compare children lists |
|
let childrenMatch = true; |
|
let childNode = elm.firstChild; |
|
for (let i = 0; i < children.length; i++) { |
|
if (!childNode || !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) { |
|
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) { |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && |
|
typeof console !== 'undefined' && |
|
!hydrationBailed |
|
) { |
|
hydrationBailed = true; |
|
console.warn('Parent: ', elm); |
|
console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children); |
|
} |
|
return false |
|
} |
|
} |
|
} |
|
} |
|
if (isDef(data)) { |
|
let fullInvoke = false; |
|
for (const key in data) { |
|
if (!isRenderedModule(key)) { |
|
fullInvoke = true; |
|
invokeCreateHooks(vnode, insertedVnodeQueue); |
|
break |
|
} |
|
} |
|
if (!fullInvoke && data['class']) { |
|
// ensure collecting deps for deep class bindings for future updates |
|
traverse(data['class']); |
|
} |
|
} |
|
} else if (elm.data !== vnode.text) { |
|
elm.data = vnode.text; |
|
} |
|
return true |
|
} |
|
|
|
function assertNodeMatch (node, vnode, inVPre) { |
|
if (isDef(vnode.tag)) { |
|
return vnode.tag.indexOf('vue-component') === 0 || ( |
|
!isUnknownElement$$1(vnode, inVPre) && |
|
vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase()) |
|
) |
|
} else { |
|
return node.nodeType === (vnode.isComment ? 8 : 3) |
|
} |
|
} |
|
|
|
return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) { |
|
if (isUndef(vnode)) { |
|
if (isDef(oldVnode)) invokeDestroyHook(oldVnode); |
|
return |
|
} |
|
|
|
let isInitialPatch = false; |
|
const insertedVnodeQueue = []; |
|
|
|
if (isUndef(oldVnode)) { |
|
// empty mount (likely as component), create new root element |
|
isInitialPatch = true; |
|
createElm(vnode, insertedVnodeQueue, parentElm, refElm); |
|
} else { |
|
const 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 { |
|
warn( |
|
'The client-side rendered virtual DOM tree is not matching ' + |
|
'server-rendered content. This is likely caused by incorrect ' + |
|
'HTML markup, for example nesting block-level elements inside ' + |
|
'<p>, or missing <tbody>. Bailing hydration and performing ' + |
|
'full client-side render.' |
|
); |
|
} |
|
} |
|
// either not server-rendered, or hydration failed. |
|
// create an empty node and replace it |
|
oldVnode = emptyNodeAt(oldVnode); |
|
} |
|
|
|
// replacing existing element |
|
const oldElm = oldVnode.elm; |
|
const parentElm = nodeOps.parentNode(oldElm); |
|
|
|
// create new node |
|
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, |
|
nodeOps.nextSibling(oldElm) |
|
); |
|
|
|
// update parent placeholder node element, recursively |
|
if (isDef(vnode.parent)) { |
|
let ancestor = vnode.parent; |
|
const patchable = isPatchable(vnode); |
|
while (ancestor) { |
|
for (let i = 0; i < cbs.destroy.length; ++i) { |
|
cbs.destroy[i](ancestor); |
|
} |
|
ancestor.elm = vnode.elm; |
|
if (patchable) { |
|
for (let i = 0; i < cbs.create.length; ++i) { |
|
cbs.create[i](emptyNode, ancestor); |
|
} |
|
// #6513 |
|
// invoke insert hooks that may have been merged by create hooks. |
|
// e.g. for directives that uses the "inserted" hook. |
|
const insert = ancestor.data.hook.insert; |
|
if (insert.merged) { |
|
// start at index 1 to avoid re-invoking component mounted hook |
|
for (let i = 1; i < insert.fns.length; i++) { |
|
insert.fns[i](); |
|
} |
|
} |
|
} else { |
|
registerRef(ancestor); |
|
} |
|
ancestor = ancestor.parent; |
|
} |
|
} |
|
|
|
// destroy old node |
|
if (isDef(parentElm)) { |
|
removeVnodes(parentElm, [oldVnode], 0, 0); |
|
} else if (isDef(oldVnode.tag)) { |
|
invokeDestroyHook(oldVnode); |
|
} |
|
} |
|
} |
|
|
|
invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); |
|
return vnode.elm |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
var directives = { |
|
create: updateDirectives, |
|
update: updateDirectives, |
|
destroy: function unbindDirectives (vnode) { |
|
updateDirectives(vnode, emptyNode); |
|
} |
|
}; |
|
|
|
function updateDirectives (oldVnode, vnode) { |
|
if (oldVnode.data.directives || vnode.data.directives) { |
|
_update(oldVnode, vnode); |
|
} |
|
} |
|
|
|
function _update (oldVnode, vnode) { |
|
const isCreate = oldVnode === emptyNode; |
|
const isDestroy = vnode === emptyNode; |
|
const oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context); |
|
const newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context); |
|
|
|
const dirsWithInsert = []; |
|
const dirsWithPostpatch = []; |
|
|
|
let key, oldDir, dir; |
|
for (key in newDirs) { |
|
oldDir = oldDirs[key]; |
|
dir = newDirs[key]; |
|
if (!oldDir) { |
|
// new directive, bind |
|
callHook$1(dir, 'bind', vnode, oldVnode); |
|
if (dir.def && dir.def.inserted) { |
|
dirsWithInsert.push(dir); |
|
} |
|
} else { |
|
// existing directive, update |
|
dir.oldValue = oldDir.value; |
|
callHook$1(dir, 'update', vnode, oldVnode); |
|
if (dir.def && dir.def.componentUpdated) { |
|
dirsWithPostpatch.push(dir); |
|
} |
|
} |
|
} |
|
|
|
if (dirsWithInsert.length) { |
|
const callInsert = () => { |
|
for (let i = 0; i < dirsWithInsert.length; i++) { |
|
callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode); |
|
} |
|
}; |
|
if (isCreate) { |
|
mergeVNodeHook(vnode, 'insert', callInsert); |
|
} else { |
|
callInsert(); |
|
} |
|
} |
|
|
|
if (dirsWithPostpatch.length) { |
|
mergeVNodeHook(vnode, 'postpatch', () => { |
|
for (let i = 0; i < dirsWithPostpatch.length; i++) { |
|
callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode); |
|
} |
|
}); |
|
} |
|
|
|
if (!isCreate) { |
|
for (key in oldDirs) { |
|
if (!newDirs[key]) { |
|
// no longer present, unbind |
|
callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy); |
|
} |
|
} |
|
} |
|
} |
|
|
|
const emptyModifiers = Object.create(null); |
|
|
|
function normalizeDirectives$1 ( |
|
dirs, |
|
vm |
|
) { |
|
const res = Object.create(null); |
|
if (!dirs) { |
|
return res |
|
} |
|
let i, dir; |
|
for (i = 0; i < dirs.length; i++) { |
|
dir = dirs[i]; |
|
if (!dir.modifiers) { |
|
dir.modifiers = emptyModifiers; |
|
} |
|
res[getRawDirName(dir)] = dir; |
|
dir.def = resolveAsset(vm.$options, 'directives', dir.name, true); |
|
} |
|
return res |
|
} |
|
|
|
function getRawDirName (dir) { |
|
return dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}` |
|
} |
|
|
|
function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) { |
|
const fn = dir.def && dir.def[hook]; |
|
if (fn) { |
|
try { |
|
fn(vnode.elm, dir, vnode, oldVnode, isDestroy); |
|
} catch (e) { |
|
handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`); |
|
} |
|
} |
|
} |
|
|
|
var baseModules = [ |
|
ref, |
|
directives |
|
]; |
|
|
|
/* */ |
|
|
|
function updateAttrs (oldVnode, vnode) { |
|
const opts = vnode.componentOptions; |
|
if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) { |
|
return |
|
} |
|
if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) { |
|
return |
|
} |
|
let key, cur, old; |
|
const elm = vnode.elm; |
|
const oldAttrs = oldVnode.data.attrs || {}; |
|
let attrs = vnode.data.attrs || {}; |
|
// clone observed objects, as the user probably wants to mutate it |
|
if (isDef(attrs.__ob__)) { |
|
attrs = vnode.data.attrs = extend({}, attrs); |
|
} |
|
|
|
for (key in attrs) { |
|
cur = attrs[key]; |
|
old = oldAttrs[key]; |
|
if (old !== cur) { |
|
setAttr(elm, key, cur); |
|
} |
|
} |
|
// #4391: in IE9, setting type can reset value for input[type=radio] |
|
// #6666: IE/Edge forces progress value down to 1 before setting a max |
|
/* istanbul ignore if */ |
|
if ((isIE9 || isEdge) && attrs.value !== oldAttrs.value) { |
|
setAttr(elm, 'value', attrs.value); |
|
} |
|
for (key in oldAttrs) { |
|
if (isUndef(attrs[key])) { |
|
if (isXlink(key)) { |
|
elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); |
|
} else if (!isEnumeratedAttr(key)) { |
|
elm.removeAttribute(key); |
|
} |
|
} |
|
} |
|
} |
|
|
|
function setAttr (el, key, value) { |
|
if (isBooleanAttr(key)) { |
|
// set attribute for blank value |
|
// e.g. <option disabled>Select one</option> |
|
if (isFalsyAttrValue(value)) { |
|
el.removeAttribute(key); |
|
} else { |
|
// technically allowfullscreen is a boolean attribute for <iframe>, |
|
// but Flash expects a value of "true" when used on <embed> tag |
|
value = key === 'allowfullscreen' && el.tagName === 'EMBED' |
|
? 'true' |
|
: key; |
|
el.setAttribute(key, value); |
|
} |
|
} else if (isEnumeratedAttr(key)) { |
|
el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true'); |
|
} else if (isXlink(key)) { |
|
if (isFalsyAttrValue(value)) { |
|
el.removeAttributeNS(xlinkNS, getXlinkProp(key)); |
|
} else { |
|
el.setAttributeNS(xlinkNS, key, value); |
|
} |
|
} else { |
|
if (isFalsyAttrValue(value)) { |
|
el.removeAttribute(key); |
|
} else { |
|
el.setAttribute(key, value); |
|
} |
|
} |
|
} |
|
|
|
var attrs = { |
|
create: updateAttrs, |
|
update: updateAttrs |
|
}; |
|
|
|
/* */ |
|
|
|
function updateClass (oldVnode, vnode) { |
|
const el = vnode.elm; |
|
const data = vnode.data; |
|
const oldData = oldVnode.data; |
|
if ( |
|
isUndef(data.staticClass) && |
|
isUndef(data.class) && ( |
|
isUndef(oldData) || ( |
|
isUndef(oldData.staticClass) && |
|
isUndef(oldData.class) |
|
) |
|
) |
|
) { |
|
return |
|
} |
|
|
|
let cls = genClassForVnode(vnode); |
|
|
|
// handle transition classes |
|
const transitionClass = el._transitionClasses; |
|
if (isDef(transitionClass)) { |
|
cls = concat(cls, stringifyClass(transitionClass)); |
|
} |
|
|
|
// set the class |
|
if (cls !== el._prevClass) { |
|
el.setAttribute('class', cls); |
|
el._prevClass = cls; |
|
} |
|
} |
|
|
|
var klass = { |
|
create: updateClass, |
|
update: updateClass |
|
}; |
|
|
|
/* */ |
|
|
|
const validDivisionCharRE = /[\w).+\-_$\]]/; |
|
|
|
function parseFilters (exp) { |
|
let inSingle = false; |
|
let inDouble = false; |
|
let inTemplateString = false; |
|
let inRegex = false; |
|
let curly = 0; |
|
let square = 0; |
|
let paren = 0; |
|
let lastFilterIndex = 0; |
|
let c, prev, i, expression, filters; |
|
|
|
for (i = 0; i < exp.length; i++) { |
|
prev = c; |
|
c = exp.charCodeAt(i); |
|
if (inSingle) { |
|
if (c === 0x27 && prev !== 0x5C) inSingle = false; |
|
} else if (inDouble) { |
|
if (c === 0x22 && prev !== 0x5C) inDouble = false; |
|
} else if (inTemplateString) { |
|
if (c === 0x60 && prev !== 0x5C) inTemplateString = false; |
|
} else if (inRegex) { |
|
if (c === 0x2f && prev !== 0x5C) inRegex = false; |
|
} else if ( |
|
c === 0x7C && // pipe |
|
exp.charCodeAt(i + 1) !== 0x7C && |
|
exp.charCodeAt(i - 1) !== 0x7C && |
|
!curly && !square && !paren |
|
) { |
|
if (expression === undefined) { |
|
// first filter, end of expression |
|
lastFilterIndex = i + 1; |
|
expression = exp.slice(0, i).trim(); |
|
} else { |
|
pushFilter(); |
|
} |
|
} else { |
|
switch (c) { |
|
case 0x22: inDouble = true; break // " |
|
case 0x27: inSingle = true; break // ' |
|
case 0x60: inTemplateString = true; break // ` |
|
case 0x28: paren++; break // ( |
|
case 0x29: paren--; break // ) |
|
case 0x5B: square++; break // [ |
|
case 0x5D: square--; break // ] |
|
case 0x7B: curly++; break // { |
|
case 0x7D: curly--; break // } |
|
} |
|
if (c === 0x2f) { // / |
|
let j = i - 1; |
|
let p; |
|
// find first non-whitespace prev char |
|
for (; j >= 0; j--) { |
|
p = exp.charAt(j); |
|
if (p !== ' ') break |
|
} |
|
if (!p || !validDivisionCharRE.test(p)) { |
|
inRegex = true; |
|
} |
|
} |
|
} |
|
} |
|
|
|
if (expression === undefined) { |
|
expression = exp.slice(0, i).trim(); |
|
} else if (lastFilterIndex !== 0) { |
|
pushFilter(); |
|
} |
|
|
|
function pushFilter () { |
|
(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); |
|
lastFilterIndex = i + 1; |
|
} |
|
|
|
if (filters) { |
|
for (i = 0; i < filters.length; i++) { |
|
expression = wrapFilter(expression, filters[i]); |
|
} |
|
} |
|
|
|
return expression |
|
} |
|
|
|
function wrapFilter (exp, filter) { |
|
const i = filter.indexOf('('); |
|
if (i < 0) { |
|
// _f: resolveFilter |
|
return `_f("${filter}")(${exp})` |
|
} else { |
|
const name = filter.slice(0, i); |
|
const args = filter.slice(i + 1); |
|
return `_f("${name}")(${exp},${args}` |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function baseWarn (msg) { |
|
console.error(`[Vue compiler]: ${msg}`); |
|
} |
|
|
|
function pluckModuleFunction ( |
|
modules, |
|
key |
|
) { |
|
return modules |
|
? modules.map(m => m[key]).filter(_ => _) |
|
: [] |
|
} |
|
|
|
function addProp (el, name, value) { |
|
(el.props || (el.props = [])).push({ name, value }); |
|
} |
|
|
|
function addAttr (el, name, value) { |
|
(el.attrs || (el.attrs = [])).push({ name, value }); |
|
} |
|
|
|
function addDirective ( |
|
el, |
|
name, |
|
rawName, |
|
value, |
|
arg, |
|
modifiers |
|
) { |
|
(el.directives || (el.directives = [])).push({ name, rawName, value, arg, modifiers }); |
|
} |
|
|
|
function addHandler ( |
|
el, |
|
name, |
|
value, |
|
modifiers, |
|
important, |
|
warn |
|
) { |
|
modifiers = modifiers || emptyObject; |
|
// warn prevent and passive modifier |
|
/* istanbul ignore if */ |
|
if ( |
|
"development" !== 'production' && warn && |
|
modifiers.prevent && modifiers.passive |
|
) { |
|
warn( |
|
'passive and prevent can\'t be used together. ' + |
|
'Passive handler can\'t prevent default event.' |
|
); |
|
} |
|
|
|
// check capture modifier |
|
if (modifiers.capture) { |
|
delete modifiers.capture; |
|
name = '!' + name; // mark the event as captured |
|
} |
|
if (modifiers.once) { |
|
delete modifiers.once; |
|
name = '~' + name; // mark the event as once |
|
} |
|
/* istanbul ignore if */ |
|
if (modifiers.passive) { |
|
delete modifiers.passive; |
|
name = '&' + name; // mark the event as passive |
|
} |
|
|
|
// normalize click.right and click.middle since they don't actually fire |
|
// this is technically browser-specific, but at least for now browsers are |
|
// the only target envs that have right/middle clicks. |
|
if (name === 'click') { |
|
if (modifiers.right) { |
|
name = 'contextmenu'; |
|
delete modifiers.right; |
|
} else if (modifiers.middle) { |
|
name = 'mouseup'; |
|
} |
|
} |
|
|
|
let events; |
|
if (modifiers.native) { |
|
delete modifiers.native; |
|
events = el.nativeEvents || (el.nativeEvents = {}); |
|
} else { |
|
events = el.events || (el.events = {}); |
|
} |
|
|
|
const newHandler = { value }; |
|
if (modifiers !== emptyObject) { |
|
newHandler.modifiers = modifiers; |
|
} |
|
|
|
const handlers = events[name]; |
|
/* istanbul ignore if */ |
|
if (Array.isArray(handlers)) { |
|
important ? handlers.unshift(newHandler) : handlers.push(newHandler); |
|
} else if (handlers) { |
|
events[name] = important ? [newHandler, handlers] : [handlers, newHandler]; |
|
} else { |
|
events[name] = newHandler; |
|
} |
|
} |
|
|
|
function getBindingAttr ( |
|
el, |
|
name, |
|
getStatic |
|
) { |
|
const dynamicValue = |
|
getAndRemoveAttr(el, ':' + name) || |
|
getAndRemoveAttr(el, 'v-bind:' + name); |
|
if (dynamicValue != null) { |
|
return parseFilters(dynamicValue) |
|
} else if (getStatic !== false) { |
|
const staticValue = getAndRemoveAttr(el, name); |
|
if (staticValue != null) { |
|
return JSON.stringify(staticValue) |
|
} |
|
} |
|
} |
|
|
|
// note: this only removes the attr from the Array (attrsList) so that it |
|
// doesn't get processed by processAttrs. |
|
// By default it does NOT remove it from the map (attrsMap) because the map is |
|
// needed during codegen. |
|
function getAndRemoveAttr ( |
|
el, |
|
name, |
|
removeFromMap |
|
) { |
|
let val; |
|
if ((val = el.attrsMap[name]) != null) { |
|
const list = el.attrsList; |
|
for (let i = 0, l = list.length; i < l; i++) { |
|
if (list[i].name === name) { |
|
list.splice(i, 1); |
|
break |
|
} |
|
} |
|
} |
|
if (removeFromMap) { |
|
delete el.attrsMap[name]; |
|
} |
|
return val |
|
} |
|
|
|
/* */ |
|
|
|
/** |
|
* Cross-platform code generation for component v-model |
|
*/ |
|
function genComponentModel ( |
|
el, |
|
value, |
|
modifiers |
|
) { |
|
const { number, trim } = modifiers || {}; |
|
|
|
const baseValueExpression = '$$v'; |
|
let valueExpression = baseValueExpression; |
|
if (trim) { |
|
valueExpression = |
|
`(typeof ${baseValueExpression} === 'string'` + |
|
`? ${baseValueExpression}.trim()` + |
|
`: ${baseValueExpression})`; |
|
} |
|
if (number) { |
|
valueExpression = `_n(${valueExpression})`; |
|
} |
|
const assignment = genAssignmentCode(value, valueExpression); |
|
|
|
el.model = { |
|
value: `(${value})`, |
|
expression: `"${value}"`, |
|
callback: `function (${baseValueExpression}) {${assignment}}` |
|
}; |
|
} |
|
|
|
/** |
|
* Cross-platform codegen helper for generating v-model value assignment code. |
|
*/ |
|
function genAssignmentCode ( |
|
value, |
|
assignment |
|
) { |
|
const res = parseModel(value); |
|
if (res.key === null) { |
|
return `${value}=${assignment}` |
|
} else { |
|
return `$set(${res.exp}, ${res.key}, ${assignment})` |
|
} |
|
} |
|
|
|
/** |
|
* Parse a v-model expression into a base path and a final key segment. |
|
* Handles both dot-path and possible square brackets. |
|
* |
|
* Possible cases: |
|
* |
|
* - test |
|
* - test[key] |
|
* - test[test1[key]] |
|
* - test["a"][key] |
|
* - xxx.test[a[a].test1[key]] |
|
* - test.xxx.a["asa"][test1[key]] |
|
* |
|
*/ |
|
|
|
let len; |
|
let str; |
|
let chr; |
|
let index$1; |
|
let expressionPos; |
|
let expressionEndPos; |
|
|
|
|
|
|
|
function parseModel (val) { |
|
len = val.length; |
|
|
|
if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) { |
|
index$1 = val.lastIndexOf('.'); |
|
if (index$1 > -1) { |
|
return { |
|
exp: val.slice(0, index$1), |
|
key: '"' + val.slice(index$1 + 1) + '"' |
|
} |
|
} else { |
|
return { |
|
exp: val, |
|
key: null |
|
} |
|
} |
|
} |
|
|
|
str = val; |
|
index$1 = expressionPos = expressionEndPos = 0; |
|
|
|
while (!eof()) { |
|
chr = next(); |
|
/* istanbul ignore if */ |
|
if (isStringStart(chr)) { |
|
parseString(chr); |
|
} else if (chr === 0x5B) { |
|
parseBracket(chr); |
|
} |
|
} |
|
|
|
return { |
|
exp: val.slice(0, expressionPos), |
|
key: val.slice(expressionPos + 1, expressionEndPos) |
|
} |
|
} |
|
|
|
function next () { |
|
return str.charCodeAt(++index$1) |
|
} |
|
|
|
function eof () { |
|
return index$1 >= len |
|
} |
|
|
|
function isStringStart (chr) { |
|
return chr === 0x22 || chr === 0x27 |
|
} |
|
|
|
function parseBracket (chr) { |
|
let inBracket = 1; |
|
expressionPos = index$1; |
|
while (!eof()) { |
|
chr = next(); |
|
if (isStringStart(chr)) { |
|
parseString(chr); |
|
continue |
|
} |
|
if (chr === 0x5B) inBracket++; |
|
if (chr === 0x5D) inBracket--; |
|
if (inBracket === 0) { |
|
expressionEndPos = index$1; |
|
break |
|
} |
|
} |
|
} |
|
|
|
function parseString (chr) { |
|
const stringQuote = chr; |
|
while (!eof()) { |
|
chr = next(); |
|
if (chr === stringQuote) { |
|
break |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
let warn$1; |
|
|
|
// in some cases, the event used has to be determined at runtime |
|
// so we used some reserved tokens during compile. |
|
const RANGE_TOKEN = '__r'; |
|
const CHECKBOX_RADIO_TOKEN = '__c'; |
|
|
|
function model ( |
|
el, |
|
dir, |
|
_warn |
|
) { |
|
warn$1 = _warn; |
|
const value = dir.value; |
|
const modifiers = dir.modifiers; |
|
const tag = el.tag; |
|
const type = el.attrsMap.type; |
|
|
|
{ |
|
// inputs with type="file" are read only and setting the input's |
|
// value will throw an error. |
|
if (tag === 'input' && type === 'file') { |
|
warn$1( |
|
`<${el.tag} v-model="${value}" type="file">:\n` + |
|
`File inputs are read only. Use a v-on:change listener instead.` |
|
); |
|
} |
|
} |
|
|
|
if (el.component) { |
|
genComponentModel(el, value, modifiers); |
|
// component v-model doesn't need extra runtime |
|
return false |
|
} else if (tag === 'select') { |
|
genSelect(el, value, modifiers); |
|
} else if (tag === 'input' && type === 'checkbox') { |
|
genCheckboxModel(el, value, modifiers); |
|
} else if (tag === 'input' && type === 'radio') { |
|
genRadioModel(el, value, modifiers); |
|
} else if (tag === 'input' || tag === 'textarea') { |
|
genDefaultModel(el, value, modifiers); |
|
} else if (!config.isReservedTag(tag)) { |
|
genComponentModel(el, value, modifiers); |
|
// component v-model doesn't need extra runtime |
|
return false |
|
} else { |
|
warn$1( |
|
`<${el.tag} v-model="${value}">: ` + |
|
`v-model is not supported on this element type. ` + |
|
'If you are working with contenteditable, it\'s recommended to ' + |
|
'wrap a library dedicated for that purpose inside a custom component.' |
|
); |
|
} |
|
|
|
// ensure runtime directive metadata |
|
return true |
|
} |
|
|
|
function genCheckboxModel ( |
|
el, |
|
value, |
|
modifiers |
|
) { |
|
const number = modifiers && modifiers.number; |
|
const valueBinding = getBindingAttr(el, 'value') || 'null'; |
|
const trueValueBinding = getBindingAttr(el, 'true-value') || 'true'; |
|
const falseValueBinding = getBindingAttr(el, 'false-value') || 'false'; |
|
addProp(el, 'checked', |
|
`Array.isArray(${value})` + |
|
`?_i(${value},${valueBinding})>-1` + ( |
|
trueValueBinding === 'true' |
|
? `:(${value})` |
|
: `:_q(${value},${trueValueBinding})` |
|
) |
|
); |
|
addHandler(el, 'change', |
|
`var $$a=${value},` + |
|
'$$el=$event.target,' + |
|
`$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` + |
|
'if(Array.isArray($$a)){' + |
|
`var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` + |
|
'$$i=_i($$a,$$v);' + |
|
`if($$el.checked){$$i<0&&(${value}=$$a.concat([$$v]))}` + |
|
`else{$$i>-1&&(${value}=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}` + |
|
`}else{${genAssignmentCode(value, '$$c')}}`, |
|
null, true |
|
); |
|
} |
|
|
|
function genRadioModel ( |
|
el, |
|
value, |
|
modifiers |
|
) { |
|
const number = modifiers && modifiers.number; |
|
let valueBinding = getBindingAttr(el, 'value') || 'null'; |
|
valueBinding = number ? `_n(${valueBinding})` : valueBinding; |
|
addProp(el, 'checked', `_q(${value},${valueBinding})`); |
|
addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true); |
|
} |
|
|
|
function genSelect ( |
|
el, |
|
value, |
|
modifiers |
|
) { |
|
const number = modifiers && modifiers.number; |
|
const selectedVal = `Array.prototype.filter` + |
|
`.call($event.target.options,function(o){return o.selected})` + |
|
`.map(function(o){var val = "_value" in o ? o._value : o.value;` + |
|
`return ${number ? '_n(val)' : 'val'}})`; |
|
|
|
const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'; |
|
let code = `var $$selectedVal = ${selectedVal};`; |
|
code = `${code} ${genAssignmentCode(value, assignment)}`; |
|
addHandler(el, 'change', code, null, true); |
|
} |
|
|
|
function genDefaultModel ( |
|
el, |
|
value, |
|
modifiers |
|
) { |
|
const type = el.attrsMap.type; |
|
|
|
// warn if v-bind:value conflicts with v-model |
|
{ |
|
const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value']; |
|
if (value) { |
|
const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'; |
|
warn$1( |
|
`${binding}="${value}" conflicts with v-model on the same element ` + |
|
'because the latter already expands to a value binding internally' |
|
); |
|
} |
|
} |
|
|
|
const { lazy, number, trim } = modifiers || {}; |
|
const needCompositionGuard = !lazy && type !== 'range'; |
|
const event = lazy |
|
? 'change' |
|
: type === 'range' |
|
? RANGE_TOKEN |
|
: 'input'; |
|
|
|
let valueExpression = '$event.target.value'; |
|
if (trim) { |
|
valueExpression = `$event.target.value.trim()`; |
|
} |
|
if (number) { |
|
valueExpression = `_n(${valueExpression})`; |
|
} |
|
|
|
let code = genAssignmentCode(value, valueExpression); |
|
if (needCompositionGuard) { |
|
code = `if($event.target.composing)return;${code}`; |
|
} |
|
|
|
addProp(el, 'value', `(${value})`); |
|
addHandler(el, event, code, null, true); |
|
if (trim || number) { |
|
addHandler(el, 'blur', '$forceUpdate()'); |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
// normalize v-model event tokens that can only be determined at runtime. |
|
// it's important to place the event as the first in the array because |
|
// the whole point is ensuring the v-model callback gets called before |
|
// user-attached handlers. |
|
function normalizeEvents (on) { |
|
/* istanbul ignore if */ |
|
if (isDef(on[RANGE_TOKEN])) { |
|
// IE input[type=range] only supports `change` event |
|
const event = isIE ? 'change' : 'input'; |
|
on[event] = [].concat(on[RANGE_TOKEN], on[event] || []); |
|
delete on[RANGE_TOKEN]; |
|
} |
|
// This was originally intended to fix #4521 but no longer necessary |
|
// after 2.5. Keeping it for backwards compat with generated code from < 2.4 |
|
/* istanbul ignore if */ |
|
if (isDef(on[CHECKBOX_RADIO_TOKEN])) { |
|
on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []); |
|
delete on[CHECKBOX_RADIO_TOKEN]; |
|
} |
|
} |
|
|
|
let target$1; |
|
|
|
function createOnceHandler (handler, event, capture) { |
|
const _target = target$1; // save current target element in closure |
|
return function onceHandler () { |
|
const res = handler.apply(null, arguments); |
|
if (res !== null) { |
|
remove$2(event, onceHandler, capture, _target); |
|
} |
|
} |
|
} |
|
|
|
function add$1 ( |
|
event, |
|
handler, |
|
once$$1, |
|
capture, |
|
passive |
|
) { |
|
handler = withMacroTask(handler); |
|
if (once$$1) handler = createOnceHandler(handler, event, capture); |
|
target$1.addEventListener( |
|
event, |
|
handler, |
|
supportsPassive |
|
? { capture, passive } |
|
: capture |
|
); |
|
} |
|
|
|
function remove$2 ( |
|
event, |
|
handler, |
|
capture, |
|
_target |
|
) { |
|
(_target || target$1).removeEventListener( |
|
event, |
|
handler._withTask || handler, |
|
capture |
|
); |
|
} |
|
|
|
function updateDOMListeners (oldVnode, vnode) { |
|
if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) { |
|
return |
|
} |
|
const on = vnode.data.on || {}; |
|
const oldOn = oldVnode.data.on || {}; |
|
target$1 = vnode.elm; |
|
normalizeEvents(on); |
|
updateListeners(on, oldOn, add$1, remove$2, vnode.context); |
|
target$1 = undefined; |
|
} |
|
|
|
var events = { |
|
create: updateDOMListeners, |
|
update: updateDOMListeners |
|
}; |
|
|
|
/* */ |
|
|
|
function updateDOMProps (oldVnode, vnode) { |
|
if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) { |
|
return |
|
} |
|
let key, cur; |
|
const elm = vnode.elm; |
|
const oldProps = oldVnode.data.domProps || {}; |
|
let props = vnode.data.domProps || {}; |
|
// clone observed objects, as the user probably wants to mutate it |
|
if (isDef(props.__ob__)) { |
|
props = vnode.data.domProps = extend({}, props); |
|
} |
|
|
|
for (key in oldProps) { |
|
if (isUndef(props[key])) { |
|
elm[key] = ''; |
|
} |
|
} |
|
for (key in props) { |
|
cur = props[key]; |
|
// ignore children if the node has textContent or innerHTML, |
|
// as these will throw away existing DOM nodes and cause removal errors |
|
// on subsequent patches (#3360) |
|
if (key === 'textContent' || key === 'innerHTML') { |
|
if (vnode.children) vnode.children.length = 0; |
|
if (cur === oldProps[key]) continue |
|
// #6601 work around Chrome version <= 55 bug where single textNode |
|
// replaced by innerHTML/textContent retains its parentNode property |
|
if (elm.childNodes.length === 1) { |
|
elm.removeChild(elm.childNodes[0]); |
|
} |
|
} |
|
|
|
if (key === 'value') { |
|
// store value as _value as well since |
|
// non-string values will be stringified |
|
elm._value = cur; |
|
// avoid resetting cursor position when value is the same |
|
const strCur = isUndef(cur) ? '' : String(cur); |
|
if (shouldUpdateValue(elm, strCur)) { |
|
elm.value = strCur; |
|
} |
|
} else { |
|
elm[key] = cur; |
|
} |
|
} |
|
} |
|
|
|
// check platforms/web/util/attrs.js acceptValue |
|
|
|
|
|
function shouldUpdateValue (elm, checkVal) { |
|
return (!elm.composing && ( |
|
elm.tagName === 'OPTION' || |
|
isDirty(elm, checkVal) || |
|
isInputChanged(elm, checkVal) |
|
)) |
|
} |
|
|
|
function isDirty (elm, checkVal) { |
|
// return true when textbox (.number and .trim) loses focus and its value is |
|
// not equal to the updated value |
|
let notInFocus = true; |
|
// #6157 |
|
// work around IE bug when accessing document.activeElement in an iframe |
|
try { notInFocus = document.activeElement !== elm; } catch (e) {} |
|
return notInFocus && elm.value !== checkVal |
|
} |
|
|
|
function isInputChanged (elm, newVal) { |
|
const value = elm.value; |
|
const modifiers = elm._vModifiers; // injected by v-model runtime |
|
if (isDef(modifiers) && modifiers.number) { |
|
return toNumber(value) !== toNumber(newVal) |
|
} |
|
if (isDef(modifiers) && modifiers.trim) { |
|
return value.trim() !== newVal.trim() |
|
} |
|
return value !== newVal |
|
} |
|
|
|
var domProps = { |
|
create: updateDOMProps, |
|
update: updateDOMProps |
|
}; |
|
|
|
/* */ |
|
|
|
const parseStyleText = cached(function (cssText) { |
|
const res = {}; |
|
const listDelimiter = /;(?![^(]*\))/g; |
|
const propertyDelimiter = /:(.+)/; |
|
cssText.split(listDelimiter).forEach(function (item) { |
|
if (item) { |
|
var tmp = item.split(propertyDelimiter); |
|
tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); |
|
} |
|
}); |
|
return res |
|
}); |
|
|
|
// merge static and dynamic style data on the same vnode |
|
function normalizeStyleData (data) { |
|
const style = normalizeStyleBinding(data.style); |
|
// static style is pre-processed into an object during compilation |
|
// and is always a fresh object, so it's safe to merge into it |
|
return data.staticStyle |
|
? extend(data.staticStyle, style) |
|
: style |
|
} |
|
|
|
// normalize possible array / string values into Object |
|
function normalizeStyleBinding (bindingStyle) { |
|
if (Array.isArray(bindingStyle)) { |
|
return toObject(bindingStyle) |
|
} |
|
if (typeof bindingStyle === 'string') { |
|
return parseStyleText(bindingStyle) |
|
} |
|
return bindingStyle |
|
} |
|
|
|
/** |
|
* parent component style should be after child's |
|
* so that parent component's style could override it |
|
*/ |
|
function getStyle (vnode, checkChild) { |
|
const res = {}; |
|
let styleData; |
|
|
|
if (checkChild) { |
|
let childNode = vnode; |
|
while (childNode.componentInstance) { |
|
childNode = childNode.componentInstance._vnode; |
|
if (childNode.data && (styleData = normalizeStyleData(childNode.data))) { |
|
extend(res, styleData); |
|
} |
|
} |
|
} |
|
|
|
if ((styleData = normalizeStyleData(vnode.data))) { |
|
extend(res, styleData); |
|
} |
|
|
|
let parentNode = vnode; |
|
while ((parentNode = parentNode.parent)) { |
|
if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) { |
|
extend(res, styleData); |
|
} |
|
} |
|
return res |
|
} |
|
|
|
/* */ |
|
|
|
const cssVarRE = /^--/; |
|
const importantRE = /\s*!important$/; |
|
const setProp = (el, name, val) => { |
|
/* istanbul ignore if */ |
|
if (cssVarRE.test(name)) { |
|
el.style.setProperty(name, val); |
|
} else if (importantRE.test(val)) { |
|
el.style.setProperty(name, val.replace(importantRE, ''), 'important'); |
|
} else { |
|
const normalizedName = normalize(name); |
|
if (Array.isArray(val)) { |
|
// Support values array created by autoprefixer, e.g. |
|
// {display: ["-webkit-box", "-ms-flexbox", "flex"]} |
|
// Set them one by one, and the browser will only set those it can recognize |
|
for (let i = 0, len = val.length; i < len; i++) { |
|
el.style[normalizedName] = val[i]; |
|
} |
|
} else { |
|
el.style[normalizedName] = val; |
|
} |
|
} |
|
}; |
|
|
|
const vendorNames = ['Webkit', 'Moz', 'ms']; |
|
|
|
let emptyStyle; |
|
const normalize = cached(function (prop) { |
|
emptyStyle = emptyStyle || document.createElement('div').style; |
|
prop = camelize(prop); |
|
if (prop !== 'filter' && (prop in emptyStyle)) { |
|
return prop |
|
} |
|
const capName = prop.charAt(0).toUpperCase() + prop.slice(1); |
|
for (let i = 0; i < vendorNames.length; i++) { |
|
const name = vendorNames[i] + capName; |
|
if (name in emptyStyle) { |
|
return name |
|
} |
|
} |
|
}); |
|
|
|
function updateStyle (oldVnode, vnode) { |
|
const data = vnode.data; |
|
const oldData = oldVnode.data; |
|
|
|
if (isUndef(data.staticStyle) && isUndef(data.style) && |
|
isUndef(oldData.staticStyle) && isUndef(oldData.style) |
|
) { |
|
return |
|
} |
|
|
|
let cur, name; |
|
const el = vnode.elm; |
|
const oldStaticStyle = oldData.staticStyle; |
|
const oldStyleBinding = oldData.normalizedStyle || oldData.style || {}; |
|
|
|
// if static style exists, stylebinding already merged into it when doing normalizeStyleData |
|
const oldStyle = oldStaticStyle || oldStyleBinding; |
|
|
|
const style = normalizeStyleBinding(vnode.data.style) || {}; |
|
|
|
// store normalized style under a different key for next diff |
|
// make sure to clone it if it's reactive, since the user likely wants |
|
// to mutate it. |
|
vnode.data.normalizedStyle = isDef(style.__ob__) |
|
? extend({}, style) |
|
: style; |
|
|
|
const newStyle = getStyle(vnode, true); |
|
|
|
for (name in oldStyle) { |
|
if (isUndef(newStyle[name])) { |
|
setProp(el, name, ''); |
|
} |
|
} |
|
for (name in newStyle) { |
|
cur = newStyle[name]; |
|
if (cur !== oldStyle[name]) { |
|
// ie9 setting to null has no effect, must use empty string |
|
setProp(el, name, cur == null ? '' : cur); |
|
} |
|
} |
|
} |
|
|
|
var style = { |
|
create: updateStyle, |
|
update: updateStyle |
|
}; |
|
|
|
/* */ |
|
|
|
/** |
|
* Add class with compatibility for SVG since classList is not supported on |
|
* SVG elements in IE |
|
*/ |
|
function addClass (el, cls) { |
|
/* istanbul ignore if */ |
|
if (!cls || !(cls = cls.trim())) { |
|
return |
|
} |
|
|
|
/* istanbul ignore else */ |
|
if (el.classList) { |
|
if (cls.indexOf(' ') > -1) { |
|
cls.split(/\s+/).forEach(c => el.classList.add(c)); |
|
} else { |
|
el.classList.add(cls); |
|
} |
|
} else { |
|
const cur = ` ${el.getAttribute('class') || ''} `; |
|
if (cur.indexOf(' ' + cls + ' ') < 0) { |
|
el.setAttribute('class', (cur + cls).trim()); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Remove class with compatibility for SVG since classList is not supported on |
|
* SVG elements in IE |
|
*/ |
|
function removeClass (el, cls) { |
|
/* istanbul ignore if */ |
|
if (!cls || !(cls = cls.trim())) { |
|
return |
|
} |
|
|
|
/* istanbul ignore else */ |
|
if (el.classList) { |
|
if (cls.indexOf(' ') > -1) { |
|
cls.split(/\s+/).forEach(c => el.classList.remove(c)); |
|
} else { |
|
el.classList.remove(cls); |
|
} |
|
if (!el.classList.length) { |
|
el.removeAttribute('class'); |
|
} |
|
} else { |
|
let cur = ` ${el.getAttribute('class') || ''} `; |
|
const tar = ' ' + cls + ' '; |
|
while (cur.indexOf(tar) >= 0) { |
|
cur = cur.replace(tar, ' '); |
|
} |
|
cur = cur.trim(); |
|
if (cur) { |
|
el.setAttribute('class', cur); |
|
} else { |
|
el.removeAttribute('class'); |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function resolveTransition (def) { |
|
if (!def) { |
|
return |
|
} |
|
/* istanbul ignore else */ |
|
if (typeof def === 'object') { |
|
const res = {}; |
|
if (def.css !== false) { |
|
extend(res, autoCssTransition(def.name || 'v')); |
|
} |
|
extend(res, def); |
|
return res |
|
} else if (typeof def === 'string') { |
|
return autoCssTransition(def) |
|
} |
|
} |
|
|
|
const autoCssTransition = cached(name => { |
|
return { |
|
enterClass: `${name}-enter`, |
|
enterToClass: `${name}-enter-to`, |
|
enterActiveClass: `${name}-enter-active`, |
|
leaveClass: `${name}-leave`, |
|
leaveToClass: `${name}-leave-to`, |
|
leaveActiveClass: `${name}-leave-active` |
|
} |
|
}); |
|
|
|
const hasTransition = inBrowser && !isIE9; |
|
const TRANSITION = 'transition'; |
|
const ANIMATION = 'animation'; |
|
|
|
// Transition property/event sniffing |
|
let transitionProp = 'transition'; |
|
let transitionEndEvent = 'transitionend'; |
|
let animationProp = 'animation'; |
|
let animationEndEvent = 'animationend'; |
|
if (hasTransition) { |
|
/* istanbul ignore if */ |
|
if (window.ontransitionend === undefined && |
|
window.onwebkittransitionend !== undefined |
|
) { |
|
transitionProp = 'WebkitTransition'; |
|
transitionEndEvent = 'webkitTransitionEnd'; |
|
} |
|
if (window.onanimationend === undefined && |
|
window.onwebkitanimationend !== undefined |
|
) { |
|
animationProp = 'WebkitAnimation'; |
|
animationEndEvent = 'webkitAnimationEnd'; |
|
} |
|
} |
|
|
|
// binding to window is necessary to make hot reload work in IE in strict mode |
|
const raf = inBrowser |
|
? window.requestAnimationFrame |
|
? window.requestAnimationFrame.bind(window) |
|
: setTimeout |
|
: /* istanbul ignore next */ fn => fn(); |
|
|
|
function nextFrame (fn) { |
|
raf(() => { |
|
raf(fn); |
|
}); |
|
} |
|
|
|
function addTransitionClass (el, cls) { |
|
const transitionClasses = el._transitionClasses || (el._transitionClasses = []); |
|
if (transitionClasses.indexOf(cls) < 0) { |
|
transitionClasses.push(cls); |
|
addClass(el, cls); |
|
} |
|
} |
|
|
|
function removeTransitionClass (el, cls) { |
|
if (el._transitionClasses) { |
|
remove(el._transitionClasses, cls); |
|
} |
|
removeClass(el, cls); |
|
} |
|
|
|
function whenTransitionEnds ( |
|
el, |
|
expectedType, |
|
cb |
|
) { |
|
const { type, timeout, propCount } = getTransitionInfo(el, expectedType); |
|
if (!type) return cb() |
|
const event = type === TRANSITION ? transitionEndEvent : animationEndEvent; |
|
let ended = 0; |
|
const end = () => { |
|
el.removeEventListener(event, onEnd); |
|
cb(); |
|
}; |
|
const onEnd = e => { |
|
if (e.target === el) { |
|
if (++ended >= propCount) { |
|
end(); |
|
} |
|
} |
|
}; |
|
setTimeout(() => { |
|
if (ended < propCount) { |
|
end(); |
|
} |
|
}, timeout + 1); |
|
el.addEventListener(event, onEnd); |
|
} |
|
|
|
const transformRE = /\b(transform|all)(,|$)/; |
|
|
|
function getTransitionInfo (el, expectedType) { |
|
const styles = window.getComputedStyle(el); |
|
const transitionDelays = styles[transitionProp + 'Delay'].split(', '); |
|
const transitionDurations = styles[transitionProp + 'Duration'].split(', '); |
|
const transitionTimeout = getTimeout(transitionDelays, transitionDurations); |
|
const animationDelays = styles[animationProp + 'Delay'].split(', '); |
|
const animationDurations = styles[animationProp + 'Duration'].split(', '); |
|
const animationTimeout = getTimeout(animationDelays, animationDurations); |
|
|
|
let type; |
|
let timeout = 0; |
|
let propCount = 0; |
|
/* istanbul ignore if */ |
|
if (expectedType === TRANSITION) { |
|
if (transitionTimeout > 0) { |
|
type = TRANSITION; |
|
timeout = transitionTimeout; |
|
propCount = transitionDurations.length; |
|
} |
|
} else if (expectedType === ANIMATION) { |
|
if (animationTimeout > 0) { |
|
type = ANIMATION; |
|
timeout = animationTimeout; |
|
propCount = animationDurations.length; |
|
} |
|
} else { |
|
timeout = Math.max(transitionTimeout, animationTimeout); |
|
type = timeout > 0 |
|
? transitionTimeout > animationTimeout |
|
? TRANSITION |
|
: ANIMATION |
|
: null; |
|
propCount = type |
|
? type === TRANSITION |
|
? transitionDurations.length |
|
: animationDurations.length |
|
: 0; |
|
} |
|
const hasTransform = |
|
type === TRANSITION && |
|
transformRE.test(styles[transitionProp + 'Property']); |
|
return { |
|
type, |
|
timeout, |
|
propCount, |
|
hasTransform |
|
} |
|
} |
|
|
|
function getTimeout (delays, durations) { |
|
/* istanbul ignore next */ |
|
while (delays.length < durations.length) { |
|
delays = delays.concat(delays); |
|
} |
|
|
|
return Math.max.apply(null, durations.map((d, i) => { |
|
return toMs(d) + toMs(delays[i]) |
|
})) |
|
} |
|
|
|
function toMs (s) { |
|
return Number(s.slice(0, -1)) * 1000 |
|
} |
|
|
|
/* */ |
|
|
|
function enter (vnode, toggleDisplay) { |
|
const el = vnode.elm; |
|
|
|
// call leave callback now |
|
if (isDef(el._leaveCb)) { |
|
el._leaveCb.cancelled = true; |
|
el._leaveCb(); |
|
} |
|
|
|
const data = resolveTransition(vnode.data.transition); |
|
if (isUndef(data)) { |
|
return |
|
} |
|
|
|
/* istanbul ignore if */ |
|
if (isDef(el._enterCb) || el.nodeType !== 1) { |
|
return |
|
} |
|
|
|
const { |
|
css, |
|
type, |
|
enterClass, |
|
enterToClass, |
|
enterActiveClass, |
|
appearClass, |
|
appearToClass, |
|
appearActiveClass, |
|
beforeEnter, |
|
enter, |
|
afterEnter, |
|
enterCancelled, |
|
beforeAppear, |
|
appear, |
|
afterAppear, |
|
appearCancelled, |
|
duration |
|
} = data; |
|
|
|
// activeInstance will always be the <transition> component managing this |
|
// transition. One edge case to check is when the <transition> is placed |
|
// as the root node of a child component. In that case we need to check |
|
// <transition>'s parent for appear check. |
|
let context = activeInstance; |
|
let transitionNode = activeInstance.$vnode; |
|
while (transitionNode && transitionNode.parent) { |
|
transitionNode = transitionNode.parent; |
|
context = transitionNode.context; |
|
} |
|
|
|
const isAppear = !context._isMounted || !vnode.isRootInsert; |
|
|
|
if (isAppear && !appear && appear !== '') { |
|
return |
|
} |
|
|
|
const startClass = isAppear && appearClass |
|
? appearClass |
|
: enterClass; |
|
const activeClass = isAppear && appearActiveClass |
|
? appearActiveClass |
|
: enterActiveClass; |
|
const toClass = isAppear && appearToClass |
|
? appearToClass |
|
: enterToClass; |
|
|
|
const beforeEnterHook = isAppear |
|
? (beforeAppear || beforeEnter) |
|
: beforeEnter; |
|
const enterHook = isAppear |
|
? (typeof appear === 'function' ? appear : enter) |
|
: enter; |
|
const afterEnterHook = isAppear |
|
? (afterAppear || afterEnter) |
|
: afterEnter; |
|
const enterCancelledHook = isAppear |
|
? (appearCancelled || enterCancelled) |
|
: enterCancelled; |
|
|
|
const explicitEnterDuration = toNumber( |
|
isObject(duration) |
|
? duration.enter |
|
: duration |
|
); |
|
|
|
if ("development" !== 'production' && explicitEnterDuration != null) { |
|
checkDuration(explicitEnterDuration, 'enter', vnode); |
|
} |
|
|
|
const expectsCSS = css !== false && !isIE9; |
|
const userWantsControl = getHookArgumentsLength(enterHook); |
|
|
|
const cb = el._enterCb = once(() => { |
|
if (expectsCSS) { |
|
removeTransitionClass(el, toClass); |
|
removeTransitionClass(el, activeClass); |
|
} |
|
if (cb.cancelled) { |
|
if (expectsCSS) { |
|
removeTransitionClass(el, startClass); |
|
} |
|
enterCancelledHook && enterCancelledHook(el); |
|
} else { |
|
afterEnterHook && afterEnterHook(el); |
|
} |
|
el._enterCb = null; |
|
}); |
|
|
|
if (!vnode.data.show) { |
|
// remove pending leave element on enter by injecting an insert hook |
|
mergeVNodeHook(vnode, 'insert', () => { |
|
const parent = el.parentNode; |
|
const pendingNode = parent && parent._pending && parent._pending[vnode.key]; |
|
if (pendingNode && |
|
pendingNode.tag === vnode.tag && |
|
pendingNode.elm._leaveCb |
|
) { |
|
pendingNode.elm._leaveCb(); |
|
} |
|
enterHook && enterHook(el, cb); |
|
}); |
|
} |
|
|
|
// start enter transition |
|
beforeEnterHook && beforeEnterHook(el); |
|
if (expectsCSS) { |
|
addTransitionClass(el, startClass); |
|
addTransitionClass(el, activeClass); |
|
nextFrame(() => { |
|
addTransitionClass(el, toClass); |
|
removeTransitionClass(el, startClass); |
|
if (!cb.cancelled && !userWantsControl) { |
|
if (isValidDuration(explicitEnterDuration)) { |
|
setTimeout(cb, explicitEnterDuration); |
|
} else { |
|
whenTransitionEnds(el, type, cb); |
|
} |
|
} |
|
}); |
|
} |
|
|
|
if (vnode.data.show) { |
|
toggleDisplay && toggleDisplay(); |
|
enterHook && enterHook(el, cb); |
|
} |
|
|
|
if (!expectsCSS && !userWantsControl) { |
|
cb(); |
|
} |
|
} |
|
|
|
function leave (vnode, rm) { |
|
const el = vnode.elm; |
|
|
|
// call enter callback now |
|
if (isDef(el._enterCb)) { |
|
el._enterCb.cancelled = true; |
|
el._enterCb(); |
|
} |
|
|
|
const data = resolveTransition(vnode.data.transition); |
|
if (isUndef(data) || el.nodeType !== 1) { |
|
return rm() |
|
} |
|
|
|
/* istanbul ignore if */ |
|
if (isDef(el._leaveCb)) { |
|
return |
|
} |
|
|
|
const { |
|
css, |
|
type, |
|
leaveClass, |
|
leaveToClass, |
|
leaveActiveClass, |
|
beforeLeave, |
|
leave, |
|
afterLeave, |
|
leaveCancelled, |
|
delayLeave, |
|
duration |
|
} = data; |
|
|
|
const expectsCSS = css !== false && !isIE9; |
|
const userWantsControl = getHookArgumentsLength(leave); |
|
|
|
const explicitLeaveDuration = toNumber( |
|
isObject(duration) |
|
? duration.leave |
|
: duration |
|
); |
|
|
|
if ("development" !== 'production' && isDef(explicitLeaveDuration)) { |
|
checkDuration(explicitLeaveDuration, 'leave', vnode); |
|
} |
|
|
|
const cb = el._leaveCb = once(() => { |
|
if (el.parentNode && el.parentNode._pending) { |
|
el.parentNode._pending[vnode.key] = null; |
|
} |
|
if (expectsCSS) { |
|
removeTransitionClass(el, leaveToClass); |
|
removeTransitionClass(el, leaveActiveClass); |
|
} |
|
if (cb.cancelled) { |
|
if (expectsCSS) { |
|
removeTransitionClass(el, leaveClass); |
|
} |
|
leaveCancelled && leaveCancelled(el); |
|
} else { |
|
rm(); |
|
afterLeave && afterLeave(el); |
|
} |
|
el._leaveCb = null; |
|
}); |
|
|
|
if (delayLeave) { |
|
delayLeave(performLeave); |
|
} else { |
|
performLeave(); |
|
} |
|
|
|
function performLeave () { |
|
// the delayed leave may have already been cancelled |
|
if (cb.cancelled) { |
|
return |
|
} |
|
// record leaving element |
|
if (!vnode.data.show) { |
|
(el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode; |
|
} |
|
beforeLeave && beforeLeave(el); |
|
if (expectsCSS) { |
|
addTransitionClass(el, leaveClass); |
|
addTransitionClass(el, leaveActiveClass); |
|
nextFrame(() => { |
|
addTransitionClass(el, leaveToClass); |
|
removeTransitionClass(el, leaveClass); |
|
if (!cb.cancelled && !userWantsControl) { |
|
if (isValidDuration(explicitLeaveDuration)) { |
|
setTimeout(cb, explicitLeaveDuration); |
|
} else { |
|
whenTransitionEnds(el, type, cb); |
|
} |
|
} |
|
}); |
|
} |
|
leave && leave(el, cb); |
|
if (!expectsCSS && !userWantsControl) { |
|
cb(); |
|
} |
|
} |
|
} |
|
|
|
// only used in dev mode |
|
function checkDuration (val, name, vnode) { |
|
if (typeof val !== 'number') { |
|
warn( |
|
`<transition> explicit ${name} duration is not a valid number - ` + |
|
`got ${JSON.stringify(val)}.`, |
|
vnode.context |
|
); |
|
} else if (isNaN(val)) { |
|
warn( |
|
`<transition> explicit ${name} duration is NaN - ` + |
|
'the duration expression might be incorrect.', |
|
vnode.context |
|
); |
|
} |
|
} |
|
|
|
function isValidDuration (val) { |
|
return typeof val === 'number' && !isNaN(val) |
|
} |
|
|
|
/** |
|
* Normalize a transition hook's argument length. The hook may be: |
|
* - a merged hook (invoker) with the original in .fns |
|
* - a wrapped component method (check ._length) |
|
* - a plain function (.length) |
|
*/ |
|
function getHookArgumentsLength (fn) { |
|
if (isUndef(fn)) { |
|
return false |
|
} |
|
const invokerFns = fn.fns; |
|
if (isDef(invokerFns)) { |
|
// invoker |
|
return getHookArgumentsLength( |
|
Array.isArray(invokerFns) |
|
? invokerFns[0] |
|
: invokerFns |
|
) |
|
} else { |
|
return (fn._length || fn.length) > 1 |
|
} |
|
} |
|
|
|
function _enter (_, vnode) { |
|
if (vnode.data.show !== true) { |
|
enter(vnode); |
|
} |
|
} |
|
|
|
var transition = inBrowser ? { |
|
create: _enter, |
|
activate: _enter, |
|
remove (vnode, rm) { |
|
/* istanbul ignore else */ |
|
if (vnode.data.show !== true) { |
|
leave(vnode, rm); |
|
} else { |
|
rm(); |
|
} |
|
} |
|
} : {}; |
|
|
|
var platformModules = [ |
|
attrs, |
|
klass, |
|
events, |
|
domProps, |
|
style, |
|
transition |
|
]; |
|
|
|
/* */ |
|
|
|
// the directive module should be applied last, after all |
|
// built-in modules have been applied. |
|
const modules = platformModules.concat(baseModules); |
|
|
|
const patch = createPatchFunction({ nodeOps, modules }); |
|
|
|
/** |
|
* Not type checking this file because flow doesn't like attaching |
|
* properties to Elements. |
|
*/ |
|
|
|
/* istanbul ignore if */ |
|
if (isIE9) { |
|
// http://www.matts411.com/post/internet-explorer-9-oninput/ |
|
document.addEventListener('selectionchange', () => { |
|
const el = document.activeElement; |
|
if (el && el.vmodel) { |
|
trigger(el, 'input'); |
|
} |
|
}); |
|
} |
|
|
|
const directive = { |
|
inserted (el, binding, vnode, oldVnode) { |
|
if (vnode.tag === 'select') { |
|
// #6903 |
|
if (oldVnode.elm && !oldVnode.elm._vOptions) { |
|
mergeVNodeHook(vnode, 'postpatch', () => { |
|
directive.componentUpdated(el, binding, vnode); |
|
}); |
|
} else { |
|
setSelected(el, binding, vnode.context); |
|
} |
|
el._vOptions = [].map.call(el.options, getValue); |
|
} else if (vnode.tag === 'textarea' || isTextInputType(el.type)) { |
|
el._vModifiers = binding.modifiers; |
|
if (!binding.modifiers.lazy) { |
|
// Safari < 10.2 & UIWebView doesn't fire compositionend when |
|
// switching focus before confirming composition choice |
|
// this also fixes the issue where some browsers e.g. iOS Chrome |
|
// fires "change" instead of "input" on autocomplete. |
|
el.addEventListener('change', onCompositionEnd); |
|
if (!isAndroid) { |
|
el.addEventListener('compositionstart', onCompositionStart); |
|
el.addEventListener('compositionend', onCompositionEnd); |
|
} |
|
/* istanbul ignore if */ |
|
if (isIE9) { |
|
el.vmodel = true; |
|
} |
|
} |
|
} |
|
}, |
|
|
|
componentUpdated (el, binding, vnode) { |
|
if (vnode.tag === 'select') { |
|
setSelected(el, binding, vnode.context); |
|
// in case the options rendered by v-for have changed, |
|
// it's possible that the value is out-of-sync with the rendered options. |
|
// detect such cases and filter out values that no longer has a matching |
|
// option in the DOM. |
|
const prevOptions = el._vOptions; |
|
const curOptions = el._vOptions = [].map.call(el.options, getValue); |
|
if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) { |
|
// trigger change event if |
|
// no matching option found for at least one value |
|
const needReset = el.multiple |
|
? binding.value.some(v => hasNoMatchingOption(v, curOptions)) |
|
: binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions); |
|
if (needReset) { |
|
trigger(el, 'change'); |
|
} |
|
} |
|
} |
|
} |
|
}; |
|
|
|
function setSelected (el, binding, vm) { |
|
actuallySetSelected(el, binding, vm); |
|
/* istanbul ignore if */ |
|
if (isIE || isEdge) { |
|
setTimeout(() => { |
|
actuallySetSelected(el, binding, vm); |
|
}, 0); |
|
} |
|
} |
|
|
|
function actuallySetSelected (el, binding, vm) { |
|
const value = binding.value; |
|
const isMultiple = el.multiple; |
|
if (isMultiple && !Array.isArray(value)) { |
|
"development" !== 'production' && warn( |
|
`<select multiple v-model="${binding.expression}"> ` + |
|
`expects an Array value for its binding, but got ${ |
|
Object.prototype.toString.call(value).slice(8, -1) |
|
}`, |
|
vm |
|
); |
|
return |
|
} |
|
let selected, option; |
|
for (let i = 0, l = el.options.length; i < l; i++) { |
|
option = el.options[i]; |
|
if (isMultiple) { |
|
selected = looseIndexOf(value, getValue(option)) > -1; |
|
if (option.selected !== selected) { |
|
option.selected = selected; |
|
} |
|
} else { |
|
if (looseEqual(getValue(option), value)) { |
|
if (el.selectedIndex !== i) { |
|
el.selectedIndex = i; |
|
} |
|
return |
|
} |
|
} |
|
} |
|
if (!isMultiple) { |
|
el.selectedIndex = -1; |
|
} |
|
} |
|
|
|
function hasNoMatchingOption (value, options) { |
|
return options.every(o => !looseEqual(o, value)) |
|
} |
|
|
|
function getValue (option) { |
|
return '_value' in option |
|
? option._value |
|
: option.value |
|
} |
|
|
|
function onCompositionStart (e) { |
|
e.target.composing = true; |
|
} |
|
|
|
function onCompositionEnd (e) { |
|
// prevent triggering an input event for no reason |
|
if (!e.target.composing) return |
|
e.target.composing = false; |
|
trigger(e.target, 'input'); |
|
} |
|
|
|
function trigger (el, type) { |
|
const e = document.createEvent('HTMLEvents'); |
|
e.initEvent(type, true, true); |
|
el.dispatchEvent(e); |
|
} |
|
|
|
/* */ |
|
|
|
// recursively search for possible transition defined inside the component root |
|
function locateNode (vnode) { |
|
return vnode.componentInstance && (!vnode.data || !vnode.data.transition) |
|
? locateNode(vnode.componentInstance._vnode) |
|
: vnode |
|
} |
|
|
|
var show = { |
|
bind (el, { value }, vnode) { |
|
vnode = locateNode(vnode); |
|
const transition$$1 = vnode.data && vnode.data.transition; |
|
const originalDisplay = el.__vOriginalDisplay = |
|
el.style.display === 'none' ? '' : el.style.display; |
|
if (value && transition$$1) { |
|
vnode.data.show = true; |
|
enter(vnode, () => { |
|
el.style.display = originalDisplay; |
|
}); |
|
} else { |
|
el.style.display = value ? originalDisplay : 'none'; |
|
} |
|
}, |
|
|
|
update (el, { value, oldValue }, vnode) { |
|
/* istanbul ignore if */ |
|
if (value === oldValue) return |
|
vnode = locateNode(vnode); |
|
const transition$$1 = vnode.data && vnode.data.transition; |
|
if (transition$$1) { |
|
vnode.data.show = true; |
|
if (value) { |
|
enter(vnode, () => { |
|
el.style.display = el.__vOriginalDisplay; |
|
}); |
|
} else { |
|
leave(vnode, () => { |
|
el.style.display = 'none'; |
|
}); |
|
} |
|
} else { |
|
el.style.display = value ? el.__vOriginalDisplay : 'none'; |
|
} |
|
}, |
|
|
|
unbind ( |
|
el, |
|
binding, |
|
vnode, |
|
oldVnode, |
|
isDestroy |
|
) { |
|
if (!isDestroy) { |
|
el.style.display = el.__vOriginalDisplay; |
|
} |
|
} |
|
}; |
|
|
|
var platformDirectives = { |
|
model: directive, |
|
show |
|
}; |
|
|
|
/* */ |
|
|
|
// Provides transition support for a single element/component. |
|
// supports transition mode (out-in / in-out) |
|
|
|
const transitionProps = { |
|
name: String, |
|
appear: Boolean, |
|
css: Boolean, |
|
mode: String, |
|
type: String, |
|
enterClass: String, |
|
leaveClass: String, |
|
enterToClass: String, |
|
leaveToClass: String, |
|
enterActiveClass: String, |
|
leaveActiveClass: String, |
|
appearClass: String, |
|
appearActiveClass: String, |
|
appearToClass: String, |
|
duration: [Number, String, Object] |
|
}; |
|
|
|
// in case the child is also an abstract component, e.g. <keep-alive> |
|
// we want to recursively retrieve the real component to be rendered |
|
function getRealChild (vnode) { |
|
const compOptions = vnode && vnode.componentOptions; |
|
if (compOptions && compOptions.Ctor.options.abstract) { |
|
return getRealChild(getFirstComponentChild(compOptions.children)) |
|
} else { |
|
return vnode |
|
} |
|
} |
|
|
|
function extractTransitionData (comp) { |
|
const data = {}; |
|
const options = comp.$options; |
|
// props |
|
for (const key in options.propsData) { |
|
data[key] = comp[key]; |
|
} |
|
// events. |
|
// extract listeners and pass them directly to the transition methods |
|
const listeners = options._parentListeners; |
|
for (const key in listeners) { |
|
data[camelize(key)] = listeners[key]; |
|
} |
|
return data |
|
} |
|
|
|
function placeholder (h, rawChild) { |
|
if (/\d-keep-alive$/.test(rawChild.tag)) { |
|
return h('keep-alive', { |
|
props: rawChild.componentOptions.propsData |
|
}) |
|
} |
|
} |
|
|
|
function hasParentTransition (vnode) { |
|
while ((vnode = vnode.parent)) { |
|
if (vnode.data.transition) { |
|
return true |
|
} |
|
} |
|
} |
|
|
|
function isSameChild (child, oldChild) { |
|
return oldChild.key === child.key && oldChild.tag === child.tag |
|
} |
|
|
|
var Transition = { |
|
name: 'transition', |
|
props: transitionProps, |
|
abstract: true, |
|
|
|
render (h) { |
|
let children = this.$slots.default; |
|
if (!children) { |
|
return |
|
} |
|
|
|
// filter out text nodes (possible whitespaces) |
|
children = children.filter((c) => c.tag || isAsyncPlaceholder(c)); |
|
/* istanbul ignore if */ |
|
if (!children.length) { |
|
return |
|
} |
|
|
|
// warn multiple elements |
|
if ("development" !== 'production' && children.length > 1) { |
|
warn( |
|
'<transition> can only be used on a single element. Use ' + |
|
'<transition-group> for lists.', |
|
this.$parent |
|
); |
|
} |
|
|
|
const mode = this.mode; |
|
|
|
// warn invalid mode |
|
if ("development" !== 'production' && |
|
mode && mode !== 'in-out' && mode !== 'out-in' |
|
) { |
|
warn( |
|
'invalid <transition> mode: ' + mode, |
|
this.$parent |
|
); |
|
} |
|
|
|
const rawChild = children[0]; |
|
|
|
// if this is a component root node and the component's |
|
// parent container node also has transition, skip. |
|
if (hasParentTransition(this.$vnode)) { |
|
return rawChild |
|
} |
|
|
|
// apply transition data to child |
|
// use getRealChild() to ignore abstract components e.g. keep-alive |
|
const child = getRealChild(rawChild); |
|
/* istanbul ignore if */ |
|
if (!child) { |
|
return rawChild |
|
} |
|
|
|
if (this._leaving) { |
|
return placeholder(h, rawChild) |
|
} |
|
|
|
// ensure a key that is unique to the vnode type and to this transition |
|
// component instance. This key will be used to remove pending leaving nodes |
|
// during entering. |
|
const id = `__transition-${this._uid}-`; |
|
child.key = child.key == null |
|
? child.isComment |
|
? id + 'comment' |
|
: id + child.tag |
|
: isPrimitive(child.key) |
|
? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key) |
|
: child.key; |
|
|
|
const data = (child.data || (child.data = {})).transition = extractTransitionData(this); |
|
const oldRawChild = this._vnode; |
|
const oldChild = getRealChild(oldRawChild); |
|
|
|
// mark v-show |
|
// so that the transition module can hand over the control to the directive |
|
if (child.data.directives && child.data.directives.some(d => d.name === 'show')) { |
|
child.data.show = true; |
|
} |
|
|
|
if ( |
|
oldChild && |
|
oldChild.data && |
|
!isSameChild(child, oldChild) && |
|
!isAsyncPlaceholder(oldChild) && |
|
// #6687 component root is a comment node |
|
!(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment) |
|
) { |
|
// replace old child transition data with fresh one |
|
// important for dynamic transitions! |
|
const oldData = oldChild.data.transition = extend({}, data); |
|
// handle transition mode |
|
if (mode === 'out-in') { |
|
// return placeholder node and queue update when leave finishes |
|
this._leaving = true; |
|
mergeVNodeHook(oldData, 'afterLeave', () => { |
|
this._leaving = false; |
|
this.$forceUpdate(); |
|
}); |
|
return placeholder(h, rawChild) |
|
} else if (mode === 'in-out') { |
|
if (isAsyncPlaceholder(child)) { |
|
return oldRawChild |
|
} |
|
let delayedLeave; |
|
const performLeave = () => { delayedLeave(); }; |
|
mergeVNodeHook(data, 'afterEnter', performLeave); |
|
mergeVNodeHook(data, 'enterCancelled', performLeave); |
|
mergeVNodeHook(oldData, 'delayLeave', leave => { delayedLeave = leave; }); |
|
} |
|
} |
|
|
|
return rawChild |
|
} |
|
}; |
|
|
|
/* */ |
|
|
|
// Provides transition support for list items. |
|
// supports move transitions using the FLIP technique. |
|
|
|
// Because the vdom's children update algorithm is "unstable" - i.e. |
|
// it doesn't guarantee the relative positioning of removed elements, |
|
// we force transition-group to update its children into two passes: |
|
// in the first pass, we remove all nodes that need to be removed, |
|
// triggering their leaving transition; in the second pass, we insert/move |
|
// into the final desired state. This way in the second pass removed |
|
// nodes will remain where they should be. |
|
|
|
const props = extend({ |
|
tag: String, |
|
moveClass: String |
|
}, transitionProps); |
|
|
|
delete props.mode; |
|
|
|
var TransitionGroup = { |
|
props, |
|
|
|
render (h) { |
|
const tag = this.tag || this.$vnode.data.tag || 'span'; |
|
const map = Object.create(null); |
|
const prevChildren = this.prevChildren = this.children; |
|
const rawChildren = this.$slots.default || []; |
|
const children = this.children = []; |
|
const transitionData = extractTransitionData(this); |
|
|
|
for (let i = 0; i < rawChildren.length; i++) { |
|
const c = rawChildren[i]; |
|
if (c.tag) { |
|
if (c.key != null && String(c.key).indexOf('__vlist') !== 0) { |
|
children.push(c); |
|
map[c.key] = c |
|
;(c.data || (c.data = {})).transition = transitionData; |
|
} else { |
|
const opts = c.componentOptions; |
|
const name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag; |
|
warn(`<transition-group> children must be keyed: <${name}>`); |
|
} |
|
} |
|
} |
|
|
|
if (prevChildren) { |
|
const kept = []; |
|
const removed = []; |
|
for (let i = 0; i < prevChildren.length; i++) { |
|
const c = prevChildren[i]; |
|
c.data.transition = transitionData; |
|
c.data.pos = c.elm.getBoundingClientRect(); |
|
if (map[c.key]) { |
|
kept.push(c); |
|
} else { |
|
removed.push(c); |
|
} |
|
} |
|
this.kept = h(tag, null, kept); |
|
this.removed = removed; |
|
} |
|
|
|
return h(tag, null, children) |
|
}, |
|
|
|
beforeUpdate () { |
|
// force removing pass |
|
this.__patch__( |
|
this._vnode, |
|
this.kept, |
|
false, // hydrating |
|
true // removeOnly (!important, avoids unnecessary moves) |
|
); |
|
this._vnode = this.kept; |
|
}, |
|
|
|
updated () { |
|
const children = this.prevChildren; |
|
const moveClass = this.moveClass || ((this.name || 'v') + '-move'); |
|
if (!children.length || !this.hasMove(children[0].elm, moveClass)) { |
|
return |
|
} |
|
|
|
// we divide the work into three loops to avoid mixing DOM reads and writes |
|
// in each iteration - which helps prevent layout thrashing. |
|
children.forEach(callPendingCbs); |
|
children.forEach(recordPosition); |
|
children.forEach(applyTranslation); |
|
|
|
// force reflow to put everything in position |
|
// assign to this to avoid being removed in tree-shaking |
|
// $flow-disable-line |
|
this._reflow = document.body.offsetHeight; |
|
|
|
children.forEach((c) => { |
|
if (c.data.moved) { |
|
var el = c.elm; |
|
var s = el.style; |
|
addTransitionClass(el, moveClass); |
|
s.transform = s.WebkitTransform = s.transitionDuration = ''; |
|
el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) { |
|
if (!e || /transform$/.test(e.propertyName)) { |
|
el.removeEventListener(transitionEndEvent, cb); |
|
el._moveCb = null; |
|
removeTransitionClass(el, moveClass); |
|
} |
|
}); |
|
} |
|
}); |
|
}, |
|
|
|
methods: { |
|
hasMove (el, moveClass) { |
|
/* istanbul ignore if */ |
|
if (!hasTransition) { |
|
return false |
|
} |
|
/* istanbul ignore if */ |
|
if (this._hasMove) { |
|
return this._hasMove |
|
} |
|
// Detect whether an element with the move class applied has |
|
// CSS transitions. Since the element may be inside an entering |
|
// transition at this very moment, we make a clone of it and remove |
|
// all other transition classes applied to ensure only the move class |
|
// is applied. |
|
const clone = el.cloneNode(); |
|
if (el._transitionClasses) { |
|
el._transitionClasses.forEach((cls) => { removeClass(clone, cls); }); |
|
} |
|
addClass(clone, moveClass); |
|
clone.style.display = 'none'; |
|
this.$el.appendChild(clone); |
|
const info = getTransitionInfo(clone); |
|
this.$el.removeChild(clone); |
|
return (this._hasMove = info.hasTransform) |
|
} |
|
} |
|
}; |
|
|
|
function callPendingCbs (c) { |
|
/* istanbul ignore if */ |
|
if (c.elm._moveCb) { |
|
c.elm._moveCb(); |
|
} |
|
/* istanbul ignore if */ |
|
if (c.elm._enterCb) { |
|
c.elm._enterCb(); |
|
} |
|
} |
|
|
|
function recordPosition (c) { |
|
c.data.newPos = c.elm.getBoundingClientRect(); |
|
} |
|
|
|
function applyTranslation (c) { |
|
const oldPos = c.data.pos; |
|
const newPos = c.data.newPos; |
|
const dx = oldPos.left - newPos.left; |
|
const dy = oldPos.top - newPos.top; |
|
if (dx || dy) { |
|
c.data.moved = true; |
|
const s = c.elm.style; |
|
s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`; |
|
s.transitionDuration = '0s'; |
|
} |
|
} |
|
|
|
var platformComponents = { |
|
Transition, |
|
TransitionGroup |
|
}; |
|
|
|
/* */ |
|
|
|
// 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 runtime directives & components |
|
extend(Vue$3.options.directives, platformDirectives); |
|
extend(Vue$3.options.components, platformComponents); |
|
|
|
// install platform patch function |
|
Vue$3.prototype.__patch__ = inBrowser ? patch : noop; |
|
|
|
// public mount method |
|
Vue$3.prototype.$mount = function ( |
|
el, |
|
hydrating |
|
) { |
|
el = el && inBrowser ? query(el) : undefined; |
|
return mountComponent(this, el, hydrating) |
|
}; |
|
|
|
// devtools global hook |
|
/* istanbul ignore next */ |
|
Vue$3.nextTick(() => { |
|
if (config.devtools) { |
|
if (devtools) { |
|
devtools.emit('init', Vue$3); |
|
} else if ("development" !== 'production' && isChrome) { |
|
console[console.info ? 'info' : 'log']( |
|
'Download the Vue Devtools extension for a better development experience:\n' + |
|
'https://github.com/vuejs/vue-devtools' |
|
); |
|
} |
|
} |
|
if ("development" !== 'production' && |
|
config.productionTip !== false && |
|
inBrowser && typeof console !== 'undefined' |
|
) { |
|
console[console.info ? 'info' : 'log']( |
|
`You are running Vue in development mode.\n` + |
|
`Make sure to turn on production mode when deploying for production.\n` + |
|
`See more tips at https://vuejs.org/guide/deployment.html` |
|
); |
|
} |
|
}, 0); |
|
|
|
/* */ |
|
|
|
const defaultTagRE = /\{\{((?:.|\n)+?)\}\}/g; |
|
const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g; |
|
|
|
const buildRegex = cached(delimiters => { |
|
const open = delimiters[0].replace(regexEscapeRE, '\\$&'); |
|
const close = delimiters[1].replace(regexEscapeRE, '\\$&'); |
|
return new RegExp(open + '((?:.|\\n)+?)' + close, 'g') |
|
}); |
|
|
|
function parseText ( |
|
text, |
|
delimiters |
|
) { |
|
const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE; |
|
if (!tagRE.test(text)) { |
|
return |
|
} |
|
const tokens = []; |
|
let lastIndex = tagRE.lastIndex = 0; |
|
let match, index; |
|
while ((match = tagRE.exec(text))) { |
|
index = match.index; |
|
// push text token |
|
if (index > lastIndex) { |
|
tokens.push(JSON.stringify(text.slice(lastIndex, index))); |
|
} |
|
// tag token |
|
const exp = parseFilters(match[1].trim()); |
|
tokens.push(`_s(${exp})`); |
|
lastIndex = index + match[0].length; |
|
} |
|
if (lastIndex < text.length) { |
|
tokens.push(JSON.stringify(text.slice(lastIndex))); |
|
} |
|
return tokens.join('+') |
|
} |
|
|
|
/* */ |
|
|
|
function transformNode (el, options) { |
|
const warn = options.warn || baseWarn; |
|
const staticClass = getAndRemoveAttr(el, 'class'); |
|
if ("development" !== 'production' && staticClass) { |
|
const expression = parseText(staticClass, options.delimiters); |
|
if (expression) { |
|
warn( |
|
`class="${staticClass}": ` + |
|
'Interpolation inside attributes has been removed. ' + |
|
'Use v-bind or the colon shorthand instead. For example, ' + |
|
'instead of <div class="{{ val }}">, use <div :class="val">.' |
|
); |
|
} |
|
} |
|
if (staticClass) { |
|
el.staticClass = JSON.stringify(staticClass); |
|
} |
|
const classBinding = getBindingAttr(el, 'class', false /* getStatic */); |
|
if (classBinding) { |
|
el.classBinding = classBinding; |
|
} |
|
} |
|
|
|
function genData (el) { |
|
let data = ''; |
|
if (el.staticClass) { |
|
data += `staticClass:${el.staticClass},`; |
|
} |
|
if (el.classBinding) { |
|
data += `class:${el.classBinding},`; |
|
} |
|
return data |
|
} |
|
|
|
var klass$1 = { |
|
staticKeys: ['staticClass'], |
|
transformNode, |
|
genData |
|
}; |
|
|
|
/* */ |
|
|
|
function transformNode$1 (el, options) { |
|
const warn = options.warn || baseWarn; |
|
const staticStyle = getAndRemoveAttr(el, 'style'); |
|
if (staticStyle) { |
|
/* istanbul ignore if */ |
|
{ |
|
const expression = parseText(staticStyle, options.delimiters); |
|
if (expression) { |
|
warn( |
|
`style="${staticStyle}": ` + |
|
'Interpolation inside attributes has been removed. ' + |
|
'Use v-bind or the colon shorthand instead. For example, ' + |
|
'instead of <div style="{{ val }}">, use <div :style="val">.' |
|
); |
|
} |
|
} |
|
el.staticStyle = JSON.stringify(parseStyleText(staticStyle)); |
|
} |
|
|
|
const styleBinding = getBindingAttr(el, 'style', false /* getStatic */); |
|
if (styleBinding) { |
|
el.styleBinding = styleBinding; |
|
} |
|
} |
|
|
|
function genData$1 (el) { |
|
let data = ''; |
|
if (el.staticStyle) { |
|
data += `staticStyle:${el.staticStyle},`; |
|
} |
|
if (el.styleBinding) { |
|
data += `style:(${el.styleBinding}),`; |
|
} |
|
return data |
|
} |
|
|
|
var style$1 = { |
|
staticKeys: ['staticStyle'], |
|
transformNode: transformNode$1, |
|
genData: genData$1 |
|
}; |
|
|
|
/* */ |
|
|
|
let decoder; |
|
|
|
var he = { |
|
decode (html) { |
|
decoder = decoder || document.createElement('div'); |
|
decoder.innerHTML = html; |
|
return decoder.textContent |
|
} |
|
}; |
|
|
|
/* */ |
|
|
|
const isUnaryTag = makeMap( |
|
'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + |
|
'link,meta,param,source,track,wbr' |
|
); |
|
|
|
// Elements that you can, intentionally, leave open |
|
// (and which close themselves) |
|
const canBeLeftOpenTag = makeMap( |
|
'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source' |
|
); |
|
|
|
// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3 |
|
// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content |
|
const isNonPhrasingTag = makeMap( |
|
'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' + |
|
'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' + |
|
'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' + |
|
'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' + |
|
'title,tr,track' |
|
); |
|
|
|
/** |
|
* Not type-checking this file because it's mostly vendor code. |
|
*/ |
|
|
|
/*! |
|
* HTML Parser By John Resig (ejohn.org) |
|
* Modified by Juriy "kangax" Zaytsev |
|
* Original code by Erik Arvidsson, Mozilla Public License |
|
* http://erik.eae.net/simplehtmlparser/simplehtmlparser.js |
|
*/ |
|
|
|
// Regular Expressions for parsing tags and attributes |
|
const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/; |
|
// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName |
|
// but for Vue templates we can enforce a simple charset |
|
const ncname = '[a-zA-Z_][\\w\\-\\.]*'; |
|
const qnameCapture = `((?:${ncname}\\:)?${ncname})`; |
|
const startTagOpen = new RegExp(`^<${qnameCapture}`); |
|
const startTagClose = /^\s*(\/?)>/; |
|
const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`); |
|
const doctype = /^<!DOCTYPE [^>]+>/i; |
|
const comment = /^<!--/; |
|
const conditionalComment = /^<!\[/; |
|
|
|
let IS_REGEX_CAPTURING_BROKEN = false; |
|
'x'.replace(/x(.)?/g, function (m, g) { |
|
IS_REGEX_CAPTURING_BROKEN = g === ''; |
|
}); |
|
|
|
// Special Elements (can contain anything) |
|
const isPlainTextElement = makeMap('script,style,textarea', true); |
|
const reCache = {}; |
|
|
|
const decodingMap = { |
|
'<': '<', |
|
'>': '>', |
|
'"': '"', |
|
'&': '&', |
|
' ': '\n', |
|
'	': '\t' |
|
}; |
|
const encodedAttr = /&(?:lt|gt|quot|amp);/g; |
|
const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#10|#9);/g; |
|
|
|
// #5992 |
|
const isIgnoreNewlineTag = makeMap('pre,textarea', true); |
|
const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; |
|
|
|
function decodeAttr (value, shouldDecodeNewlines) { |
|
const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr; |
|
return value.replace(re, match => decodingMap[match]) |
|
} |
|
|
|
function parseHTML (html, options) { |
|
const stack = []; |
|
const expectHTML = options.expectHTML; |
|
const isUnaryTag$$1 = options.isUnaryTag || no; |
|
const canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no; |
|
let index = 0; |
|
let last, lastTag; |
|
while (html) { |
|
last = html; |
|
// Make sure we're not in a plaintext content element like script/style |
|
if (!lastTag || !isPlainTextElement(lastTag)) { |
|
let textEnd = html.indexOf('<'); |
|
if (textEnd === 0) { |
|
// Comment: |
|
if (comment.test(html)) { |
|
const commentEnd = html.indexOf('-->'); |
|
|
|
if (commentEnd >= 0) { |
|
if (options.shouldKeepComment) { |
|
options.comment(html.substring(4, commentEnd)); |
|
} |
|
advance(commentEnd + 3); |
|
continue |
|
} |
|
} |
|
|
|
// http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment |
|
if (conditionalComment.test(html)) { |
|
const conditionalEnd = html.indexOf(']>'); |
|
|
|
if (conditionalEnd >= 0) { |
|
advance(conditionalEnd + 2); |
|
continue |
|
} |
|
} |
|
|
|
// Doctype: |
|
const doctypeMatch = html.match(doctype); |
|
if (doctypeMatch) { |
|
advance(doctypeMatch[0].length); |
|
continue |
|
} |
|
|
|
// End tag: |
|
const endTagMatch = html.match(endTag); |
|
if (endTagMatch) { |
|
const curIndex = index; |
|
advance(endTagMatch[0].length); |
|
parseEndTag(endTagMatch[1], curIndex, index); |
|
continue |
|
} |
|
|
|
// Start tag: |
|
const startTagMatch = parseStartTag(); |
|
if (startTagMatch) { |
|
handleStartTag(startTagMatch); |
|
if (shouldIgnoreFirstNewline(lastTag, html)) { |
|
advance(1); |
|
} |
|
continue |
|
} |
|
} |
|
|
|
let text, rest, next; |
|
if (textEnd >= 0) { |
|
rest = html.slice(textEnd); |
|
while ( |
|
!endTag.test(rest) && |
|
!startTagOpen.test(rest) && |
|
!comment.test(rest) && |
|
!conditionalComment.test(rest) |
|
) { |
|
// < in plain text, be forgiving and treat it as text |
|
next = rest.indexOf('<', 1); |
|
if (next < 0) break |
|
textEnd += next; |
|
rest = html.slice(textEnd); |
|
} |
|
text = html.substring(0, textEnd); |
|
advance(textEnd); |
|
} |
|
|
|
if (textEnd < 0) { |
|
text = html; |
|
html = ''; |
|
} |
|
|
|
if (options.chars && text) { |
|
options.chars(text); |
|
} |
|
} else { |
|
let endTagLength = 0; |
|
const stackedTag = lastTag.toLowerCase(); |
|
const reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i')); |
|
const rest = html.replace(reStackedTag, function (all, text, endTag) { |
|
endTagLength = endTag.length; |
|
if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') { |
|
text = text |
|
.replace(/<!--([\s\S]*?)-->/g, '$1') |
|
.replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1'); |
|
} |
|
if (shouldIgnoreFirstNewline(stackedTag, text)) { |
|
text = text.slice(1); |
|
} |
|
if (options.chars) { |
|
options.chars(text); |
|
} |
|
return '' |
|
}); |
|
index += html.length - rest.length; |
|
html = rest; |
|
parseEndTag(stackedTag, index - endTagLength, index); |
|
} |
|
|
|
if (html === last) { |
|
options.chars && options.chars(html); |
|
if ("development" !== 'production' && !stack.length && options.warn) { |
|
options.warn(`Mal-formatted tag at end of template: "${html}"`); |
|
} |
|
break |
|
} |
|
} |
|
|
|
// Clean up any remaining tags |
|
parseEndTag(); |
|
|
|
function advance (n) { |
|
index += n; |
|
html = html.substring(n); |
|
} |
|
|
|
function parseStartTag () { |
|
const start = html.match(startTagOpen); |
|
if (start) { |
|
const match = { |
|
tagName: start[1], |
|
attrs: [], |
|
start: index |
|
}; |
|
advance(start[0].length); |
|
let end, attr; |
|
while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) { |
|
advance(attr[0].length); |
|
match.attrs.push(attr); |
|
} |
|
if (end) { |
|
match.unarySlash = end[1]; |
|
advance(end[0].length); |
|
match.end = index; |
|
return match |
|
} |
|
} |
|
} |
|
|
|
function handleStartTag (match) { |
|
const tagName = match.tagName; |
|
const unarySlash = match.unarySlash; |
|
|
|
if (expectHTML) { |
|
if (lastTag === 'p' && isNonPhrasingTag(tagName)) { |
|
parseEndTag(lastTag); |
|
} |
|
if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) { |
|
parseEndTag(tagName); |
|
} |
|
} |
|
|
|
const unary = isUnaryTag$$1(tagName) || !!unarySlash; |
|
|
|
const l = match.attrs.length; |
|
const attrs = new Array(l); |
|
for (let i = 0; i < l; i++) { |
|
const args = match.attrs[i]; |
|
// hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778 |
|
if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) { |
|
if (args[3] === '') { delete args[3]; } |
|
if (args[4] === '') { delete args[4]; } |
|
if (args[5] === '') { delete args[5]; } |
|
} |
|
const value = args[3] || args[4] || args[5] || ''; |
|
const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href' |
|
? options.shouldDecodeNewlinesForHref |
|
: options.shouldDecodeNewlines; |
|
attrs[i] = { |
|
name: args[1], |
|
value: decodeAttr(value, shouldDecodeNewlines) |
|
}; |
|
} |
|
|
|
if (!unary) { |
|
stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs }); |
|
lastTag = tagName; |
|
} |
|
|
|
if (options.start) { |
|
options.start(tagName, attrs, unary, match.start, match.end); |
|
} |
|
} |
|
|
|
function parseEndTag (tagName, start, end) { |
|
let pos, lowerCasedTagName; |
|
if (start == null) start = index; |
|
if (end == null) end = index; |
|
|
|
if (tagName) { |
|
lowerCasedTagName = tagName.toLowerCase(); |
|
} |
|
|
|
// Find the closest opened tag of the same type |
|
if (tagName) { |
|
for (pos = stack.length - 1; pos >= 0; pos--) { |
|
if (stack[pos].lowerCasedTag === lowerCasedTagName) { |
|
break |
|
} |
|
} |
|
} else { |
|
// If no tag name is provided, clean shop |
|
pos = 0; |
|
} |
|
|
|
if (pos >= 0) { |
|
// Close all the open elements, up the stack |
|
for (let i = stack.length - 1; i >= pos; i--) { |
|
if ("development" !== 'production' && |
|
(i > pos || !tagName) && |
|
options.warn |
|
) { |
|
options.warn( |
|
`tag <${stack[i].tag}> has no matching end tag.` |
|
); |
|
} |
|
if (options.end) { |
|
options.end(stack[i].tag, start, end); |
|
} |
|
} |
|
|
|
// Remove the open elements from the stack |
|
stack.length = pos; |
|
lastTag = pos && stack[pos - 1].tag; |
|
} else if (lowerCasedTagName === 'br') { |
|
if (options.start) { |
|
options.start(tagName, [], true, start, end); |
|
} |
|
} else if (lowerCasedTagName === 'p') { |
|
if (options.start) { |
|
options.start(tagName, [], false, start, end); |
|
} |
|
if (options.end) { |
|
options.end(tagName, start, end); |
|
} |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
const onRE = /^@|^v-on:/; |
|
const dirRE = /^v-|^@|^:/; |
|
const forAliasRE = /(.*?)\s+(?:in|of)\s+(.*)/; |
|
const forIteratorRE = /\((\{[^}]*\}|[^,]*),([^,]*)(?:,([^,]*))?\)/; |
|
|
|
const argRE = /:(.*)$/; |
|
const bindRE = /^:|^v-bind:/; |
|
const modifierRE = /\.[^.]+/g; |
|
|
|
const decodeHTMLCached = cached(he.decode); |
|
|
|
// configurable state |
|
let warn$2; |
|
let delimiters; |
|
let transforms; |
|
let preTransforms; |
|
let postTransforms; |
|
let platformIsPreTag; |
|
let platformMustUseProp; |
|
let platformGetTagNamespace; |
|
|
|
|
|
|
|
function createASTElement ( |
|
tag, |
|
attrs, |
|
parent |
|
) { |
|
return { |
|
type: 1, |
|
tag, |
|
attrsList: attrs, |
|
attrsMap: makeAttrsMap(attrs), |
|
parent, |
|
children: [] |
|
} |
|
} |
|
|
|
/** |
|
* Convert HTML string to AST. |
|
*/ |
|
function parse ( |
|
template, |
|
options |
|
) { |
|
warn$2 = options.warn || baseWarn; |
|
|
|
platformIsPreTag = options.isPreTag || no; |
|
platformMustUseProp = options.mustUseProp || no; |
|
platformGetTagNamespace = options.getTagNamespace || no; |
|
|
|
transforms = pluckModuleFunction(options.modules, 'transformNode'); |
|
preTransforms = pluckModuleFunction(options.modules, 'preTransformNode'); |
|
postTransforms = pluckModuleFunction(options.modules, 'postTransformNode'); |
|
|
|
delimiters = options.delimiters; |
|
|
|
const stack = []; |
|
const preserveWhitespace = options.preserveWhitespace !== false; |
|
let root; |
|
let currentParent; |
|
let inVPre = false; |
|
let inPre = false; |
|
let warned = false; |
|
|
|
function warnOnce (msg) { |
|
if (!warned) { |
|
warned = true; |
|
warn$2(msg); |
|
} |
|
} |
|
|
|
function endPre (element) { |
|
// check pre state |
|
if (element.pre) { |
|
inVPre = false; |
|
} |
|
if (platformIsPreTag(element.tag)) { |
|
inPre = false; |
|
} |
|
} |
|
|
|
parseHTML(template, { |
|
warn: warn$2, |
|
expectHTML: options.expectHTML, |
|
isUnaryTag: options.isUnaryTag, |
|
canBeLeftOpenTag: options.canBeLeftOpenTag, |
|
shouldDecodeNewlines: options.shouldDecodeNewlines, |
|
shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref, |
|
shouldKeepComment: options.comments, |
|
start (tag, attrs, unary) { |
|
// check namespace. |
|
// inherit parent ns if there is one |
|
const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag); |
|
|
|
// handle IE svg bug |
|
/* istanbul ignore if */ |
|
if (isIE && ns === 'svg') { |
|
attrs = guardIESVGBug(attrs); |
|
} |
|
|
|
let element = createASTElement(tag, attrs, currentParent); |
|
if (ns) { |
|
element.ns = ns; |
|
} |
|
|
|
if (isForbiddenTag(element) && !isServerRendering()) { |
|
element.forbidden = true; |
|
"development" !== 'production' && warn$2( |
|
'Templates should only be responsible for mapping the state to the ' + |
|
'UI. Avoid placing tags with side-effects in your templates, such as ' + |
|
`<${tag}>` + ', as they will not be parsed.' |
|
); |
|
} |
|
|
|
// apply pre-transforms |
|
for (let i = 0; i < preTransforms.length; i++) { |
|
element = preTransforms[i](element, options) || element; |
|
} |
|
|
|
if (!inVPre) { |
|
processPre(element); |
|
if (element.pre) { |
|
inVPre = true; |
|
} |
|
} |
|
if (platformIsPreTag(element.tag)) { |
|
inPre = true; |
|
} |
|
if (inVPre) { |
|
processRawAttrs(element); |
|
} else if (!element.processed) { |
|
// structural directives |
|
processFor(element); |
|
processIf(element); |
|
processOnce(element); |
|
// element-scope stuff |
|
processElement(element, options); |
|
} |
|
|
|
function checkRootConstraints (el) { |
|
{ |
|
if (el.tag === 'slot' || el.tag === 'template') { |
|
warnOnce( |
|
`Cannot use <${el.tag}> as component root element because it may ` + |
|
'contain multiple nodes.' |
|
); |
|
} |
|
if (el.attrsMap.hasOwnProperty('v-for')) { |
|
warnOnce( |
|
'Cannot use v-for on stateful component root element because ' + |
|
'it renders multiple elements.' |
|
); |
|
} |
|
} |
|
} |
|
|
|
// tree management |
|
if (!root) { |
|
root = element; |
|
checkRootConstraints(root); |
|
} else if (!stack.length) { |
|
// allow root elements with v-if, v-else-if and v-else |
|
if (root.if && (element.elseif || element.else)) { |
|
checkRootConstraints(element); |
|
addIfCondition(root, { |
|
exp: element.elseif, |
|
block: element |
|
}); |
|
} else { |
|
warnOnce( |
|
`Component template should contain exactly one root element. ` + |
|
`If you are using v-if on multiple elements, ` + |
|
`use v-else-if to chain them instead.` |
|
); |
|
} |
|
} |
|
if (currentParent && !element.forbidden) { |
|
if (element.elseif || element.else) { |
|
processIfConditions(element, currentParent); |
|
} else if (element.slotScope) { // scoped slot |
|
currentParent.plain = false; |
|
const name = element.slotTarget || '"default"';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element; |
|
} else { |
|
currentParent.children.push(element); |
|
element.parent = currentParent; |
|
} |
|
} |
|
if (!unary) { |
|
currentParent = element; |
|
stack.push(element); |
|
} else { |
|
endPre(element); |
|
} |
|
// apply post-transforms |
|
for (let i = 0; i < postTransforms.length; i++) { |
|
postTransforms[i](element, options); |
|
} |
|
}, |
|
|
|
end () { |
|
// remove trailing whitespace |
|
const element = stack[stack.length - 1]; |
|
const lastNode = element.children[element.children.length - 1]; |
|
if (lastNode && lastNode.type === 3 && lastNode.text === ' ' && !inPre) { |
|
element.children.pop(); |
|
} |
|
// pop stack |
|
stack.length -= 1; |
|
currentParent = stack[stack.length - 1]; |
|
endPre(element); |
|
}, |
|
|
|
chars (text) { |
|
if (!currentParent) { |
|
{ |
|
if (text === template) { |
|
warnOnce( |
|
'Component template requires a root element, rather than just text.' |
|
); |
|
} else if ((text = text.trim())) { |
|
warnOnce( |
|
`text "${text}" outside root element will be ignored.` |
|
); |
|
} |
|
} |
|
return |
|
} |
|
// IE textarea placeholder bug |
|
/* istanbul ignore if */ |
|
if (isIE && |
|
currentParent.tag === 'textarea' && |
|
currentParent.attrsMap.placeholder === text |
|
) { |
|
return |
|
} |
|
const children = currentParent.children; |
|
text = inPre || text.trim() |
|
? isTextTag(currentParent) ? text : decodeHTMLCached(text) |
|
// only preserve whitespace if its not right after a starting tag |
|
: preserveWhitespace && children.length ? ' ' : ''; |
|
if (text) { |
|
let expression; |
|
if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) { |
|
children.push({ |
|
type: 2, |
|
expression, |
|
text |
|
}); |
|
} else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') { |
|
children.push({ |
|
type: 3, |
|
text |
|
}); |
|
} |
|
} |
|
}, |
|
comment (text) { |
|
currentParent.children.push({ |
|
type: 3, |
|
text, |
|
isComment: true |
|
}); |
|
} |
|
}); |
|
return root |
|
} |
|
|
|
function processPre (el) { |
|
if (getAndRemoveAttr(el, 'v-pre') != null) { |
|
el.pre = true; |
|
} |
|
} |
|
|
|
function processRawAttrs (el) { |
|
const l = el.attrsList.length; |
|
if (l) { |
|
const attrs = el.attrs = new Array(l); |
|
for (let i = 0; i < l; i++) { |
|
attrs[i] = { |
|
name: el.attrsList[i].name, |
|
value: JSON.stringify(el.attrsList[i].value) |
|
}; |
|
} |
|
} else if (!el.pre) { |
|
// non root node in pre blocks with no attributes |
|
el.plain = true; |
|
} |
|
} |
|
|
|
function processElement (element, options) { |
|
processKey(element); |
|
|
|
// determine whether this is a plain element after |
|
// removing structural attributes |
|
element.plain = !element.key && !element.attrsList.length; |
|
|
|
processRef(element); |
|
processSlot(element); |
|
processComponent(element); |
|
for (let i = 0; i < transforms.length; i++) { |
|
element = transforms[i](element, options) || element; |
|
} |
|
processAttrs(element); |
|
} |
|
|
|
function processKey (el) { |
|
const exp = getBindingAttr(el, 'key'); |
|
if (exp) { |
|
if ("development" !== 'production' && el.tag === 'template') { |
|
warn$2(`<template> cannot be keyed. Place the key on real elements instead.`); |
|
} |
|
el.key = exp; |
|
} |
|
} |
|
|
|
function processRef (el) { |
|
const ref = getBindingAttr(el, 'ref'); |
|
if (ref) { |
|
el.ref = ref; |
|
el.refInFor = checkInFor(el); |
|
} |
|
} |
|
|
|
function processFor (el) { |
|
let exp; |
|
if ((exp = getAndRemoveAttr(el, 'v-for'))) { |
|
const inMatch = exp.match(forAliasRE); |
|
if (!inMatch) { |
|
"development" !== 'production' && warn$2( |
|
`Invalid v-for expression: ${exp}` |
|
); |
|
return |
|
} |
|
el.for = inMatch[2].trim(); |
|
const alias = inMatch[1].trim(); |
|
const iteratorMatch = alias.match(forIteratorRE); |
|
if (iteratorMatch) { |
|
el.alias = iteratorMatch[1].trim(); |
|
el.iterator1 = iteratorMatch[2].trim(); |
|
if (iteratorMatch[3]) { |
|
el.iterator2 = iteratorMatch[3].trim(); |
|
} |
|
} else { |
|
el.alias = alias; |
|
} |
|
} |
|
} |
|
|
|
function processIf (el) { |
|
const exp = getAndRemoveAttr(el, 'v-if'); |
|
if (exp) { |
|
el.if = exp; |
|
addIfCondition(el, { |
|
exp: exp, |
|
block: el |
|
}); |
|
} else { |
|
if (getAndRemoveAttr(el, 'v-else') != null) { |
|
el.else = true; |
|
} |
|
const elseif = getAndRemoveAttr(el, 'v-else-if'); |
|
if (elseif) { |
|
el.elseif = elseif; |
|
} |
|
} |
|
} |
|
|
|
function processIfConditions (el, parent) { |
|
const prev = findPrevElement(parent.children); |
|
if (prev && prev.if) { |
|
addIfCondition(prev, { |
|
exp: el.elseif, |
|
block: el |
|
}); |
|
} else { |
|
warn$2( |
|
`v-${el.elseif ? ('else-if="' + el.elseif + '"') : 'else'} ` + |
|
`used on element <${el.tag}> without corresponding v-if.` |
|
); |
|
} |
|
} |
|
|
|
function findPrevElement (children) { |
|
let i = children.length; |
|
while (i--) { |
|
if (children[i].type === 1) { |
|
return children[i] |
|
} else { |
|
if ("development" !== 'production' && children[i].text !== ' ') { |
|
warn$2( |
|
`text "${children[i].text.trim()}" between v-if and v-else(-if) ` + |
|
`will be ignored.` |
|
); |
|
} |
|
children.pop(); |
|
} |
|
} |
|
} |
|
|
|
function addIfCondition (el, condition) { |
|
if (!el.ifConditions) { |
|
el.ifConditions = []; |
|
} |
|
el.ifConditions.push(condition); |
|
} |
|
|
|
function processOnce (el) { |
|
const once$$1 = getAndRemoveAttr(el, 'v-once'); |
|
if (once$$1 != null) { |
|
el.once = true; |
|
} |
|
} |
|
|
|
function processSlot (el) { |
|
if (el.tag === 'slot') { |
|
el.slotName = getBindingAttr(el, 'name'); |
|
if ("development" !== 'production' && el.key) { |
|
warn$2( |
|
`\`key\` does not work on <slot> because slots are abstract outlets ` + |
|
`and can possibly expand into multiple elements. ` + |
|
`Use the key on a wrapping element instead.` |
|
); |
|
} |
|
} else { |
|
let slotScope; |
|
if (el.tag === 'template') { |
|
slotScope = getAndRemoveAttr(el, 'scope'); |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && slotScope) { |
|
warn$2( |
|
`the "scope" attribute for scoped slots have been deprecated and ` + |
|
`replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` + |
|
`can also be used on plain elements in addition to <template> to ` + |
|
`denote scoped slots.`, |
|
true |
|
); |
|
} |
|
el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope'); |
|
} else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) { |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && el.attrsMap['v-for']) { |
|
warn$2( |
|
`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` + |
|
`(v-for takes higher priority). Use a wrapper <template> for the ` + |
|
`scoped slot to make it clearer.`, |
|
true |
|
); |
|
} |
|
el.slotScope = slotScope; |
|
} |
|
const slotTarget = getBindingAttr(el, 'slot'); |
|
if (slotTarget) { |
|
el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget; |
|
// preserve slot as an attribute for native shadow DOM compat |
|
// only for non-scoped slots. |
|
if (el.tag !== 'template' && !el.slotScope) { |
|
addAttr(el, 'slot', slotTarget); |
|
} |
|
} |
|
} |
|
} |
|
|
|
function processComponent (el) { |
|
let binding; |
|
if ((binding = getBindingAttr(el, 'is'))) { |
|
el.component = binding; |
|
} |
|
if (getAndRemoveAttr(el, 'inline-template') != null) { |
|
el.inlineTemplate = true; |
|
} |
|
} |
|
|
|
function processAttrs (el) { |
|
const list = el.attrsList; |
|
let i, l, name, rawName, value, modifiers, isProp; |
|
for (i = 0, l = list.length; i < l; i++) { |
|
name = rawName = list[i].name; |
|
value = list[i].value; |
|
if (dirRE.test(name)) { |
|
// mark element as dynamic |
|
el.hasBindings = true; |
|
// modifiers |
|
modifiers = parseModifiers(name); |
|
if (modifiers) { |
|
name = name.replace(modifierRE, ''); |
|
} |
|
if (bindRE.test(name)) { // v-bind |
|
name = name.replace(bindRE, ''); |
|
value = parseFilters(value); |
|
isProp = false; |
|
if (modifiers) { |
|
if (modifiers.prop) { |
|
isProp = true; |
|
name = camelize(name); |
|
if (name === 'innerHtml') name = 'innerHTML'; |
|
} |
|
if (modifiers.camel) { |
|
name = camelize(name); |
|
} |
|
if (modifiers.sync) { |
|
addHandler( |
|
el, |
|
`update:${camelize(name)}`, |
|
genAssignmentCode(value, `$event`) |
|
); |
|
} |
|
} |
|
if (isProp || ( |
|
!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name) |
|
)) { |
|
addProp(el, name, value); |
|
} else { |
|
addAttr(el, name, value); |
|
} |
|
} else if (onRE.test(name)) { // v-on |
|
name = name.replace(onRE, ''); |
|
addHandler(el, name, value, modifiers, false, warn$2); |
|
} else { // normal directives |
|
name = name.replace(dirRE, ''); |
|
// parse arg |
|
const argMatch = name.match(argRE); |
|
const arg = argMatch && argMatch[1]; |
|
if (arg) { |
|
name = name.slice(0, -(arg.length + 1)); |
|
} |
|
addDirective(el, name, rawName, value, arg, modifiers); |
|
if ("development" !== 'production' && name === 'model') { |
|
checkForAliasModel(el, value); |
|
} |
|
} |
|
} else { |
|
// literal attribute |
|
{ |
|
const expression = parseText(value, delimiters); |
|
if (expression) { |
|
warn$2( |
|
`${name}="${value}": ` + |
|
'Interpolation inside attributes has been removed. ' + |
|
'Use v-bind or the colon shorthand instead. For example, ' + |
|
'instead of <div id="{{ val }}">, use <div :id="val">.' |
|
); |
|
} |
|
} |
|
addAttr(el, name, JSON.stringify(value)); |
|
// #6887 firefox doesn't update muted state if set via attribute |
|
// even immediately after element creation |
|
if (!el.component && |
|
name === 'muted' && |
|
platformMustUseProp(el.tag, el.attrsMap.type, name)) { |
|
addProp(el, name, 'true'); |
|
} |
|
} |
|
} |
|
} |
|
|
|
function checkInFor (el) { |
|
let parent = el; |
|
while (parent) { |
|
if (parent.for !== undefined) { |
|
return true |
|
} |
|
parent = parent.parent; |
|
} |
|
return false |
|
} |
|
|
|
function parseModifiers (name) { |
|
const match = name.match(modifierRE); |
|
if (match) { |
|
const ret = {}; |
|
match.forEach(m => { ret[m.slice(1)] = true; }); |
|
return ret |
|
} |
|
} |
|
|
|
function makeAttrsMap (attrs) { |
|
const map = {}; |
|
for (let i = 0, l = attrs.length; i < l; i++) { |
|
if ( |
|
"development" !== 'production' && |
|
map[attrs[i].name] && !isIE && !isEdge |
|
) { |
|
warn$2('duplicate attribute: ' + attrs[i].name); |
|
} |
|
map[attrs[i].name] = attrs[i].value; |
|
} |
|
return map |
|
} |
|
|
|
// for script (e.g. type="x/template") or style, do not decode content |
|
function isTextTag (el) { |
|
return el.tag === 'script' || el.tag === 'style' |
|
} |
|
|
|
function isForbiddenTag (el) { |
|
return ( |
|
el.tag === 'style' || |
|
(el.tag === 'script' && ( |
|
!el.attrsMap.type || |
|
el.attrsMap.type === 'text/javascript' |
|
)) |
|
) |
|
} |
|
|
|
const ieNSBug = /^xmlns:NS\d+/; |
|
const ieNSPrefix = /^NS\d+:/; |
|
|
|
/* istanbul ignore next */ |
|
function guardIESVGBug (attrs) { |
|
const res = []; |
|
for (let i = 0; i < attrs.length; i++) { |
|
const attr = attrs[i]; |
|
if (!ieNSBug.test(attr.name)) { |
|
attr.name = attr.name.replace(ieNSPrefix, ''); |
|
res.push(attr); |
|
} |
|
} |
|
return res |
|
} |
|
|
|
function checkForAliasModel (el, value) { |
|
let _el = el; |
|
while (_el) { |
|
if (_el.for && _el.alias === value) { |
|
warn$2( |
|
`<${el.tag} v-model="${value}">: ` + |
|
`You are binding v-model directly to a v-for iteration alias. ` + |
|
`This will not be able to modify the v-for source array because ` + |
|
`writing to the alias is like modifying a function local variable. ` + |
|
`Consider using an array of objects and use v-model on an object property instead.` |
|
); |
|
} |
|
_el = _el.parent; |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
/** |
|
* Expand input[v-model] with dyanmic type bindings into v-if-else chains |
|
* Turn this: |
|
* <input v-model="data[type]" :type="type"> |
|
* into this: |
|
* <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]"> |
|
* <input v-else-if="type === 'radio'" type="radio" v-model="data[type]"> |
|
* <input v-else :type="type" v-model="data[type]"> |
|
*/ |
|
|
|
function preTransformNode (el, options) { |
|
if (el.tag === 'input') { |
|
const map = el.attrsMap; |
|
if (map['v-model'] && (map['v-bind:type'] || map[':type'])) { |
|
const typeBinding = getBindingAttr(el, 'type'); |
|
const ifCondition = getAndRemoveAttr(el, 'v-if', true); |
|
const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``; |
|
const hasElse = getAndRemoveAttr(el, 'v-else', true) != null; |
|
const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true); |
|
// 1. checkbox |
|
const branch0 = cloneASTElement(el); |
|
// process for on the main node |
|
processFor(branch0); |
|
addRawAttr(branch0, 'type', 'checkbox'); |
|
processElement(branch0, options); |
|
branch0.processed = true; // prevent it from double-processed |
|
branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra; |
|
addIfCondition(branch0, { |
|
exp: branch0.if, |
|
block: branch0 |
|
}); |
|
// 2. add radio else-if condition |
|
const branch1 = cloneASTElement(el); |
|
getAndRemoveAttr(branch1, 'v-for', true); |
|
addRawAttr(branch1, 'type', 'radio'); |
|
processElement(branch1, options); |
|
addIfCondition(branch0, { |
|
exp: `(${typeBinding})==='radio'` + ifConditionExtra, |
|
block: branch1 |
|
}); |
|
// 3. other |
|
const branch2 = cloneASTElement(el); |
|
getAndRemoveAttr(branch2, 'v-for', true); |
|
addRawAttr(branch2, ':type', typeBinding); |
|
processElement(branch2, options); |
|
addIfCondition(branch0, { |
|
exp: ifCondition, |
|
block: branch2 |
|
}); |
|
|
|
if (hasElse) { |
|
branch0.else = true; |
|
} else if (elseIfCondition) { |
|
branch0.elseif = elseIfCondition; |
|
} |
|
|
|
return branch0 |
|
} |
|
} |
|
} |
|
|
|
function cloneASTElement (el) { |
|
return createASTElement(el.tag, el.attrsList.slice(), el.parent) |
|
} |
|
|
|
function addRawAttr (el, name, value) { |
|
el.attrsMap[name] = value; |
|
el.attrsList.push({ name, value }); |
|
} |
|
|
|
var model$2 = { |
|
preTransformNode |
|
}; |
|
|
|
var modules$1 = [ |
|
klass$1, |
|
style$1, |
|
model$2 |
|
]; |
|
|
|
/* */ |
|
|
|
function text (el, dir) { |
|
if (dir.value) { |
|
addProp(el, 'textContent', `_s(${dir.value})`); |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function html (el, dir) { |
|
if (dir.value) { |
|
addProp(el, 'innerHTML', `_s(${dir.value})`); |
|
} |
|
} |
|
|
|
var directives$1 = { |
|
model, |
|
text, |
|
html |
|
}; |
|
|
|
/* */ |
|
|
|
const baseOptions = { |
|
expectHTML: true, |
|
modules: modules$1, |
|
directives: directives$1, |
|
isPreTag, |
|
isUnaryTag, |
|
mustUseProp, |
|
canBeLeftOpenTag, |
|
isReservedTag, |
|
getTagNamespace, |
|
staticKeys: genStaticKeys(modules$1) |
|
}; |
|
|
|
/* */ |
|
|
|
let isStaticKey; |
|
let isPlatformReservedTag; |
|
|
|
const genStaticKeysCached = cached(genStaticKeys$1); |
|
|
|
/** |
|
* Goal of the optimizer: walk the generated template AST tree |
|
* and detect sub-trees that are purely static, i.e. parts of |
|
* the DOM that never needs to change. |
|
* |
|
* Once we detect these sub-trees, we can: |
|
* |
|
* 1. Hoist them into constants, so that we no longer need to |
|
* create fresh nodes for them on each re-render; |
|
* 2. Completely skip them in the patching process. |
|
*/ |
|
function optimize (root, options) { |
|
if (!root) return |
|
isStaticKey = genStaticKeysCached(options.staticKeys || ''); |
|
isPlatformReservedTag = options.isReservedTag || no; |
|
// first pass: mark all non-static nodes. |
|
markStatic$1(root); |
|
// second pass: mark static roots. |
|
markStaticRoots(root, false); |
|
} |
|
|
|
function genStaticKeys$1 (keys) { |
|
return makeMap( |
|
'type,tag,attrsList,attrsMap,plain,parent,children,attrs' + |
|
(keys ? ',' + keys : '') |
|
) |
|
} |
|
|
|
function markStatic$1 (node) { |
|
node.static = isStatic(node); |
|
if (node.type === 1) { |
|
// do not make component slot content static. this avoids |
|
// 1. components not able to mutate slot nodes |
|
// 2. static slot content fails for hot-reloading |
|
if ( |
|
!isPlatformReservedTag(node.tag) && |
|
node.tag !== 'slot' && |
|
node.attrsMap['inline-template'] == null |
|
) { |
|
return |
|
} |
|
for (let i = 0, l = node.children.length; i < l; i++) { |
|
const child = node.children[i]; |
|
markStatic$1(child); |
|
if (!child.static) { |
|
node.static = false; |
|
} |
|
} |
|
if (node.ifConditions) { |
|
for (let i = 1, l = node.ifConditions.length; i < l; i++) { |
|
const block = node.ifConditions[i].block; |
|
markStatic$1(block); |
|
if (!block.static) { |
|
node.static = false; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
function markStaticRoots (node, isInFor) { |
|
if (node.type === 1) { |
|
if (node.static || node.once) { |
|
node.staticInFor = isInFor; |
|
} |
|
// For a node to qualify as a static root, it should have children that |
|
// are not just static text. Otherwise the cost of hoisting out will |
|
// outweigh the benefits and it's better off to just always render it fresh. |
|
if (node.static && node.children.length && !( |
|
node.children.length === 1 && |
|
node.children[0].type === 3 |
|
)) { |
|
node.staticRoot = true; |
|
return |
|
} else { |
|
node.staticRoot = false; |
|
} |
|
if (node.children) { |
|
for (let i = 0, l = node.children.length; i < l; i++) { |
|
markStaticRoots(node.children[i], isInFor || !!node.for); |
|
} |
|
} |
|
if (node.ifConditions) { |
|
for (let i = 1, l = node.ifConditions.length; i < l; i++) { |
|
markStaticRoots(node.ifConditions[i].block, isInFor); |
|
} |
|
} |
|
} |
|
} |
|
|
|
function isStatic (node) { |
|
if (node.type === 2) { // expression |
|
return false |
|
} |
|
if (node.type === 3) { // text |
|
return true |
|
} |
|
return !!(node.pre || ( |
|
!node.hasBindings && // no dynamic bindings |
|
!node.if && !node.for && // not v-if or v-for or v-else |
|
!isBuiltInTag(node.tag) && // not a built-in |
|
isPlatformReservedTag(node.tag) && // not a component |
|
!isDirectChildOfTemplateFor(node) && |
|
Object.keys(node).every(isStaticKey) |
|
)) |
|
} |
|
|
|
function isDirectChildOfTemplateFor (node) { |
|
while (node.parent) { |
|
node = node.parent; |
|
if (node.tag !== 'template') { |
|
return false |
|
} |
|
if (node.for) { |
|
return true |
|
} |
|
} |
|
return false |
|
} |
|
|
|
/* */ |
|
|
|
const fnExpRE = /^\s*([\w$_]+|\([^)]*?\))\s*=>|^function\s*\(/; |
|
const simplePathRE = /^\s*[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?']|\[".*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*\s*$/; |
|
|
|
// keyCode aliases |
|
const keyCodes = { |
|
esc: 27, |
|
tab: 9, |
|
enter: 13, |
|
space: 32, |
|
up: 38, |
|
left: 37, |
|
right: 39, |
|
down: 40, |
|
'delete': [8, 46] |
|
}; |
|
|
|
// #4868: modifiers that prevent the execution of the listener |
|
// need to explicitly return null so that we can determine whether to remove |
|
// the listener for .once |
|
const genGuard = condition => `if(${condition})return null;`; |
|
|
|
const modifierCode = { |
|
stop: '$event.stopPropagation();', |
|
prevent: '$event.preventDefault();', |
|
self: genGuard(`$event.target !== $event.currentTarget`), |
|
ctrl: genGuard(`!$event.ctrlKey`), |
|
shift: genGuard(`!$event.shiftKey`), |
|
alt: genGuard(`!$event.altKey`), |
|
meta: genGuard(`!$event.metaKey`), |
|
left: genGuard(`'button' in $event && $event.button !== 0`), |
|
middle: genGuard(`'button' in $event && $event.button !== 1`), |
|
right: genGuard(`'button' in $event && $event.button !== 2`) |
|
}; |
|
|
|
function genHandlers ( |
|
events, |
|
isNative, |
|
warn |
|
) { |
|
let res = isNative ? 'nativeOn:{' : 'on:{'; |
|
for (const name in events) { |
|
res += `"${name}":${genHandler(name, events[name])},`; |
|
} |
|
return res.slice(0, -1) + '}' |
|
} |
|
|
|
function genHandler ( |
|
name, |
|
handler |
|
) { |
|
if (!handler) { |
|
return 'function(){}' |
|
} |
|
|
|
if (Array.isArray(handler)) { |
|
return `[${handler.map(handler => genHandler(name, handler)).join(',')}]` |
|
} |
|
|
|
const isMethodPath = simplePathRE.test(handler.value); |
|
const isFunctionExpression = fnExpRE.test(handler.value); |
|
|
|
if (!handler.modifiers) { |
|
return isMethodPath || isFunctionExpression |
|
? handler.value |
|
: `function($event){${handler.value}}` // inline statement |
|
} else { |
|
let code = ''; |
|
let genModifierCode = ''; |
|
const keys = []; |
|
for (const key in handler.modifiers) { |
|
if (modifierCode[key]) { |
|
genModifierCode += modifierCode[key]; |
|
// left/right |
|
if (keyCodes[key]) { |
|
keys.push(key); |
|
} |
|
} else if (key === 'exact') { |
|
const modifiers = (handler.modifiers); |
|
genModifierCode += genGuard( |
|
['ctrl', 'shift', 'alt', 'meta'] |
|
.filter(keyModifier => !modifiers[keyModifier]) |
|
.map(keyModifier => `$event.${keyModifier}Key`) |
|
.join('||') |
|
); |
|
} else { |
|
keys.push(key); |
|
} |
|
} |
|
if (keys.length) { |
|
code += genKeyFilter(keys); |
|
} |
|
// Make sure modifiers like prevent and stop get executed after key filtering |
|
if (genModifierCode) { |
|
code += genModifierCode; |
|
} |
|
const handlerCode = isMethodPath |
|
? handler.value + '($event)' |
|
: isFunctionExpression |
|
? `(${handler.value})($event)` |
|
: handler.value; |
|
return `function($event){${code}${handlerCode}}` |
|
} |
|
} |
|
|
|
function genKeyFilter (keys) { |
|
return `if(!('button' in $event)&&${keys.map(genFilterCode).join('&&')})return null;` |
|
} |
|
|
|
function genFilterCode (key) { |
|
const keyVal = parseInt(key, 10); |
|
if (keyVal) { |
|
return `$event.keyCode!==${keyVal}` |
|
} |
|
const code = keyCodes[key]; |
|
return ( |
|
`_k($event.keyCode,` + |
|
`${JSON.stringify(key)},` + |
|
`${JSON.stringify(code)},` + |
|
`$event.key)` |
|
) |
|
} |
|
|
|
/* */ |
|
|
|
function on (el, dir) { |
|
if ("development" !== 'production' && dir.modifiers) { |
|
warn(`v-on without argument does not support modifiers.`); |
|
} |
|
el.wrapListeners = (code) => `_g(${code},${dir.value})`; |
|
} |
|
|
|
/* */ |
|
|
|
function bind$1 (el, dir) { |
|
el.wrapData = (code) => { |
|
return `_b(${code},'${el.tag}',${dir.value},${ |
|
dir.modifiers && dir.modifiers.prop ? 'true' : 'false' |
|
}${ |
|
dir.modifiers && dir.modifiers.sync ? ',true' : '' |
|
})` |
|
}; |
|
} |
|
|
|
/* */ |
|
|
|
var baseDirectives = { |
|
on, |
|
bind: bind$1, |
|
cloak: noop |
|
}; |
|
|
|
/* */ |
|
|
|
class CodegenState { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
constructor (options) { |
|
this.options = options; |
|
this.warn = options.warn || baseWarn; |
|
this.transforms = pluckModuleFunction(options.modules, 'transformCode'); |
|
this.dataGenFns = pluckModuleFunction(options.modules, 'genData'); |
|
this.directives = extend(extend({}, baseDirectives), options.directives); |
|
const isReservedTag = options.isReservedTag || no; |
|
this.maybeComponent = (el) => !isReservedTag(el.tag); |
|
this.onceId = 0; |
|
this.staticRenderFns = []; |
|
} |
|
} |
|
|
|
|
|
|
|
function generate ( |
|
ast, |
|
options |
|
) { |
|
const state = new CodegenState(options); |
|
const code = ast ? genElement(ast, state) : '_c("div")'; |
|
return { |
|
render: `with(this){return ${code}}`, |
|
staticRenderFns: state.staticRenderFns |
|
} |
|
} |
|
|
|
function genElement (el, state) { |
|
if (el.staticRoot && !el.staticProcessed) { |
|
return genStatic(el, state) |
|
} else if (el.once && !el.onceProcessed) { |
|
return genOnce(el, state) |
|
} else if (el.for && !el.forProcessed) { |
|
return genFor(el, state) |
|
} else if (el.if && !el.ifProcessed) { |
|
return genIf(el, state) |
|
} else if (el.tag === 'template' && !el.slotTarget) { |
|
return genChildren(el, state) || 'void 0' |
|
} else if (el.tag === 'slot') { |
|
return genSlot(el, state) |
|
} else { |
|
// component or element |
|
let code; |
|
if (el.component) { |
|
code = genComponent(el.component, el, state); |
|
} else { |
|
const data = el.plain ? undefined : genData$2(el, state); |
|
|
|
const children = el.inlineTemplate ? null : genChildren(el, state, true); |
|
code = `_c('${el.tag}'${ |
|
data ? `,${data}` : '' // data |
|
}${ |
|
children ? `,${children}` : '' // children |
|
})`; |
|
} |
|
// module transforms |
|
for (let i = 0; i < state.transforms.length; i++) { |
|
code = state.transforms[i](el, code); |
|
} |
|
return code |
|
} |
|
} |
|
|
|
// hoist static sub-trees out |
|
function genStatic (el, state, once$$1) { |
|
el.staticProcessed = true; |
|
state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`); |
|
return `_m(${ |
|
state.staticRenderFns.length - 1 |
|
},${ |
|
el.staticInFor ? 'true' : 'false' |
|
},${ |
|
once$$1 ? 'true' : 'false' |
|
})` |
|
} |
|
|
|
// v-once |
|
function genOnce (el, state) { |
|
el.onceProcessed = true; |
|
if (el.if && !el.ifProcessed) { |
|
return genIf(el, state) |
|
} else if (el.staticInFor) { |
|
let key = ''; |
|
let parent = el.parent; |
|
while (parent) { |
|
if (parent.for) { |
|
key = parent.key; |
|
break |
|
} |
|
parent = parent.parent; |
|
} |
|
if (!key) { |
|
"development" !== 'production' && state.warn( |
|
`v-once can only be used inside v-for that is keyed. ` |
|
); |
|
return genElement(el, state) |
|
} |
|
return `_o(${genElement(el, state)},${state.onceId++},${key})` |
|
} else { |
|
return genStatic(el, state, true) |
|
} |
|
} |
|
|
|
function genIf ( |
|
el, |
|
state, |
|
altGen, |
|
altEmpty |
|
) { |
|
el.ifProcessed = true; // avoid recursion |
|
return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty) |
|
} |
|
|
|
function genIfConditions ( |
|
conditions, |
|
state, |
|
altGen, |
|
altEmpty |
|
) { |
|
if (!conditions.length) { |
|
return altEmpty || '_e()' |
|
} |
|
|
|
const condition = conditions.shift(); |
|
if (condition.exp) { |
|
return `(${condition.exp})?${ |
|
genTernaryExp(condition.block) |
|
}:${ |
|
genIfConditions(conditions, state, altGen, altEmpty) |
|
}` |
|
} else { |
|
return `${genTernaryExp(condition.block)}` |
|
} |
|
|
|
// v-if with v-once should generate code like (a)?_m(0):_m(1) |
|
function genTernaryExp (el) { |
|
return altGen |
|
? altGen(el, state) |
|
: el.once |
|
? genOnce(el, state) |
|
: genElement(el, state) |
|
} |
|
} |
|
|
|
function genFor ( |
|
el, |
|
state, |
|
altGen, |
|
altHelper |
|
) { |
|
const exp = el.for; |
|
const alias = el.alias; |
|
const iterator1 = el.iterator1 ? `,${el.iterator1}` : ''; |
|
const iterator2 = el.iterator2 ? `,${el.iterator2}` : ''; |
|
|
|
if ("development" !== 'production' && |
|
state.maybeComponent(el) && |
|
el.tag !== 'slot' && |
|
el.tag !== 'template' && |
|
!el.key |
|
) { |
|
state.warn( |
|
`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` + |
|
`v-for should have explicit keys. ` + |
|
`See https://vuejs.org/guide/list.html#key for more info.`, |
|
true /* tip */ |
|
); |
|
} |
|
|
|
el.forProcessed = true; // avoid recursion |
|
return `${altHelper || '_l'}((${exp}),` + |
|
`function(${alias}${iterator1}${iterator2}){` + |
|
`return ${(altGen || genElement)(el, state)}` + |
|
'})' |
|
} |
|
|
|
function genData$2 (el, state) { |
|
let data = '{'; |
|
|
|
// directives first. |
|
// directives may mutate the el's other properties before they are generated. |
|
const dirs = genDirectives(el, state); |
|
if (dirs) data += dirs + ','; |
|
|
|
// key |
|
if (el.key) { |
|
data += `key:${el.key},`; |
|
} |
|
// ref |
|
if (el.ref) { |
|
data += `ref:${el.ref},`; |
|
} |
|
if (el.refInFor) { |
|
data += `refInFor:true,`; |
|
} |
|
// pre |
|
if (el.pre) { |
|
data += `pre:true,`; |
|
} |
|
// record original tag name for components using "is" attribute |
|
if (el.component) { |
|
data += `tag:"${el.tag}",`; |
|
} |
|
// module data generation functions |
|
for (let i = 0; i < state.dataGenFns.length; i++) { |
|
data += state.dataGenFns[i](el); |
|
} |
|
// attributes |
|
if (el.attrs) { |
|
data += `attrs:{${genProps(el.attrs)}},`; |
|
} |
|
// DOM props |
|
if (el.props) { |
|
data += `domProps:{${genProps(el.props)}},`; |
|
} |
|
// event handlers |
|
if (el.events) { |
|
data += `${genHandlers(el.events, false, state.warn)},`; |
|
} |
|
if (el.nativeEvents) { |
|
data += `${genHandlers(el.nativeEvents, true, state.warn)},`; |
|
} |
|
// slot target |
|
// only for non-scoped slots |
|
if (el.slotTarget && !el.slotScope) { |
|
data += `slot:${el.slotTarget},`; |
|
} |
|
// scoped slots |
|
if (el.scopedSlots) { |
|
data += `${genScopedSlots(el.scopedSlots, state)},`; |
|
} |
|
// component v-model |
|
if (el.model) { |
|
data += `model:{value:${ |
|
el.model.value |
|
},callback:${ |
|
el.model.callback |
|
},expression:${ |
|
el.model.expression |
|
}},`; |
|
} |
|
// inline-template |
|
if (el.inlineTemplate) { |
|
const inlineTemplate = genInlineTemplate(el, state); |
|
if (inlineTemplate) { |
|
data += `${inlineTemplate},`; |
|
} |
|
} |
|
data = data.replace(/,$/, '') + '}'; |
|
// v-bind data wrap |
|
if (el.wrapData) { |
|
data = el.wrapData(data); |
|
} |
|
// v-on data wrap |
|
if (el.wrapListeners) { |
|
data = el.wrapListeners(data); |
|
} |
|
return data |
|
} |
|
|
|
function genDirectives (el, state) { |
|
const dirs = el.directives; |
|
if (!dirs) return |
|
let res = 'directives:['; |
|
let hasRuntime = false; |
|
let i, l, dir, needRuntime; |
|
for (i = 0, l = dirs.length; i < l; i++) { |
|
dir = dirs[i]; |
|
needRuntime = true; |
|
const gen = state.directives[dir.name]; |
|
if (gen) { |
|
// compile-time directive that manipulates AST. |
|
// returns true if it also needs a runtime counterpart. |
|
needRuntime = !!gen(el, dir, state.warn); |
|
} |
|
if (needRuntime) { |
|
hasRuntime = true; |
|
res += `{name:"${dir.name}",rawName:"${dir.rawName}"${ |
|
dir.value ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}` : '' |
|
}${ |
|
dir.arg ? `,arg:"${dir.arg}"` : '' |
|
}${ |
|
dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : '' |
|
}},`; |
|
} |
|
} |
|
if (hasRuntime) { |
|
return res.slice(0, -1) + ']' |
|
} |
|
} |
|
|
|
function genInlineTemplate (el, state) { |
|
const ast = el.children[0]; |
|
if ("development" !== 'production' && ( |
|
el.children.length !== 1 || ast.type !== 1 |
|
)) { |
|
state.warn('Inline-template components must have exactly one child element.'); |
|
} |
|
if (ast.type === 1) { |
|
const inlineRenderFns = generate(ast, state.options); |
|
return `inlineTemplate:{render:function(){${ |
|
inlineRenderFns.render |
|
}},staticRenderFns:[${ |
|
inlineRenderFns.staticRenderFns.map(code => `function(){${code}}`).join(',') |
|
}]}` |
|
} |
|
} |
|
|
|
function genScopedSlots ( |
|
slots, |
|
state |
|
) { |
|
return `scopedSlots:_u([${ |
|
Object.keys(slots).map(key => { |
|
return genScopedSlot(key, slots[key], state) |
|
}).join(',') |
|
}])` |
|
} |
|
|
|
function genScopedSlot ( |
|
key, |
|
el, |
|
state |
|
) { |
|
if (el.for && !el.forProcessed) { |
|
return genForScopedSlot(key, el, state) |
|
} |
|
const fn = `function(${String(el.slotScope)}){` + |
|
`return ${el.tag === 'template' |
|
? el.if |
|
? `${el.if}?${genChildren(el, state) || 'undefined'}:undefined` |
|
: genChildren(el, state) || 'undefined' |
|
: genElement(el, state) |
|
}}`; |
|
return `{key:${key},fn:${fn}}` |
|
} |
|
|
|
function genForScopedSlot ( |
|
key, |
|
el, |
|
state |
|
) { |
|
const exp = el.for; |
|
const alias = el.alias; |
|
const iterator1 = el.iterator1 ? `,${el.iterator1}` : ''; |
|
const iterator2 = el.iterator2 ? `,${el.iterator2}` : ''; |
|
el.forProcessed = true; // avoid recursion |
|
return `_l((${exp}),` + |
|
`function(${alias}${iterator1}${iterator2}){` + |
|
`return ${genScopedSlot(key, el, state)}` + |
|
'})' |
|
} |
|
|
|
function genChildren ( |
|
el, |
|
state, |
|
checkSkip, |
|
altGenElement, |
|
altGenNode |
|
) { |
|
const children = el.children; |
|
if (children.length) { |
|
const el = children[0]; |
|
// optimize single v-for |
|
if (children.length === 1 && |
|
el.for && |
|
el.tag !== 'template' && |
|
el.tag !== 'slot' |
|
) { |
|
return (altGenElement || genElement)(el, state) |
|
} |
|
const normalizationType = checkSkip |
|
? getNormalizationType(children, state.maybeComponent) |
|
: 0; |
|
const gen = altGenNode || genNode; |
|
return `[${children.map(c => gen(c, state)).join(',')}]${ |
|
normalizationType ? `,${normalizationType}` : '' |
|
}` |
|
} |
|
} |
|
|
|
// determine the normalization needed for the children array. |
|
// 0: no normalization needed |
|
// 1: simple normalization needed (possible 1-level deep nested array) |
|
// 2: full normalization needed |
|
function getNormalizationType ( |
|
children, |
|
maybeComponent |
|
) { |
|
let res = 0; |
|
for (let i = 0; i < children.length; i++) { |
|
const el = children[i]; |
|
if (el.type !== 1) { |
|
continue |
|
} |
|
if (needsNormalization(el) || |
|
(el.ifConditions && el.ifConditions.some(c => needsNormalization(c.block)))) { |
|
res = 2; |
|
break |
|
} |
|
if (maybeComponent(el) || |
|
(el.ifConditions && el.ifConditions.some(c => maybeComponent(c.block)))) { |
|
res = 1; |
|
} |
|
} |
|
return res |
|
} |
|
|
|
function needsNormalization (el) { |
|
return el.for !== undefined || el.tag === 'template' || el.tag === 'slot' |
|
} |
|
|
|
function genNode (node, state) { |
|
if (node.type === 1) { |
|
return genElement(node, state) |
|
} if (node.type === 3 && node.isComment) { |
|
return genComment(node) |
|
} else { |
|
return genText(node) |
|
} |
|
} |
|
|
|
function genText (text) { |
|
return `_v(${text.type === 2 |
|
? text.expression // no need for () because already wrapped in _s() |
|
: transformSpecialNewlines(JSON.stringify(text.text)) |
|
})` |
|
} |
|
|
|
function genComment (comment) { |
|
return `_e(${JSON.stringify(comment.text)})` |
|
} |
|
|
|
function genSlot (el, state) { |
|
const slotName = el.slotName || '"default"'; |
|
const children = genChildren(el, state); |
|
let res = `_t(${slotName}${children ? `,${children}` : ''}`; |
|
const attrs = el.attrs && `{${el.attrs.map(a => `${camelize(a.name)}:${a.value}`).join(',')}}`; |
|
const bind$$1 = el.attrsMap['v-bind']; |
|
if ((attrs || bind$$1) && !children) { |
|
res += `,null`; |
|
} |
|
if (attrs) { |
|
res += `,${attrs}`; |
|
} |
|
if (bind$$1) { |
|
res += `${attrs ? '' : ',null'},${bind$$1}`; |
|
} |
|
return res + ')' |
|
} |
|
|
|
// componentName is el.component, take it as argument to shun flow's pessimistic refinement |
|
function genComponent ( |
|
componentName, |
|
el, |
|
state |
|
) { |
|
const children = el.inlineTemplate ? null : genChildren(el, state, true); |
|
return `_c(${componentName},${genData$2(el, state)}${ |
|
children ? `,${children}` : '' |
|
})` |
|
} |
|
|
|
function genProps (props) { |
|
let res = ''; |
|
for (let i = 0; i < props.length; i++) { |
|
const prop = props[i]; |
|
res += `"${prop.name}":${transformSpecialNewlines(prop.value)},`; |
|
} |
|
return res.slice(0, -1) |
|
} |
|
|
|
// #3895, #4268 |
|
function transformSpecialNewlines (text) { |
|
return text |
|
.replace(/\u2028/g, '\\u2028') |
|
.replace(/\u2029/g, '\\u2029') |
|
} |
|
|
|
/* */ |
|
|
|
// these keywords should not appear inside expressions, but operators like |
|
// typeof, instanceof and in are allowed |
|
const prohibitedKeywordRE = new RegExp('\\b' + ( |
|
'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + |
|
'super,throw,while,yield,delete,export,import,return,switch,default,' + |
|
'extends,finally,continue,debugger,function,arguments' |
|
).split(',').join('\\b|\\b') + '\\b'); |
|
|
|
// these unary operators should not be used as property/method names |
|
const unaryOperatorsRE = new RegExp('\\b' + ( |
|
'delete,typeof,void' |
|
).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)'); |
|
|
|
// strip strings in expressions |
|
const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; |
|
|
|
// detect problematic expressions in a template |
|
function detectErrors (ast) { |
|
const errors = []; |
|
if (ast) { |
|
checkNode(ast, errors); |
|
} |
|
return errors |
|
} |
|
|
|
function checkNode (node, errors) { |
|
if (node.type === 1) { |
|
for (const name in node.attrsMap) { |
|
if (dirRE.test(name)) { |
|
const value = node.attrsMap[name]; |
|
if (value) { |
|
if (name === 'v-for') { |
|
checkFor(node, `v-for="${value}"`, errors); |
|
} else if (onRE.test(name)) { |
|
checkEvent(value, `${name}="${value}"`, errors); |
|
} else { |
|
checkExpression(value, `${name}="${value}"`, errors); |
|
} |
|
} |
|
} |
|
} |
|
if (node.children) { |
|
for (let i = 0; i < node.children.length; i++) { |
|
checkNode(node.children[i], errors); |
|
} |
|
} |
|
} else if (node.type === 2) { |
|
checkExpression(node.expression, node.text, errors); |
|
} |
|
} |
|
|
|
function checkEvent (exp, text, errors) { |
|
const stipped = exp.replace(stripStringRE, ''); |
|
const keywordMatch = stipped.match(unaryOperatorsRE); |
|
if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') { |
|
errors.push( |
|
`avoid using JavaScript unary operator as property name: ` + |
|
`"${keywordMatch[0]}" in expression ${text.trim()}` |
|
); |
|
} |
|
checkExpression(exp, text, errors); |
|
} |
|
|
|
function checkFor (node, text, errors) { |
|
checkExpression(node.for || '', text, errors); |
|
checkIdentifier(node.alias, 'v-for alias', text, errors); |
|
checkIdentifier(node.iterator1, 'v-for iterator', text, errors); |
|
checkIdentifier(node.iterator2, 'v-for iterator', text, errors); |
|
} |
|
|
|
function checkIdentifier ( |
|
ident, |
|
type, |
|
text, |
|
errors |
|
) { |
|
if (typeof ident === 'string') { |
|
try { |
|
new Function(`var ${ident}=_`); |
|
} catch (e) { |
|
errors.push(`invalid ${type} "${ident}" in expression: ${text.trim()}`); |
|
} |
|
} |
|
} |
|
|
|
function checkExpression (exp, text, errors) { |
|
try { |
|
new Function(`return ${exp}`); |
|
} catch (e) { |
|
const keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE); |
|
if (keywordMatch) { |
|
errors.push( |
|
`avoid using JavaScript keyword as property name: ` + |
|
`"${keywordMatch[0]}"\n Raw expression: ${text.trim()}` |
|
); |
|
} else { |
|
errors.push( |
|
`invalid expression: ${e.message} in\n\n` + |
|
` ${exp}\n\n` + |
|
` Raw expression: ${text.trim()}\n` |
|
); |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function createFunction (code, errors) { |
|
try { |
|
return new Function(code) |
|
} catch (err) { |
|
errors.push({ err, code }); |
|
return noop |
|
} |
|
} |
|
|
|
function createCompileToFunctionFn (compile) { |
|
const cache = Object.create(null); |
|
|
|
return function compileToFunctions ( |
|
template, |
|
options, |
|
vm |
|
) { |
|
options = extend({}, options); |
|
const warn$$1 = options.warn || warn; |
|
delete options.warn; |
|
|
|
/* istanbul ignore if */ |
|
{ |
|
// detect possible CSP restriction |
|
try { |
|
new Function('return 1'); |
|
} catch (e) { |
|
if (e.toString().match(/unsafe-eval|CSP/)) { |
|
warn$$1( |
|
'It seems you are using the standalone build of Vue.js in an ' + |
|
'environment with Content Security Policy that prohibits unsafe-eval. ' + |
|
'The template compiler cannot work in this environment. Consider ' + |
|
'relaxing the policy to allow unsafe-eval or pre-compiling your ' + |
|
'templates into render functions.' |
|
); |
|
} |
|
} |
|
} |
|
|
|
// check cache |
|
const key = options.delimiters |
|
? String(options.delimiters) + template |
|
: template; |
|
if (cache[key]) { |
|
return cache[key] |
|
} |
|
|
|
// compile |
|
const compiled = compile(template, options); |
|
|
|
// check compilation errors/tips |
|
{ |
|
if (compiled.errors && compiled.errors.length) { |
|
warn$$1( |
|
`Error compiling template:\n\n${template}\n\n` + |
|
compiled.errors.map(e => `- ${e}`).join('\n') + '\n', |
|
vm |
|
); |
|
} |
|
if (compiled.tips && compiled.tips.length) { |
|
compiled.tips.forEach(msg => tip(msg, vm)); |
|
} |
|
} |
|
|
|
// turn code into functions |
|
const res = {}; |
|
const fnGenErrors = []; |
|
res.render = createFunction(compiled.render, fnGenErrors); |
|
res.staticRenderFns = compiled.staticRenderFns.map(code => { |
|
return createFunction(code, fnGenErrors) |
|
}); |
|
|
|
// check function generation errors. |
|
// this should only happen if there is a bug in the compiler itself. |
|
// mostly for codegen development use |
|
/* istanbul ignore if */ |
|
{ |
|
if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) { |
|
warn$$1( |
|
`Failed to generate render function:\n\n` + |
|
fnGenErrors.map(({ err, code }) => `${err.toString()} in\n\n${code}\n`).join('\n'), |
|
vm |
|
); |
|
} |
|
} |
|
|
|
return (cache[key] = res) |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
function createCompilerCreator (baseCompile) { |
|
return function createCompiler (baseOptions) { |
|
function compile ( |
|
template, |
|
options |
|
) { |
|
const finalOptions = Object.create(baseOptions); |
|
const errors = []; |
|
const tips = []; |
|
finalOptions.warn = (msg, tip) => { |
|
(tip ? tips : errors).push(msg); |
|
}; |
|
|
|
if (options) { |
|
// merge custom modules |
|
if (options.modules) { |
|
finalOptions.modules = |
|
(baseOptions.modules || []).concat(options.modules); |
|
} |
|
// merge custom directives |
|
if (options.directives) { |
|
finalOptions.directives = extend( |
|
Object.create(baseOptions.directives), |
|
options.directives |
|
); |
|
} |
|
// copy other options |
|
for (const key in options) { |
|
if (key !== 'modules' && key !== 'directives') { |
|
finalOptions[key] = options[key]; |
|
} |
|
} |
|
} |
|
|
|
const compiled = baseCompile(template, finalOptions); |
|
{ |
|
errors.push.apply(errors, detectErrors(compiled.ast)); |
|
} |
|
compiled.errors = errors; |
|
compiled.tips = tips; |
|
return compiled |
|
} |
|
|
|
return { |
|
compile, |
|
compileToFunctions: createCompileToFunctionFn(compile) |
|
} |
|
} |
|
} |
|
|
|
/* */ |
|
|
|
// `createCompilerCreator` allows creating compilers that use alternative |
|
// parser/optimizer/codegen, e.g the SSR optimizing compiler. |
|
// Here we just export a default compiler using the default parts. |
|
const createCompiler = createCompilerCreator(function baseCompile ( |
|
template, |
|
options |
|
) { |
|
const ast = parse(template.trim(), options); |
|
optimize(ast, options); |
|
const code = generate(ast, options); |
|
return { |
|
ast, |
|
render: code.render, |
|
staticRenderFns: code.staticRenderFns |
|
} |
|
}); |
|
|
|
/* */ |
|
|
|
const { compile, compileToFunctions } = createCompiler(baseOptions); |
|
|
|
/* */ |
|
|
|
// check whether current browser encodes a char inside attribute values |
|
let div; |
|
function getShouldDecode (href) { |
|
div = div || document.createElement('div'); |
|
div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`; |
|
return div.innerHTML.indexOf(' ') > 0 |
|
} |
|
|
|
// #3663: IE encodes newlines inside attribute values while other browsers don't |
|
const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false; |
|
// #6828: chrome encodes content in a[href] |
|
const shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false; |
|
|
|
/* */ |
|
|
|
const idToTemplate = cached(id => { |
|
const el = query(id); |
|
return el && el.innerHTML |
|
}); |
|
|
|
const mount = Vue$3.prototype.$mount; |
|
Vue$3.prototype.$mount = function ( |
|
el, |
|
hydrating |
|
) { |
|
el = el && query(el); |
|
|
|
/* istanbul ignore if */ |
|
if (el === document.body || el === document.documentElement) { |
|
"development" !== 'production' && warn( |
|
`Do not mount Vue to <html> or <body> - mount to normal elements instead.` |
|
); |
|
return this |
|
} |
|
|
|
const options = this.$options; |
|
// resolve template/el and convert to render function |
|
if (!options.render) { |
|
let template = options.template; |
|
if (template) { |
|
if (typeof template === 'string') { |
|
if (template.charAt(0) === '#') { |
|
template = idToTemplate(template); |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && !template) { |
|
warn( |
|
`Template element not found or is empty: ${options.template}`, |
|
this |
|
); |
|
} |
|
} |
|
} else if (template.nodeType) { |
|
template = template.innerHTML; |
|
} else { |
|
{ |
|
warn('invalid template option:' + template, this); |
|
} |
|
return this |
|
} |
|
} else if (el) { |
|
template = getOuterHTML(el); |
|
} |
|
if (template) { |
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && config.performance && mark) { |
|
mark('compile'); |
|
} |
|
|
|
const { render, staticRenderFns } = compileToFunctions(template, { |
|
shouldDecodeNewlines, |
|
shouldDecodeNewlinesForHref, |
|
delimiters: options.delimiters, |
|
comments: options.comments |
|
}, this); |
|
options.render = render; |
|
options.staticRenderFns = staticRenderFns; |
|
|
|
/* istanbul ignore if */ |
|
if ("development" !== 'production' && config.performance && mark) { |
|
mark('compile end'); |
|
measure(`vue ${this._name} compile`, 'compile', 'compile end'); |
|
} |
|
} |
|
} |
|
return mount.call(this, el, hydrating) |
|
}; |
|
|
|
/** |
|
* Get outerHTML of elements, taking care |
|
* of SVG elements in IE as well. |
|
*/ |
|
function getOuterHTML (el) { |
|
if (el.outerHTML) { |
|
return el.outerHTML |
|
} else { |
|
const container = document.createElement('div'); |
|
container.appendChild(el.cloneNode(true)); |
|
return container.innerHTML |
|
} |
|
} |
|
|
|
Vue$3.compile = compileToFunctions; |
|
|
|
export default Vue$3;
|
|
|