vue 2.6.6 → 2.6.10

package/src/core/observer/scheduler.js

@@ -8,7 +8,8 @@ import {
   warn,
   nextTick,
   devtools,
-  inBrowser
+  inBrowser,
+  isIE
 } from '../util/index'
 
 export const MAX_UPDATE_COUNT = 100
@@ -47,11 +48,21 @@ let getNow: () => number = Date.now
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
 // same timestamp type when saving the flush timestamp.
-if (inBrowser && getNow() > document.createEvent('Event').timeStamp) {
-  // if the low-res timestamp which is bigger than the event timestamp
-  // (which is evaluated AFTER) it means the event is using a hi-res timestamp,
-  // and we need to use the hi-res version for event listeners as well.
-  getNow = () => performance.now()
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+  const performance = window.performance
+  if (
+    performance &&
+    typeof performance.now === 'function' &&
+    getNow() > document.createEvent('Event').timeStamp
+  ) {
+    // if the event timestamp, although evaluated AFTER the Date.now(), is
+    // smaller than it, it means the event is using a hi-res timestamp,
+    // and we need to use the hi-res version for event listener timestamps as
+    // well.
+    getNow = () => performance.now()
+  }
 }
 
 /**

package/src/core/util/error.js

@@ -4,25 +4,33 @@ import config from '../config'
 import { warn } from './debug'
 import { inBrowser, inWeex } from './env'
 import { isPromise } from 'shared/util'
+import { pushTarget, popTarget } from '../observer/dep'
 
 export function handleError (err: Error, vm: any, info: string) {
-  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')
+  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+  // See: https://github.com/vuejs/vuex/issues/1505
+  pushTarget()
+  try {
+    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)
+  } finally {
+    popTarget()
   }
-  globalHandleError(err, vm, info)
 }
 
 export function invokeWithErrorHandling (
@@ -35,8 +43,11 @@ export function invokeWithErrorHandling (
   let res
   try {
     res = args ? handler.apply(context, args) : handler.call(context)
-    if (res && !res._isVue && isPromise(res)) {
+    if (res && !res._isVue && isPromise(res) && !res._handled) {
       res.catch(e => handleError(e, vm, info + ` (Promise/async)`))
+      // issue #9511
+      // avoid catch triggering multiple times when nested calls
+      res._handled = true
     }
   } catch (e) {
     handleError(e, vm, info)

package/src/core/util/lang.js

@@ -5,7 +5,7 @@
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-export const unicodeLetters = 'a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD'
+export const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
 
 /**
  * Check if a string starts with $ or _
@@ -30,7 +30,7 @@ export function def (obj: Object, key: string, val: any, enumerable?: boolean) {
 /**
  * Parse simple path.
  */
