vue 2.6.13 → 2.7.0-alpha.2

package/src/core/instance/{proxy.js → proxy.ts}

@@ -5,21 +5,21 @@ import { warn, makeMap, isNative } from '../util/index'
 
 let initProxy
 
-if (process.env.NODE_ENV !== 'production') {
+if (__DEV__) {
   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,BigInt,' +
-    'require' // for Webpack/Browserify
+      'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+      'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+      '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.',
+        '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
     )
   }
@@ -27,22 +27,25 @@ if (process.env.NODE_ENV !== 'production') {
   const warnReservedPrefix = (target, key) => {
     warn(
       `Property "${key}" must be accessed with "$data.${key}" because ` +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals. ' +
-      'See: https://vuejs.org/v2/api/#data',
+        'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+        'prevent conflicts with Vue internals. ' +
+        'See: https://vuejs.org/v2/api/#data',
       target
     )
   }
 
-  const hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy)
+  const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy)
 
   if (hasProxy) {
-    const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact')
+    const isBuiltInModifier = makeMap(
+      'stop,prevent,self,ctrl,shift,alt,meta,exact'
+    )
     config.keyCodes = new Proxy(config.keyCodes, {
-      set (target, key, value) {
+      set(target, key: string, value) {
         if (isBuiltInModifier(key)) {
-          warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`)
+          warn(
+            `Avoid overwriting built-in modifier in config.keyCodes: .${key}`
+          )
           return false
         } else {
           target[key] = value
@@ -53,10 +56,13 @@ if (process.env.NODE_ENV !== 'production') {
   }
 
   const hasHandler = {
-    has (target, key) {
+    has(target, key) {
       const has = key in target
-      const isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data))
+      const isAllowed =
+        allowedGlobals(key) ||
+        (typeof key === 'string' &&
+          key.charAt(0) === '_' &&
+          !(key in target.$data))
       if (!has && !isAllowed) {
         if (key in target.$data) warnReservedPrefix(target, key)
         else warnNonPresent(target, key)
@@ -66,7 +72,7 @@ if (process.env.NODE_ENV !== 'production') {
   }
 
   const getHandler = {
-    get (target, key) {
+    get(target, key) {
       if (typeof key === 'string' && !(key in target)) {
         if (key in target.$data) warnReservedPrefix(target, key)
         else warnNonPresent(target, key)
@@ -75,13 +81,12 @@ if (process.env.NODE_ENV !== 'production') {
     }
   }
 
-  initProxy = function initProxy (vm) {
+  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
+      const handlers =
+        options.render && options.render._withStripped ? getHandler : hasHandler
       vm._renderProxy = new Proxy(vm, handlers)
     } else {
       vm._renderProxy = vm

package/src/core/instance/render-helpers/{bind-dynamic-keys.js → bind-dynamic-keys.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 // For example, the following template:
 //
@@ -11,12 +9,15 @@
 
 import { warn } from 'core/util/debug'
 
-export function bindDynamicKeys (baseObj: Object, values: Array<any>): Object {
+export function bindDynamicKeys(
+  baseObj: Record<string, any>,
+  values: Array<any>
+): Object {
   for (let i = 0; i < values.length; i += 2) {
     const key = values[i]
     if (typeof key === 'string' && key) {
       baseObj[values[i]] = values[i + 1]
-    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {
+    } else if (__DEV__ && key !== '' && key !== null) {
       // null is a special value for explicitly removing a binding
       warn(
         `Invalid value for dynamic directive argument (expected string or null): ${key}`,
@@ -30,6 +31,6 @@ export function bindDynamicKeys (baseObj: Object, values: Array<any>): Object {
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-export function prependModifier (value: any, symbol: string): any {
+export function prependModifier(value: any, symbol: string): any {
   return typeof value === 'string' ? symbol + value : value
 }

package/src/core/instance/render-helpers/{bind-object-listeners.js → bind-object-listeners.ts}

@@ -1,16 +1,12 @@
-/* @flow */
-
 import { warn, extend, isPlainObject } from 'core/util/index'
+import type { VNodeData } from 'types/vnode'
 
-export function bindObjectListeners (data: any, value: any): VNodeData {
+export function bindObjectListeners(data: any, value: any): VNodeData {
   if (value) {
     if (!isPlainObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-on without argument expects an Object value',
-        this
-      )
+      __DEV__ && warn('v-on without argument expects an Object value', this)
     } else {
-      const on = data.on = data.on ? extend({}, data.on) : {}
+      const on = (data.on = data.on ? extend({}, data.on) : {})
       for (const key in value) {
         const existing = on[key]
         const ours = value[key]

package/src/core/instance/render-helpers/{bind-object-props.js → bind-object-props.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 import config from 'core/config'
 
 import {
@@ -8,13 +6,15 @@ import {
   toObject,
   isReservedAttribute,
   camelize,
-  hyphenate
+  hyphenate,
+  isArray
 } from 'core/util/index'
+import type { VNodeData } from 'types/vnode'
 
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-export function bindObjectProps (
+export function bindObjectProps(
   data: any,
   tag: string,
   value: any,
@@ -23,27 +23,22 @@ export function bindObjectProps (
 ): VNodeData {
   if (value) {
     if (!isObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      )
+      __DEV__ &&
+        warn('v-bind without argument expects an Object or Array value', this)
     } else {
-      if (Array.isArray(value)) {
+      if (isArray(value)) {
         value = toObject(value)
       }
       let hash
       for (const key in value) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
+        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 = {})
+          hash =
+            asProp || config.mustUseProp(tag, type, key)
+              ? data.domProps || (data.domProps = {})
+              : data.attrs || (data.attrs = {})
         }
         const camelizedKey = camelize(key)
         const hyphenatedKey = hyphenate(key)

package/src/core/instance/render-helpers/{check-keycodes.js → check-keycodes.ts}

@@ -1,10 +1,8 @@
-/* @flow */
-
 import config from 'core/config'
-import { hyphenate } from 'shared/util'
+import { hyphenate, isArray } from 'shared/util'
 
-function isKeyNotMatch<T> (expect: T | Array<T>, actual: T): boolean {
-  if (Array.isArray(expect)) {
+function isKeyNotMatch<T>(expect: T | Array<T>, actual: T): boolean {
+  if (isArray(expect)) {
     return expect.indexOf(actual) === -1
   } else {
     return expect !== actual
@@ -16,13 +14,13 @@ function isKeyNotMatch<T> (expect: T | Array<T>, actual: T): boolean {
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-export function checkKeyCodes (
+export function checkKeyCodes(
   eventKeyCode: number,
   key: string,
   builtInKeyCode?: number | Array<number>,
   eventKeyName?: string,
   builtInKeyName?: string | Array<string>
-): ?boolean {
+): boolean | null | undefined {
   const mappedKeyCode = config.keyCodes[key] || builtInKeyCode
   if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
     return isKeyNotMatch(builtInKeyName, eventKeyName)

package/src/core/instance/render-helpers/{index.js → index.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 import { toNumber, toString, looseEqual, looseIndexOf } from 'shared/util'
 import { createTextVNode, createEmptyVNode } from 'core/vdom/vnode'
 import { renderList } from './render-list'
@@ -12,7 +10,7 @@ import { bindObjectListeners } from './bind-object-listeners'
 import { resolveScopedSlots } from './resolve-scoped-slots'
 import { bindDynamicKeys, prependModifier } from './bind-dynamic-keys'
 
-export function installRenderHelpers (target: any) {
+export function installRenderHelpers(target: any) {
   target._o = markOnce
   target._n = toNumber
   target._s = toString

package/src/core/instance/render-helpers/{render-list.js → render-list.ts}

@@ -1,20 +1,19 @@
-/* @flow */
-
-import { isObject, isDef, hasSymbol } from 'core/util/index'
+import { isObject, isDef, hasSymbol, isArray } from 'core/util/index'
+import VNode from 'core/vdom/vnode'
 
 /**
  * Runtime helper for rendering v-for lists.
  */
-export function renderList (
+export function renderList(
   val: any,
-  render: (
-    val: any,
-    keyOrIndex: string | number,
-    index?: number
-  ) => VNode
-): ?Array<VNode> {
-  let ret: ?Array<VNode>, i, l, keys, key
-  if (Array.isArray(val) || typeof val === 'string') {
+  render: (val: any, keyOrIndex: string | number, index?: number) => VNode
+): Array<VNode> | null {
+  let ret: Array<VNode> | null = null,
+    i,
+    l,
+    keys,
+    key
+  if (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)
@@ -45,6 +44,6 @@ export function renderList (
   if (!isDef(ret)) {
     ret = []
   }
-  (ret: any)._isVList = true
+  ;(ret as any)._isVList = true
   return ret
 }

package/src/core/instance/render-helpers/{render-slot.js → render-slot.ts}

@@ -1,34 +1,33 @@
-/* @flow */
-
-import { extend, warn, isObject } from 'core/util/index'
+import { extend, warn, isObject, isFunction } from 'core/util/index'
+import VNode from 'core/vdom/vnode'
 
 /**
  * Runtime helper for rendering <slot>
  */
-export function renderSlot (
+export function renderSlot(
   name: string,
-  fallbackRender: ?((() => Array<VNode>) | Array<VNode>),
-  props: ?Object,
-  bindObject: ?Object
-): ?Array<VNode> {
+  fallbackRender: ((() => Array<VNode>) | Array<VNode>) | null,
+  props: Record<string, any> | null,
+  bindObject: object | null
+): Array<VNode> | null {
   const scopedSlotFn = this.$scopedSlots[name]
   let nodes
   if (scopedSlotFn) {
     // scoped slot
     props = props || {}
     if (bindObject) {
-      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
+      if (__DEV__ && !isObject(bindObject)) {
         warn('slot v-bind without argument expects an Object', this)
       }
       props = extend(extend({}, bindObject), props)
     }
     nodes =
       scopedSlotFn(props) ||
-      (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender)
+      (isFunction(fallbackRender) ? fallbackRender() : fallbackRender)
   } else {
     nodes =
       this.$slots[name] ||
-      (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender)
+      (isFunction(fallbackRender) ? fallbackRender() : fallbackRender)
   }
 
   const target = props && props.slot

package/src/core/instance/render-helpers/{render-static.js → render-static.ts}

@@ -1,9 +1,10 @@
-/* @flow */
+import VNode from 'core/vdom/vnode'
+import { isArray } from 'core/util'
 
 /**
  * Runtime helper for rendering static trees.
  */
-export function renderStatic (
+export function renderStatic(
   index: number,
   isInFor: boolean
 ): VNode | Array<VNode> {
@@ -28,7 +29,7 @@ export function renderStatic (
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-export function markOnce (
+export function markOnce(
   tree: VNode | Array<VNode>,
   index: number,
   key: string
@@ -37,12 +38,8 @@ export function markOnce (
   return tree
 }
 
-function markStatic (
-  tree: VNode | Array<VNode>,
-  key: string,
-  isOnce: boolean
-) {
-  if (Array.isArray(tree)) {
+function markStatic(tree: VNode | Array<VNode>, key: string, isOnce: boolean) {
+  if (isArray(tree)) {
     for (let i = 0; i < tree.length; i++) {
       if (tree[i] && typeof tree[i] !== 'string') {
         markStaticNode(tree[i], `${key}_${i}`, isOnce)
@@ -53,7 +50,7 @@ function markStatic (
   }
 }
 
-function markStaticNode (node, key, isOnce) {
+function markStaticNode(node, key, isOnce) {
   node.isStatic = true
   node.key = key
   node.isOnce = isOnce

package/src/core/instance/render-helpers/{resolve-filter.js → resolve-filter.ts}

@@ -1,10 +1,8 @@
-/* @flow */
-
 import { identity, resolveAsset } from 'core/util/index'
 
 /**
  * Runtime helper for resolving filters
  */
-export function resolveFilter (id: string): Function {
+export function resolveFilter(id: string): Function {
   return resolveAsset(this.$options, 'filters', id, true) || identity
 }

package/src/core/instance/render-helpers/{resolve-scoped-slots.js → resolve-scoped-slots.ts}

@@ -1,27 +1,30 @@
-/* @flow */
+import type { ScopedSlotsData } from 'types/vnode'
+import { isArray } from 'core/util'
 
-export function resolveScopedSlots (
-  fns: ScopedSlotsData, // see flow/vnode
-  res?: Object,
+export function resolveScopedSlots(
+  fns: ScopedSlotsData,
+  res?: Record<string, any>,
   // the following are added in 2.6
   hasDynamicKeys?: boolean,
   contentHashKey?: number
-): { [key: string]: Function, $stable: boolean } {
+): { $stable: boolean } & { [key: string]: Function } {
   res = res || { $stable: !hasDynamicKeys }
   for (let i = 0; i < fns.length; i++) {
     const slot = fns[i]
-    if (Array.isArray(slot)) {
+    if (isArray(slot)) {
       resolveScopedSlots(slot, res, hasDynamicKeys)
     } else if (slot) {
       // marker for reverse proxying v-slot without scope on this.$slots
+      // @ts-expect-error
       if (slot.proxy) {
+        // @ts-expect-error
         slot.fn.proxy = true
       }
       res[slot.key] = slot.fn
     }
   }
   if (contentHashKey) {
-    (res: any).$key = contentHashKey
+    ;(res as any).$key = contentHashKey
   }
-  return res
+  return res as any
 }

package/src/core/instance/render-helpers/{resolve-slots.js → resolve-slots.ts}

@@ -1,18 +1,17 @@
-/* @flow */
-
 import type VNode from 'core/vdom/vnode'
+import type { Component } from 'types/component'
 
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-export function resolveSlots (
-  children: ?Array<VNode>,
-  context: ?Component
+export function resolveSlots(
+  children: Array<VNode> | null | undefined,
+  context: Component | null
 ): { [key: string]: Array<VNode> } {
   if (!children || !children.length) {
     return {}
   }
-  const slots = {}
+  const slots: Record<string, any> = {}
   for (let i = 0, l = children.length; i < l; i++) {
     const child = children[i]
     const data = child.data
@@ -22,18 +21,20 @@ export function resolveSlots (
     }
     // named slots should only be respected if the vnode was rendered in the
     // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
+    if (
+      (child.context === context || child.fnContext === context) &&
+      data &&
+      data.slot != null
     ) {
       const name = data.slot
-      const slot = (slots[name] || (slots[name] = []))
+      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)
+      ;(slots.default || (slots.default = [])).push(child)
     }
   }
   // ignore slots that contains only whitespace
@@ -45,6 +46,6 @@ export function resolveSlots (
   return slots
 }
 
-function isWhitespace (node: VNode): boolean {
+function isWhitespace(node: VNode): boolean {
   return (node.isComment && !node.asyncFactory) || node.text === ' '
 }