vue 2.6.13 → 2.7.0-alpha.2

package/src/core/util/{next-tick.js → next-tick.ts}

@@ -1,4 +1,3 @@
-/* @flow */
 /* globals MutationObserver */
 
 import { noop } from 'shared/util'
@@ -7,10 +6,10 @@ import { isIE, isIOS, isNative } from './env'
 
 export let isUsingMicroTask = false
 
-const callbacks = []
+const callbacks: Array<Function> = []
 let pending = false
 
-function flushCallbacks () {
+function flushCallbacks() {
   pending = false
   const copies = callbacks.slice(0)
   callbacks.length = 0
@@ -51,11 +50,13 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
     if (isIOS) setTimeout(noop)
   }
   isUsingMicroTask = true
-} else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
+} else if (
+  !isIE &&
+  typeof MutationObserver !== 'undefined' &&
+  (isNative(MutationObserver) ||
+    // PhantomJS and iOS 7.x
+    MutationObserver.toString() === '[object MutationObserverConstructor]')
+) {
   // Use MutationObserver where native Promise is not available,
   // e.g. PhantomJS, iOS7, Android 4.4
   // (#6466 MutationObserver is unreliable in IE11)
@@ -84,13 +85,18 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
   }
 }
 
-export function nextTick (cb?: Function, ctx?: Object) {
+export function nextTick(): Promise<void>
+export function nextTick(cb: (...args: any[]) => any, ctx?: object): void
+/**
+ * @internal
+ */
+export function nextTick(cb?: (...args: any[]) => any, ctx?: object) {
   let _resolve
   callbacks.push(() => {
     if (cb) {
       try {
         cb.call(ctx)
-      } catch (e) {
+      } catch (e: any) {
         handleError(e, ctx, 'nextTick')
       }
     } else if (_resolve) {

package/src/core/util/{options.js → options.ts}

@@ -1,15 +1,11 @@
-/* @flow */
-
 import config from '../config'
 import { warn } from './debug'
 import { set } from '../observer/index'
 import { unicodeRegExp } from './lang'
 import { nativeWatch, hasSymbol } from './env'
+import { isArray, isFunction } from 'shared/util'
 
-import {
-  ASSET_TYPES,
-  LIFECYCLE_HOOKS
-} from 'shared/constants'
+import { ASSET_TYPES, LIFECYCLE_HOOKS } from 'shared/constants'
 
 import {
   extend,
@@ -20,6 +16,8 @@ import {
   isBuiltInTag,
   isPlainObject
 } from 'shared/util'
+import type { Component } from 'types/component'
+import type { ComponentOptions } from 'types/options'
 
 /**
  * Option overwriting strategies are functions that handle
@@ -31,12 +29,17 @@ const strats = config.optionMergeStrategies
 /**
  * Options with restrictions
  */
-if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
+if (__DEV__) {
+  strats.el = strats.propsData = function (
+    parent: any,
+    child: any,
+    vm: any,
+    key: any
+  ) {
     if (!vm) {
       warn(
         `option "${key}" can only be used during instance ` +
-        'creation with the `new` keyword.'
+          'creation with the `new` keyword.'
       )
     }
     return defaultStrat(parent, child)
@@ -46,12 +49,15 @@ if (process.env.NODE_ENV !== 'production') {
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to: Object, from: ?Object): Object {
+function mergeData(
+  to: Record<string | symbol, any>,
+  from: Record<string | symbol, any> | null
+): Record<PropertyKey, any> {
   if (!from) return to
   let key, toVal, fromVal
 
   const keys = hasSymbol
-    ? Reflect.ownKeys(from)
+    ? (Reflect.ownKeys(from) as string[])
     : Object.keys(from)
 
   for (let i = 0; i < keys.length; i++) {
@@ -76,11 +82,11 @@ function mergeData (to: Object, from: ?Object): Object {
 /**
  * Data
  */
-export function mergeDataOrFn (
+export function mergeDataOrFn(
   parentVal: any,
   childVal: any,
   vm?: Component
-): ?Function {
+): Function | null {
   if (!vm) {
     // in a Vue.extend merge, both should be functions
     if (!childVal) {
@@ -94,19 +100,19 @@ export function mergeDataOrFn (
     // 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 function mergedDataFn() {
       return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
+        isFunction(childVal) ? childVal.call(this, this) : childVal,
+        isFunction(parentVal) ? parentVal.call(this, this) : parentVal
       )
     }
   } else {
-    return function mergedInstanceDataFn () {
+    return function mergedInstanceDataFn() {
       // instance merge
-      const instanceData = typeof childVal === 'function'
+      const instanceData = isFunction(childVal)
         ? childVal.call(vm, vm)
         : childVal
-      const defaultData = typeof parentVal === 'function'
+      const defaultData = isFunction(parentVal)
         ? parentVal.call(vm, vm)
         : parentVal
       if (instanceData) {
@@ -122,15 +128,16 @@ strats.data = function (
   parentVal: any,
   childVal: any,
   vm?: Component
-): ?Function {
+): Function | null {
   if (!vm) {
     if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      )
+      __DEV__ &&
+        warn(
+          'The "data" option should be a function ' +
+            'that returns a per-instance value in component ' +
+            'definitions.',
+          vm
+        )
 
       return parentVal
     }
@@ -143,24 +150,22 @@ strats.data = function (
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal: ?Array<Function>,
-  childVal: ?Function | ?Array<Function>
-): ?Array<Function> {
+export function mergeLifecycleHook(
+  parentVal: Array<Function> | null,
+  childVal: Function | Array<Function> | null
+): Array<Function> | null {
   const res = childVal
     ? parentVal
       ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
+      : isArray(childVal)
+      ? childVal
+      : [childVal]
     : parentVal
-  return res
-    ? dedupeHooks(res)
-    : res
+  return res ? dedupeHooks(res) : res
 }
 
-function dedupeHooks (hooks) {
-  const res = []
+function dedupeHooks(hooks: any) {
+  const res: Array<any> = []
   for (let i = 0; i < hooks.length; i++) {
     if (res.indexOf(hooks[i]) === -1) {
       res.push(hooks[i])
@@ -170,7 +175,7 @@ function dedupeHooks (hooks) {
 }
 
 LIFECYCLE_HOOKS.forEach(hook => {
-  strats[hook] = mergeHook
+  strats[hook] = mergeLifecycleHook
 })
 
 /**
@@ -180,15 +185,15 @@ LIFECYCLE_HOOKS.forEach(hook => {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal: ?Object,
-  childVal: ?Object,
-  vm?: Component,
+function mergeAssets(
+  parentVal: Object | null,
+  childVal: Object | null,
+  vm: Component | null,
   key: string
 ): Object {
   const res = Object.create(parentVal || null)
   if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm)
+    __DEV__ && assertObjectType(key, childVal, vm)
     return extend(res, childVal)
   } else {
     return res
@@ -206,31 +211,31 @@ ASSET_TYPES.forEach(function (type) {
  * another, so we merge them as arrays.
  */
 strats.watch = function (
-  parentVal: ?Object,
-  childVal: ?Object,
-  vm?: Component,
+  parentVal: Record<string, any> | null,
+  childVal: Record<string, any> | null,
+  vm: Component | null,
   key: string
-): ?Object {
+): Object | null {
   // work around Firefox's Object.prototype.watch...
+  //@ts-expect-error work around
   if (parentVal === nativeWatch) parentVal = undefined
+  //@ts-expect-error work around
   if (childVal === nativeWatch) childVal = undefined
   /* istanbul ignore if */
   if (!childVal) return Object.create(parentVal || null)
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     assertObjectType(key, childVal, vm)
   }
   if (!parentVal) return childVal
-  const ret = {}
+  const ret: Record<string, any> = {}
   extend(ret, parentVal)
   for (const key in childVal) {
     let parent = ret[key]
     const child = childVal[key]
-    if (parent && !Array.isArray(parent)) {
+    if (parent && !isArray(parent)) {
       parent = [parent]
     }
-    ret[key] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child]
+    ret[key] = parent ? parent.concat(child) : isArray(child) ? child : [child]
   }
   return ret
 }
@@ -239,54 +244,58 @@ strats.watch = function (
  * Other object hashes.
  */
 strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal: ?Object,
-  childVal: ?Object,
-  vm?: Component,
-  key: string
-): ?Object {
-  if (childVal && process.env.NODE_ENV !== '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.methods =
+  strats.inject =
+  strats.computed =
+    function (
+      parentVal: Object | null,
+      childVal: Object | null,
+      vm: Component | null,
+      key: string
+    ): Object | null {
+      if (childVal && __DEV__) {
+        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: any, childVal: any): any {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+  return childVal === undefined ? parentVal : childVal
 }
 
 /**
  * Validate component names
  */
-function checkComponents (options: Object) {
+function checkComponents(options: Record<string, any>) {
   for (const key in options.components) {
     validateComponentName(key)
   }
 }
 
-export function validateComponentName (name: string) {
-  if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+export function validateComponentName(name: string) {
+  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.'
+      'Invalid component name: "' +
+        name +
+        '". Component names ' +
+        'should conform to valid custom element name in html5 specification.'
     )
   }
   if (isBuiltInTag(name) || config.isReservedTag(name)) {
     warn(
       'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
+        'id: ' +
+        name
     )
   }
 }
@@ -295,19 +304,19 @@ export function validateComponentName (name: string) {
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options: Object, vm: ?Component) {
+function normalizeProps(options: Record<string, any>, vm?: Component | null) {
   const props = options.props
   if (!props) return
-  const res = {}
+  const res: Record<string, any> = {}
   let i, val, name
-  if (Array.isArray(props)) {
+  if (isArray(props)) {
     i = props.length
     while (i--) {
       val = props[i]
       if (typeof val === 'string') {
         name = camelize(val)
         res[name] = { type: null }
-      } else if (process.env.NODE_ENV !== 'production') {
+      } else if (__DEV__) {
         warn('props must be strings when using array syntax.')
       }
     }
@@ -315,14 +324,12 @@ function normalizeProps (options: Object, vm: ?Component) {
     for (const key in props) {
       val = props[key]
       name = camelize(key)
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val }
+      res[name] = isPlainObject(val) ? val : { type: val }
     }
-  } else if (process.env.NODE_ENV !== 'production') {
+  } else if (__DEV__) {
     warn(
       `Invalid value for option "props": expected an Array or an Object, ` +
-      `but got ${toRawType(props)}.`,
+        `but got ${toRawType(props)}.`,
       vm
     )
   }
@@ -332,11 +339,11 @@ function normalizeProps (options: Object, vm: ?Component) {
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options: Object, vm: ?Component) {
+function normalizeInject(options: Record<string, any>, vm?: Component | null) {
   const inject = options.inject
   if (!inject) return
-  const normalized = options.inject = {}
-  if (Array.isArray(inject)) {
+  const normalized: Record<string, any> = (options.inject = {})
+  if (isArray(inject)) {
     for (let i = 0; i < inject.length; i++) {
       normalized[inject[i]] = { from: inject[i] }
     }
@@ -347,10 +354,10 @@ function normalizeInject (options: Object, vm: ?Component) {
         ? extend({ from: key }, val)
         : { from: val }
     }
-  } else if (process.env.NODE_ENV !== 'production') {
+  } else if (__DEV__) {
     warn(
       `Invalid value for option "inject": expected an Array or an Object, ` +
-      `but got ${toRawType(inject)}.`,
+        `but got ${toRawType(inject)}.`,
       vm
     )
   }
@@ -359,23 +366,23 @@ function normalizeInject (options: Object, vm: ?Component) {
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options: Object) {
+function normalizeDirectives(options: Record<string, any>) {
   const dirs = options.directives
   if (dirs) {
     for (const key in dirs) {
       const def = dirs[key]
-      if (typeof def === 'function') {
+      if (isFunction(def)) {
         dirs[key] = { bind: def, update: def }
       }
     }
   }
 }
 
-function assertObjectType (name: string, value: any, vm: ?Component) {
+function assertObjectType(name: string, value: any, vm: Component | null) {
   if (!isPlainObject(value)) {
     warn(
       `Invalid value for option "${name}": expected an Object, ` +
-      `but got ${toRawType(value)}.`,
+        `but got ${toRawType(value)}.`,
       vm
     )
   }
@@ -385,16 +392,17 @@ function assertObjectType (name: string, value: any, vm: ?Component) {
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-export function mergeOptions (
-  parent: Object,
-  child: Object,
-  vm?: Component
-): Object {
-  if (process.env.NODE_ENV !== 'production') {
+export function mergeOptions(
+  parent: Record<string, any>,
+  child: Record<string, any>,
+  vm?: Component | null
+): ComponentOptions {
+  if (__DEV__) {
     checkComponents(child)
   }
 
-  if (typeof child === 'function') {
+  if (isFunction(child)) {
+    // @ts-expect-error
     child = child.options
   }
 
@@ -417,7 +425,7 @@ export function mergeOptions (
     }
   }
 
-  const options = {}
+  const options: ComponentOptions = {} as any
   let key
   for (key in parent) {
     mergeField(key)
@@ -427,7 +435,7 @@ export function mergeOptions (
       mergeField(key)
     }
   }
-  function mergeField (key) {
+  function mergeField(key: any) {
     const strat = strats[key] || defaultStrat
     options[key] = strat(parent[key], child[key], vm, key)
   }
@@ -439,8 +447,8 @@ export function mergeOptions (
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-export function resolveAsset (
-  options: Object,
+export function resolveAsset(
+  options: Record<string, any>,
   type: string,
   id: string,
   warnMissing?: boolean
@@ -458,11 +466,8 @@ export function resolveAsset (
   if (hasOwn(assets, PascalCaseId)) return assets[PascalCaseId]
   // fallback to prototype chain
   const res = assets[id] || assets[camelizedId] || assets[PascalCaseId]
-  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    )
+  if (__DEV__ && warnMissing && !res) {
+    warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options)
   }
   return res
 }

package/src/core/util/{perf.js → perf.ts}

@@ -3,14 +3,18 @@ import { inBrowser } from './env'
 export let mark
 export let measure
 
-if (process.env.NODE_ENV !== 'production') {
+if (__DEV__) {
   const perf = inBrowser && window.performance
   /* istanbul ignore if */
   if (
     perf &&
+    // @ts-ignore
     perf.mark &&
+    // @ts-ignore
     perf.measure &&
+    // @ts-ignore
     perf.clearMarks &&
+    // @ts-ignore
     perf.clearMeasures
   ) {
     mark = tag => perf.mark(tag)