vue 2.6.13 → 2.7.0-alpha.2

package/src/core/vdom/{create-functional-component.js → create-functional-component.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 import VNode, { cloneVNode } from './vnode'
 import { createElement } from './create-element'
 import { resolveInject } from '../instance/inject'
@@ -12,17 +10,20 @@ import {
   isDef,
   isTrue,
   hasOwn,
+  isArray,
   camelize,
   emptyObject,
   validateProp
 } from '../util/index'
+import type { Component } from 'types/component'
+import type { VNodeData } from 'types/vnode'
 
-export function FunctionalRenderContext (
+export function FunctionalRenderContext(
   data: VNodeData,
   props: Object,
-  children: ?Array<VNode>,
+  children: Array<VNode> | undefined,
   parent: Component,
-  Ctor: Class<Component>
+  Ctor: typeof Component
 ) {
   const options = Ctor.options
   // ensure the createElement function in functional components
@@ -30,14 +31,13 @@ export function FunctionalRenderContext (
   let contextVm
   if (hasOwn(parent, '_uid')) {
     contextVm = Object.create(parent)
-    // $flow-disable-line
     contextVm._original = parent
   } else {
     // the context vm passed in is a functional context as well.
     // in this case we want to make sure we are able to get a hold to the
     // real context instance.
     contextVm = parent
-    // $flow-disable-line
+    // @ts-ignore
     parent = parent._original
   }
   const isCompiled = isTrue(options._compiled)
@@ -52,19 +52,20 @@ export function FunctionalRenderContext (
   this.slots = () => {
     if (!this.$slots) {
       normalizeScopedSlots(
+        parent,
         data.scopedSlots,
-        this.$slots = resolveSlots(children, parent)
+        (this.$slots = resolveSlots(children, parent))
       )
     }
     return this.$slots
   }
 
-  Object.defineProperty(this, 'scopedSlots', ({
+  Object.defineProperty(this, 'scopedSlots', {
     enumerable: true,
-    get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
+    get() {
+      return normalizeScopedSlots(parent, data.scopedSlots, this.slots())
     }
-  }: any))
+  } as any)
 
   // support for compiled functional template
   if (isCompiled) {
@@ -72,31 +73,36 @@ export function FunctionalRenderContext (
     this.$options = options
     // pre-resolve slots for renderSlot()
     this.$slots = this.slots()
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots)
+    this.$scopedSlots = normalizeScopedSlots(
+      parent,
+      data.scopedSlots,
+      this.$slots
+    )
   }
 
   if (options._scopeId) {
     this._c = (a, b, c, d) => {
       const vnode = createElement(contextVm, a, b, c, d, needNormalization)
-      if (vnode && !Array.isArray(vnode)) {
+      if (vnode && !isArray(vnode)) {
         vnode.fnScopeId = options._scopeId
         vnode.fnContext = parent
       }
       return vnode
     }
   } else {
-    this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization)
+    this._c = (a, b, c, d) =>
+      createElement(contextVm, a, b, c, d, needNormalization)
   }
 }
 
 installRenderHelpers(FunctionalRenderContext.prototype)
 
-export function createFunctionalComponent (
-  Ctor: Class<Component>,
-  propsData: ?Object,
+export function createFunctionalComponent(
+  Ctor: typeof Component,
+  propsData: Object | undefined,
   data: VNodeData,
   contextVm: Component,
-  children: ?Array<VNode>
+  children?: Array<VNode>
 ): VNode | Array<VNode> | void {
   const options = Ctor.options
   const props = {}
@@ -121,34 +127,53 @@ export function createFunctionalComponent (
   const vnode = options.render.call(null, renderContext._c, renderContext)
 
   if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
+    return cloneAndMarkFunctionalResult(
+      vnode,
+      data,
+      renderContext.parent,
+      options,
+      renderContext
+    )
+  } else if (isArray(vnode)) {
     const vnodes = normalizeChildren(vnode) || []
     const res = new Array(vnodes.length)
     for (let i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext)
+      res[i] = cloneAndMarkFunctionalResult(
+        vnodes[i],
+        data,
+        renderContext.parent,
+        options,
+        renderContext
+      )
     }
     return res
   }
 }
 
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
+function cloneAndMarkFunctionalResult(
+  vnode,
+  data,
+  contextVm,
+  options,
+  renderContext
+) {
   // #7817 clone node before setting fnContext, otherwise if the node is reused
   // (e.g. it was from a cached normal slot) the fnContext causes named slots
   // that should not be matched to match.
   const clone = cloneVNode(vnode)
   clone.fnContext = contextVm
   clone.fnOptions = options
-  if (process.env.NODE_ENV !== 'production') {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext
+  if (__DEV__) {
+    ;(clone.devtoolsMeta = clone.devtoolsMeta || ({} as any)).renderContext =
+      renderContext
   }
   if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot
+    ;(clone.data || (clone.data = {})).slot = data.slot
   }
   return clone
 }
 
-function mergeProps (to, from) {
+function mergeProps(to, from) {
   for (const key in from) {
     to[camelize(key)] = from[key]
   }

package/src/core/vdom/helpers/{extract-props.js → extract-props.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 import {
   tip,
   hasOwn,
@@ -8,12 +6,14 @@ import {
   hyphenate,
   formatComponentName
 } from 'core/util/index'
+import type { Component } from 'types/component'
+import type { VNodeData } from 'types/vnode'
 
-export function extractPropsFromVNodeData (
+export function extractPropsFromVNodeData(
   data: VNodeData,
-  Ctor: Class<Component>,
+  Ctor: typeof Component,
   tag?: string
-): ?Object {
+): object | undefined {
   // we are only extracting raw values here.
   // validation and default values are handled in the child
   // component itself.
@@ -26,32 +26,32 @@ export function extractPropsFromVNodeData (
   if (isDef(attrs) || isDef(props)) {
     for (const key in propOptions) {
       const altKey = hyphenate(key)
-      if (process.env.NODE_ENV !== 'production') {
+      if (__DEV__) {
         const keyInLowerCase = key.toLowerCase()
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
+        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}".`
+              `${formatComponentName(
+                // @ts-expect-error tag is string
+                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)
+        checkProp(res, attrs, key, altKey, false)
     }
   }
   return res
 }
 
-function checkProp (
+function checkProp(
   res: Object,
-  hash: ?Object,
+  hash: Object | undefined,
   key: string,
   altKey: string,
   preserve: boolean

package/src/core/vdom/helpers/{get-first-component-child.js → get-first-component-child.ts}

@@ -1,10 +1,11 @@
-/* @flow */
-
-import { isDef } from 'shared/util'
+import { isDef, isArray } from 'shared/util'
+import VNode from '../vnode'
 import { isAsyncPlaceholder } from './is-async-placeholder'
 
-export function getFirstComponentChild (children: ?Array<VNode>): ?VNode {
-  if (Array.isArray(children)) {
+export function getFirstComponentChild(
+  children?: Array<VNode>
+): VNode | undefined {
+  if (isArray(children)) {
     for (let i = 0; i < children.length; i++) {
       const c = children[i]
       if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {

package/src/core/vdom/helpers/{index.js → index.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 export * from './merge-hook'
 export * from './extract-props'
 export * from './update-listeners'

package/src/core/vdom/helpers/is-async-placeholder.ts

@@ -0,0 +1,6 @@
+import VNode from '../vnode'
+
+export function isAsyncPlaceholder(node: VNode): boolean {
+  // @ts-expect-error not really boolean type
+  return node.isComment && node.asyncFactory
+}

package/src/core/vdom/helpers/{merge-hook.js → merge-hook.ts}

@@ -1,17 +1,19 @@
-/* @flow */
-
 import VNode from '../vnode'
 import { createFnInvoker } from './update-listeners'
 import { remove, isDef, isUndef, isTrue } from 'shared/util'
 
-export function mergeVNodeHook (def: Object, hookKey: string, hook: Function) {
+export function mergeVNodeHook(
+  def: Record<string, any>,
+  hookKey: string,
+  hook: Function
+) {
   if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {})
+    def = def.data!.hook || (def.data!.hook = {})
   }
   let invoker
   const oldHook = def[hookKey]
 
-  function wrappedHook () {
+  function wrappedHook() {
     hook.apply(this, arguments)
     // important: remove merged hook to ensure it's called only once
     // and prevent memory leak

package/src/core/vdom/helpers/{normalize-children.js → normalize-children.ts}

@@ -1,7 +1,12 @@
-/* @flow */
-
 import VNode, { createTextVNode } from 'core/vdom/vnode'
-import { isFalse, isTrue, isDef, isUndef, isPrimitive } from 'shared/util'
+import {
+  isFalse,
+  isTrue,
+  isArray,
+  isDef,
+  isUndef,
+  isPrimitive
+} from 'shared/util'
 
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
@@ -15,9 +20,9 @@ import { isFalse, isTrue, isDef, isUndef, isPrimitive } from 'shared/util'
 // 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.
-export function simpleNormalizeChildren (children: any) {
+export function simpleNormalizeChildren(children: any) {
   for (let i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
+    if (isArray(children[i])) {
       return Array.prototype.concat.apply([], children)
     }
   }
@@ -28,20 +33,23 @@ export function simpleNormalizeChildren (children: any) {
 // 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.
-export function normalizeChildren (children: any): ?Array<VNode> {
+export function normalizeChildren(children: any): Array<VNode> | undefined {
   return isPrimitive(children)
     ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
+    : isArray(children)
+    ? normalizeArrayChildren(children)
+    : undefined
 }
 
-function isTextNode (node): boolean {
+function isTextNode(node): boolean {
   return isDef(node) && isDef(node.text) && isFalse(node.isComment)
 }
 
-function normalizeArrayChildren (children: any, nestedIndex?: string): Array<VNode> {
-  const res = []
+function normalizeArrayChildren(
+  children: any,
+  nestedIndex?: string
+): Array<VNode> {
+  const res: VNode[] = []
   let i, c, lastIndex, last
   for (i = 0; i < children.length; i++) {
     c = children[i]
@@ -49,12 +57,12 @@ function normalizeArrayChildren (children: any, nestedIndex?: string): Array<VNo
     lastIndex = res.length - 1
     last = res[lastIndex]
     //  nested
-    if (Array.isArray(c)) {
+    if (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]: any).text)
+          res[lastIndex] = createTextVNode(last.text + c[0].text)
           c.shift()
         }
         res.push.apply(res, c)
@@ -75,10 +83,12 @@ function normalizeArrayChildren (children: any, nestedIndex?: string): Array<VNo
         res[lastIndex] = createTextVNode(last.text + c.text)
       } else {
         // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
+        if (
+          isTrue(children._isVList) &&
           isDef(c.tag) &&
           isUndef(c.key) &&
-          isDef(nestedIndex)) {
+          isDef(nestedIndex)
+        ) {
           c.key = `__vlist${nestedIndex}_${i}__`
         }
         res.push(c)

package/src/core/vdom/helpers/{normalize-scoped-slots.js → normalize-scoped-slots.ts}

@@ -1,16 +1,18 @@
-/* @flow */
-
 import { def } from 'core/util/lang'
 import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
-import { emptyObject } from 'shared/util'
+import { emptyObject, isArray } from 'shared/util'
 import { isAsyncPlaceholder } from './is-async-placeholder'
+import type VNode from '../vnode'
+import { Component } from 'types/component'
+import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
 
-export function normalizeScopedSlots (
+export function normalizeScopedSlots(
+  ownerVm: Component,
   slots: { [key: string]: Function } | void,
-  normalSlots: { [key: string]: Array<VNode> },
-  prevSlots?: { [key: string]: Function } | void
+  normalSlots: { [key: string]: VNode[] }
 ): any {
   let res
+  const prevSlots = ownerVm.$scopedSlots
   const hasNormalSlots = Object.keys(normalSlots).length > 0
   const isStable = slots ? !!slots.$stable : !hasNormalSlots
   const key = slots && slots.$key
@@ -34,7 +36,7 @@ export function normalizeScopedSlots (
     res = {}
     for (const key in slots) {
       if (slots[key] && key[0] !== '$') {
-        res[key] = normalizeScopedSlot(normalSlots, key, slots[key])
+        res[key] = normalizeScopedSlot(ownerVm, normalSlots, key, slots[key])
       }
     }
   }
@@ -47,7 +49,7 @@ export function normalizeScopedSlots (
   // 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
+    slots._normalized = res
   }
   def(res, '$stable', isStable)
   def(res, '$key', key)
@@ -55,17 +57,21 @@ export function normalizeScopedSlots (
   return res
 }
 
-function normalizeScopedSlot(normalSlots, key, fn) {
+function normalizeScopedSlot(vm, normalSlots, key, fn) {
   const normalized = function () {
+    const cur = currentInstance
+    setCurrentInstance(vm)
     let res = arguments.length ? fn.apply(null, arguments) : fn({})
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res)
-    let vnode: VNode = res && res[0]
-    return res && (
-      !vnode ||
-      (vnode.isComment && !isAsyncPlaceholder(vnode)) // #9658, #10391
-    ) ? undefined
+    res =
+      res && typeof res === 'object' && !isArray(res)
+        ? [res] // single vnode
+        : normalizeChildren(res)
+    const vnode: VNode | null = res && res[0]
+    setCurrentInstance(cur)
+    return res &&
+      (!vnode ||
+        (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+      ? 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 → resolve-async-component.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 import {
   warn,
   once,
@@ -12,27 +10,24 @@ import {
   remove
 } from 'core/util/index'
 
-import { createEmptyVNode } from 'core/vdom/vnode'
+import VNode, { createEmptyVNode } from 'core/vdom/vnode'
 import { currentRenderingInstance } from 'core/instance/render'
+import type { VNodeData } from 'types/vnode'
+import type { Component } from 'types/component'
 
-function ensureCtor (comp: any, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
+function ensureCtor(comp: any, base) {
+  if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
     comp = comp.default
   }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
+  return isObject(comp) ? base.extend(comp) : comp
 }
 
-export function createAsyncPlaceholder (
+export function createAsyncPlaceholder(
   factory: Function,
-  data: ?VNodeData,
+  data: VNodeData | undefined,
   context: Component,
-  children: ?Array<VNode>,
-  tag: ?string
+  children: Array<VNode> | undefined,
+  tag?: string
 ): VNode {
   const node = createEmptyVNode()
   node.asyncFactory = factory
@@ -40,10 +35,10 @@ export function createAsyncPlaceholder (
   return node
 }
 
-export function resolveAsyncComponent (
-  factory: Function,
-  baseCtor: Class<Component>
-): Class<Component> | void {
+export function resolveAsyncComponent(
+  factory: { (...args: any[]): any; [keye: string]: any },
+  baseCtor: typeof Component
+): typeof Component | void {
   if (isTrue(factory.error) && isDef(factory.errorComp)) {
     return factory.errorComp
   }
@@ -63,16 +58,16 @@ export function resolveAsyncComponent (
   }
 
   if (owner && !isDef(factory.owners)) {
-    const owners = factory.owners = [owner]
+    const owners = (factory.owners = [owner])
     let sync = true
-    let timerLoading = null
-    let timerTimeout = null
+    let timerLoading: number | null = null
+    let timerTimeout: number | null = null
 
-    ;(owner: any).$on('hook:destroyed', () => remove(owners, owner))
+    owner.$on('hook:destroyed', () => remove(owners, owner))
 
     const forceRender = (renderCompleted: boolean) => {
       for (let i = 0, l = owners.length; i < l; i++) {
-        (owners[i]: any).$forceUpdate()
+        owners[i].$forceUpdate()
       }
 
       if (renderCompleted) {
@@ -88,7 +83,7 @@ export function resolveAsyncComponent (
       }
     }
 
-    const resolve = once((res: Object | Class<Component>) => {
+    const resolve = once((res: Object | Component) => {
       // cache resolved
       factory.resolved = ensureCtor(res, baseCtor)
       // invoke callbacks only if this is not a synchronous resolve
@@ -101,10 +96,11 @@ export function resolveAsyncComponent (
     })
 
     const reject = once(reason => {
-      process.env.NODE_ENV !== 'production' && warn(
-        `Failed to resolve async component: ${String(factory)}` +
-        (reason ? `\nReason: ${reason}` : '')
-      )
+      __DEV__ &&
+        warn(
+          `Failed to resolve async component: ${String(factory)}` +
+            (reason ? `\nReason: ${reason}` : '')
+        )
       if (isDef(factory.errorComp)) {
         factory.error = true
         forceRender(true)
@@ -131,6 +127,7 @@ export function resolveAsyncComponent (
           if (res.delay === 0) {
             factory.loading = true
           } else {
+            // @ts-expect-error NodeJS timeout type
             timerLoading = setTimeout(() => {
               timerLoading = null
               if (isUndef(factory.resolved) && isUndef(factory.error)) {
@@ -142,14 +139,11 @@ export function resolveAsyncComponent (
         }
 
         if (isDef(res.timeout)) {
+          // @ts-expect-error NodeJS timeout type
           timerTimeout = setTimeout(() => {
             timerTimeout = null
             if (isUndef(factory.resolved)) {
-              reject(
-                process.env.NODE_ENV !== 'production'
-                  ? `timeout (${res.timeout}ms)`
-                  : null
-              )
+              reject(__DEV__ ? `timeout (${res.timeout}ms)` : null)
             }
           }, res.timeout)
         }
@@ -158,8 +152,6 @@ export function resolveAsyncComponent (
 
     sync = false
     // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
+    return factory.loading ? factory.loadingComp : factory.resolved
   }
 }