-const bailRE = new RegExp(`[^${unicodeLetters}.$_\\d]`)
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`)
 export function parsePath (path: string): any {
   if (bailRE.test(path)) {
     return

package/src/core/util/options.js

@@ -3,7 +3,7 @@
 import config from '../config'
 import { warn } from './debug'
 import { set } from '../observer/index'
-import { unicodeLetters } from './lang'
+import { unicodeRegExp } from './lang'
 import { nativeWatch, hasSymbol } from './env'
 
 import {
@@ -277,7 +277,7 @@ function checkComponents (options: Object) {
 }
 
 export function validateComponentName (name: string) {
-  if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeLetters}]*$`).test(name)) {
+  if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
     warn(
       'Invalid component name: "' + name + '". Component names ' +
       'should conform to valid custom element name in html5 specification.'

package/src/core/vdom/helpers/normalize-scoped-slots.js

@@ -10,16 +10,21 @@ export function normalizeScopedSlots (
   prevSlots?: { [key: string]: Function } | void
 ): any {
   let res
+  const hasNormalSlots = Object.keys(normalSlots).length > 0
+  const isStable = slots ? !!slots.$stable : !hasNormalSlots
+  const key = slots && slots.$key
   if (!slots) {
     res = {}
   } else if (slots._normalized) {
     // fast path 1: child component re-render only, parent did not change
     return slots._normalized
   } else if (
-    slots.$stable &&
+    isStable &&
     prevSlots &&
     prevSlots !== emptyObject &&
-    Object.keys(normalSlots).length === 0
+    key === prevSlots.$key &&
+    !hasNormalSlots &&
+    !prevSlots.$hasNormal
   ) {
     // fast path 2: stable scoped slots w/ no normal slots to proxy,
     // only need to normalize once
@@ -43,7 +48,9 @@ export function normalizeScopedSlots (
   if (slots && Object.isExtensible(slots)) {
     (slots: any)._normalized = res
   }
-  def(res, '$stable', slots ? !!slots.$stable : true)
+  def(res, '$stable', isStable)
+  def(res, '$key', key)
+  def(res, '$hasNormal', hasNormalSlots)
   return res
 }
 
@@ -53,8 +60,10 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     res = res && typeof res === 'object' && !Array.isArray(res)
       ? [res] // single vnode
       : normalizeChildren(res)
-    return res && res.length === 0
-      ? undefined
+    return res && (
+      res.length === 0 ||
+      (res.length === 1 && res[0].isComment) // #9658
+    ) ? undefined
       : res
   }
   // this is a slot using the new v-slot syntax without scope. although it is

package/src/core/vdom/helpers/resolve-async-component.js

@@ -8,7 +8,8 @@ import {
   isTrue,
   isObject,
   hasSymbol,
-  isPromise
+  isPromise,
+  remove
 } from 'core/util/index'
 
 import { createEmptyVNode } from 'core/vdom/vnode'
@@ -51,17 +52,23 @@ export function resolveAsyncComponent (
     return factory.resolved
   }
 
+  const owner = currentRenderingInstance
+  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+    // already pending
+    factory.owners.push(owner)
+  }
+
   if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
     return factory.loadingComp
   }
 
-  const owner = currentRenderingInstance
-  if (isDef(factory.owners)) {
-    // already pending
-    factory.owners.push(owner)
-  } else {
+  if (owner && !isDef(factory.owners)) {
     const owners = factory.owners = [owner]
     let sync = true
+    let timerLoading = null
+    let timerTimeout = null
+
+    ;(owner: any).$on('hook:destroyed', () => remove(owners, owner))
 
     const forceRender = (renderCompleted: boolean) => {
       for (let i = 0, l = owners.length; i < l; i++) {
@@ -70,6 +77,14 @@ export function resolveAsyncComponent (
 
       if (renderCompleted) {
         owners.length = 0
+        if (timerLoading !== null) {
+          clearTimeout(timerLoading)
+          timerLoading = null
+        }
+        if (timerTimeout !== null) {
+          clearTimeout(timerTimeout)
+          timerTimeout = null
+        }
       }
     }
 
@@ -116,7 +131,8 @@ export function resolveAsyncComponent (
           if (res.delay === 0) {
             factory.loading = true
           } else {
-            setTimeout(() => {
+            timerLoading = setTimeout(() => {
+              timerLoading = null
               if (isUndef(factory.resolved) && isUndef(factory.error)) {
                 factory.loading = true
                 forceRender(false)
@@ -126,7 +142,8 @@ export function resolveAsyncComponent (
         }
 
         if (isDef(res.timeout)) {
-          setTimeout(() => {
+          timerTimeout = setTimeout(() => {
+            timerTimeout = null
             if (isUndef(factory.resolved)) {
               reject(
                 process.env.NODE_ENV !== 'production'

package/src/platforms/web/runtime/modules/dom-props.js

@@ -19,10 +19,11 @@ function updateDOMProps (oldVnode: VNodeWithData, vnode: VNodeWithData) {
   }
 
   for (key in oldProps) {
-    if (isUndef(props[key])) {
+    if (!(key in props)) {
       elm[key] = ''
     }
   }
+
   for (key in props) {
     cur = props[key]
     // ignore children if the node has textContent or innerHTML,
@@ -38,15 +39,7 @@ function updateDOMProps (oldVnode: VNodeWithData, vnode: VNodeWithData) {
       }
     }
 
-    // skip the update if old and new VDOM state is the same.
-    // the only exception is `value` where the DOM value may be temporarily
-    // out of sync with VDOM state due to focus, composition and modifiers.
-    // This also covers #4521 by skipping the unnecesarry `checked` update.
-    if (key !== 'value' && cur === oldProps[key]) {
-      continue
-    }
-
-    if (key === 'value') {
+    if (key === 'value' && elm.tagName !== 'PROGRESS') {
       // store value as _value as well since
       // non-string values will be stringified
       elm._value = cur
@@ -66,8 +59,18 @@ function updateDOMProps (oldVnode: VNodeWithData, vnode: VNodeWithData) {
       while (svg.firstChild) {
         elm.appendChild(svg.firstChild)
       }
-    } else {
-      elm[key] = cur
+    } else if (
+      // skip the update if old and new VDOM state is the same.
+      // `value` is handled separately because the DOM value may be temporarily
+      // out of sync with VDOM state due to focus, composition and modifiers.
+      // This  #4521 by skipping the unnecesarry `checked` update.
+      cur !== oldProps[key]
+    ) {
+      // some property updates can throw
+      // e.g. `value` on <progress> w/ non-finite value
+      try {
+        elm[key] = cur
+      } catch (e) {}
     }
   }
 }

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

@@ -67,8 +67,10 @@ function add (
         e.target === e.currentTarget ||
         // event is fired after handler attachment
         e.timeStamp >= attachedTimestamp ||
-        // #9462 bail for iOS 9 bug: event.timeStamp is 0 after history.pushState
-        e.timeStamp === 0 ||
+        // bail for environments that have buggy event.timeStamp implementations
+        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+        // #9681 QtWebEngine event.timeStamp is negative value
+        e.timeStamp <= 0 ||
         // #9448 bail if event is fired in another document in a multi-page
         // electron/nw.js app, since event.timeStamp will be using a different
         // starting reference

package/src/platforms/web/runtime/modules/transition.js

@@ -66,8 +66,8 @@ export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
   let context = activeInstance
   let transitionNode = activeInstance.$vnode
   while (transitionNode && transitionNode.parent) {
-    transitionNode = transitionNode.parent
     context = transitionNode.context
+    transitionNode = transitionNode.parent
   }
 
   const isAppear = !context._isMounted || !vnode.isRootInsert

package/src/server/template-renderer/create-async-file-mapper.js

@@ -43,8 +43,8 @@ function mapIdToFile (id, clientManifest) {
   if (fileIndices) {
     fileIndices.forEach(index => {
       const file = clientManifest.all[index]
-      // only include async files or non-js assets
-      if (clientManifest.async.indexOf(file) > -1 || !(/\.js($|\?)/.test(file))) {
+      // only include async files or non-js, non-css assets
+      if (clientManifest.async.indexOf(file) > -1 || !(/\.(js|css)($|\?)/.test(file))) {
         files.push(file)
       }
     })

package/src/server/write.js

@@ -1,6 +1,6 @@
 /* @flow */
 
-const MAX_STACK_DEPTH = 900
+const MAX_STACK_DEPTH = 800
 const noop = _ => _
 
 const defer = typeof process !== 'undefined' && process.nextTick

package/types/options.d.ts

@@ -1,5 +1,5 @@
 import { Vue, CreateElement, CombinedVueInstance } from "./vue";
-import { VNode, VNodeData, VNodeDirective, ScopedSlot } from "./vnode";
+import { VNode, VNodeData, VNodeDirective, NormalizedScopedSlot } from "./vnode";
 
 type Constructor = {
   new (...args: any[]): any;
@@ -140,11 +140,11 @@ export interface RenderContext<Props=DefaultProps> {
   data: VNodeData;
   parent: Vue;
   listeners: { [key: string]: Function | Function[] };
-  scopedSlots: { [key: string]: ScopedSlot };
+  scopedSlots: { [key: string]: NormalizedScopedSlot };
   injections: any
 }
 
-export type Prop<T> = { (): T } | { new(...args: any[]): T & object }
+export type Prop<T> = { (): T } | { new(...args: any[]): T & object } | { new(...args: string[]): Function }
 
 export type PropType<T> = Prop<T> | Prop<T>[];
 

package/types/vnode.d.ts

@@ -1,7 +1,11 @@
 import { Vue } from "./vue";
 
+export type ScopedSlot = (props: any) => ScopedSlotReturnValue;
+type ScopedSlotReturnValue = VNode | string | boolean | null | undefined | ScopedSlotReturnArray;
+interface ScopedSlotReturnArray extends Array<ScopedSlotReturnValue> {}
+
 // Scoped slots are guaranteed to return Array of VNodes starting in 2.6
-export type ScopedSlot = (props: any) => ScopedSlotChildren;
+export type NormalizedScopedSlot = (props: any) => ScopedSlotChildren;
 export type ScopedSlotChildren = VNode[] | undefined;
 
 // Relaxed type compatible with $createElement
@@ -44,7 +48,7 @@ export interface VNodeData {
   staticClass?: string;
   class?: any;
   staticStyle?: { [key: string]: any };
-  style?: object[] | object;
+  style?: string | object[] | object;
   props?: { [key: string]: any };
   attrs?: { [key: string]: any };
   domProps?: { [key: string]: any };

package/types/vue.d.ts

@@ -12,7 +12,7 @@ import {
   ThisTypedComponentOptionsWithRecordProps,
   WatchOptions,
 } from "./options";
-import { VNode, VNodeData, VNodeChildren, ScopedSlot } from "./vnode";
+import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from "./vnode";
 import { PluginFunction, PluginObject } from "./plugin";
 
 export interface CreateElement {
@@ -28,7 +28,7 @@ export interface Vue {
   readonly $children: Vue[];
   readonly $refs: { [key: string]: Vue | Element | Vue[] | Element[] };
   readonly $slots: { [key: string]: VNode[] | undefined };
-  readonly $scopedSlots: { [key: string]: ScopedSlot | undefined };
+  readonly $scopedSlots: { [key: string]: NormalizedScopedSlot | undefined };
   readonly $isServer: boolean;
   readonly $data: Record<string, any>;
   readonly $props: Record<string, any>;
@@ -89,7 +89,7 @@ export interface VueConstructor<V extends Vue = Vue> {
   extend<Props>(definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>): ExtendedVue<V, {}, {}, {}, Props>;
   extend(options?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}>;
 
-  nextTick(callback: () => void, context?: any[]): void;
+  nextTick<T>(callback: (this: T) => void, context?: T): void;
   nextTick(): Promise<void>
   set<T>(object: object, key: string | number, value: T): T;
   set<T>(array: T[], key: number, value: T): T;