vue 2.6.2 → 2.6.6

package/src/core/observer/scheduler.js

@@ -44,7 +44,7 @@ export let currentFlushTimestamp = 0
 let getNow: () => number = Date.now
 
 // Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res ( relative to poge load) or low-res
+// 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) {

package/src/core/util/env.js

@@ -15,6 +15,7 @@ export const isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform ===
 export const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios')
 export const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
 export const isPhantomJS = UA && /phantomjs/.test(UA)
+export const isFF = UA && UA.match(/firefox\/(\d+)/)
 
 // Firefox has a "watch" function on Object.prototype...
 export const nativeWatch = ({}).watch

package/src/core/util/error.js

@@ -49,7 +49,11 @@ function globalHandleError (err, vm, info) {
     try {
       return config.errorHandler.call(null, err, vm, info)
     } catch (e) {
-      logError(e, null, 'config.errorHandler')
+      // if the user intentionally throws the original error in the handler,
+      // do not log it twice
+      if (e !== err) {
+        logError(e, null, 'config.errorHandler')
+      }
     }
   }
   logError(err, vm, info)

package/src/core/vdom/create-component.js

@@ -129,7 +129,7 @@ export function createComponent (
   let asyncFactory
   if (isUndef(Ctor.cid)) {
     asyncFactory = Ctor
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context)
+    Ctor = resolveAsyncComponent(asyncFactory, baseCtor)
     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.

package/src/core/vdom/create-functional-component.js

@@ -49,7 +49,15 @@ export function FunctionalRenderContext (
   this.parent = parent
   this.listeners = data.on || emptyObject
   this.injections = resolveInject(options.inject, parent)
-  this.slots = () => resolveSlots(children, parent)
+  this.slots = () => {
+    if (!this.$slots) {
+      normalizeScopedSlots(
+        data.scopedSlots,
+        this.$slots = resolveSlots(children, parent)
+      )
+    }
+    return this.$slots
+  }
 
   Object.defineProperty(this, 'scopedSlots', ({
     enumerable: true,

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

@@ -1,17 +1,29 @@
 /* @flow */
 
-import { hasOwn } from 'shared/util'
+import { def } from 'core/util/lang'
 import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
+import { emptyObject } from 'shared/util'
 
 export function normalizeScopedSlots (
   slots: { [key: string]: Function } | void,
-  normalSlots: { [key: string]: Array<VNode> }
+  normalSlots: { [key: string]: Array<VNode> },
+  prevSlots?: { [key: string]: Function } | void
 ): any {
   let res
   if (!slots) {
     res = {}
   } else if (slots._normalized) {
-    return slots
+    // fast path 1: child component re-render only, parent did not change
+    return slots._normalized
+  } else if (
+    slots.$stable &&
+    prevSlots &&
+    prevSlots !== emptyObject &&
+    Object.keys(normalSlots).length === 0
+  ) {
+    // fast path 2: stable scoped slots w/ no normal slots to proxy,
+    // only need to normalize once
+    return prevSlots
   } else {
     res = {}
     for (const key in slots) {
@@ -26,22 +38,33 @@ export function normalizeScopedSlots (
       res[key] = proxyNormalSlot(normalSlots, key)
     }
   }
-  res._normalized = true
-  res.$stable = slots ? slots.$stable : true
+  // avoriaz seems to mock a non-extensible $scopedSlots object
+  // and when that is passed down this would cause an error
+  if (slots && Object.isExtensible(slots)) {
+    (slots: any)._normalized = res
+  }
+  def(res, '$stable', slots ? !!slots.$stable : true)
   return res
 }
 
 function normalizeScopedSlot(normalSlots, key, fn) {
-  const normalized = (scope = {}) => {
-    const res = fn(scope)
-    return res && typeof res === 'object' && !Array.isArray(res)
+  const normalized = function () {
+    let res = arguments.length ? fn.apply(null, arguments) : fn({})
+    res = res && typeof res === 'object' && !Array.isArray(res)
       ? [res] // single vnode
       : normalizeChildren(res)
+    return res && res.length === 0
+      ? undefined
+      : res
   }
-  // proxy scoped slots on normal $slots
-  if (!hasOwn(normalSlots, key)) {
+  // this is a slot using the new v-slot syntax without scope. although it is
+  // compiled as a scoped slot, render fn users would expect it to be present
+  // on this.$slots because the usage is semantically a normal slot.
+  if (fn.proxy) {
     Object.defineProperty(normalSlots, key, {
-      get: normalized
+      get: normalized,
+      enumerable: true,
+      configurable: true
     })
   }
   return normalized

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

@@ -12,6 +12,7 @@ import {
 } from 'core/util/index'
 
 import { createEmptyVNode } from 'core/vdom/vnode'
+import { currentRenderingInstance } from 'core/instance/render'
 
 function ensureCtor (comp: any, base) {
   if (
@@ -40,8 +41,7 @@ export function createAsyncPlaceholder (
 
 export function resolveAsyncComponent (
   factory: Function,
-  baseCtor: Class<Component>,
-  context: Component
+  baseCtor: Class<Component>
 ): Class<Component> | void {
   if (isTrue(factory.error) && isDef(factory.errorComp)) {
     return factory.errorComp
@@ -55,20 +55,21 @@ export function resolveAsyncComponent (
     return factory.loadingComp
   }
 
-  if (isDef(factory.contexts)) {
+  const owner = currentRenderingInstance
+  if (isDef(factory.owners)) {
     // already pending
-    factory.contexts.push(context)
+    factory.owners.push(owner)
   } else {
-    const contexts = factory.contexts = [context]
+    const owners = factory.owners = [owner]
     let sync = true
 
     const forceRender = (renderCompleted: boolean) => {
-      for (let i = 0, l = contexts.length; i < l; i++) {
-        contexts[i].$forceUpdate()
+      for (let i = 0, l = owners.length; i < l; i++) {
+        (owners[i]: any).$forceUpdate()
       }
 
       if (renderCompleted) {
-        contexts.length = 0
+        owners.length = 0
       }
     }
 
@@ -80,7 +81,7 @@ export function resolveAsyncComponent (
       if (!sync) {
         forceRender(true)
       } else {
-        contexts.length = 0
+        owners.length = 0
       }
     })
 

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

@@ -2,7 +2,7 @@
 
 import { isDef, isUndef } from 'shared/util'
 import { updateListeners } from 'core/vdom/helpers/index'
-import { isIE, supportsPassive, isUsingMicroTask } from 'core/util/index'
+import { isIE, isFF, supportsPassive, isUsingMicroTask } from 'core/util/index'
 import { RANGE_TOKEN, CHECKBOX_RADIO_TOKEN } from 'web/compiler/directives/model'
 import { currentFlushTimestamp } from 'core/observer/scheduler'
 
@@ -39,6 +39,11 @@ function createOnceHandler (event, handler, capture) {
   }
 }
 
+// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
+// implementation and does not fire microtasks in between event propagation, so
+// safe to exclude.
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53)
+
 function add (
   name: string,
   handler: Function,
@@ -51,11 +56,24 @@ function add (
   // the solution is simple: we save the timestamp when a handler is attached,
   // and the handler would only fire if the event passed to it was fired
   // AFTER it was attached.
-  if (isUsingMicroTask) {
+  if (useMicrotaskFix) {
     const attachedTimestamp = currentFlushTimestamp
     const original = handler
     handler = original._wrapper = function (e) {
-      if (e.timeStamp >= attachedTimestamp) {
+      if (
+        // no bubbling, should always fire.
+        // this is just a safety net in case event.timeStamp is unreliable in
+        // certain weird environments...
+        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 ||
+        // #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
+        e.target.ownerDocument !== document
+      ) {
         return original.apply(this, arguments)
       }
     }

package/types/vue.d.ts

@@ -122,6 +122,7 @@ export interface VueConstructor<V extends Vue = Vue> {
   observable<T>(obj: T): T;
 
   config: VueConfiguration;
+  version: string;
 }
 
 export const Vue: VueConstructor;