vue 2.6.13 → 2.7.0-alpha.2

package/src/compiler/parser/{text-parser.js → text-parser.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 import { cached } from 'shared/util'
 import { parseFilters } from './filter-parser'
 
@@ -13,27 +11,28 @@ const buildRegex = cached(delimiters => {
 })
 
 type TextParseResult = {
-  expression: string,
+  expression: string
   tokens: Array<string | { '@binding': string }>
 }
 
-export function parseText (
+export function parseText(
   text: string,
   delimiters?: [string, string]
 ): TextParseResult | void {
+  //@ts-expect-error
   const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
   if (!tagRE.test(text)) {
     return
   }
-  const tokens = []
-  const rawTokens = []
-  let lastIndex = tagRE.lastIndex = 0
+  const tokens: string[] = []
+  const rawTokens: any[] = []
+  let lastIndex = (tagRE.lastIndex = 0)
   let match, index, tokenValue
   while ((match = tagRE.exec(text))) {
     index = match.index
     // push text token
     if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index))
+      rawTokens.push((tokenValue = text.slice(lastIndex, index)))
       tokens.push(JSON.stringify(tokenValue))
     }
     // tag token
@@ -43,7 +42,7 @@ export function parseText (
     lastIndex = index + match[0].length
   }
   if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex))
+    rawTokens.push((tokenValue = text.slice(lastIndex)))
     tokens.push(JSON.stringify(tokenValue))
   }
   return {

package/src/compiler/{to-function.js → to-function.ts}

@@ -1,27 +1,27 @@
-/* @flow */
-
 import { noop, extend } from 'shared/util'
 import { warn as baseWarn, tip } from 'core/util/debug'
 import { generateCodeFrame } from './codeframe'
+import type { Component } from 'types/component'
+import { CompilerOptions } from 'types/compiler'
 
 type CompiledFunctionResult = {
-  render: Function;
-  staticRenderFns: Array<Function>;
-};
+  render: Function
+  staticRenderFns: Array<Function>
+}
 
-function createFunction (code, errors) {
+function createFunction(code, errors) {
   try {
     return new Function(code)
-  } catch (err) {
+  } catch (err: any) {
     errors.push({ err, code })
     return noop
   }
 }
 
-export function createCompileToFunctionFn (compile: Function): Function {
+export function createCompileToFunctionFn(compile: Function): Function {
   const cache = Object.create(null)
 
-  return function compileToFunctions (
+  return function compileToFunctions(
     template: string,
     options?: CompilerOptions,
     vm?: Component
@@ -31,18 +31,18 @@ export function createCompileToFunctionFn (compile: Function): Function {
     delete options.warn
 
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       // detect possible CSP restriction
       try {
         new Function('return 1')
-      } catch (e) {
+      } catch (e: any) {
         if (e.toString().match(/unsafe-eval|CSP/)) {
           warn(
             'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
+              'environment with Content Security Policy that prohibits unsafe-eval. ' +
+              'The template compiler cannot work in this environment. Consider ' +
+              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+              'templates into render functions.'
           )
         }
       }
@@ -60,20 +60,21 @@ export function createCompileToFunctionFn (compile: Function): Function {
     const compiled = compile(template, options)
 
     // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       if (compiled.errors && compiled.errors.length) {
         if (options.outputSourceRange) {
           compiled.errors.forEach(e => {
             warn(
               `Error compiling template:\n\n${e.msg}\n\n` +
-              generateCodeFrame(template, e.start, e.end),
+                generateCodeFrame(template, e.start, e.end),
               vm
             )
           })
         } else {
           warn(
             `Error compiling template:\n\n${template}\n\n` +
-            compiled.errors.map(e => `- ${e}`).join('\n') + '\n',
+              compiled.errors.map(e => `- ${e}`).join('\n') +
+              '\n',
             vm
           )
         }
@@ -88,8 +89,8 @@ export function createCompileToFunctionFn (compile: Function): Function {
     }
 
     // turn code into functions
-    const res = {}
-    const fnGenErrors = []
+    const res: any = {}
+    const fnGenErrors: any[] = []
     res.render = createFunction(compiled.render, fnGenErrors)
     res.staticRenderFns = compiled.staticRenderFns.map(code => {
       return createFunction(code, fnGenErrors)
@@ -99,11 +100,15 @@ export function createCompileToFunctionFn (compile: Function): Function {
     // this should only happen if there is a bug in the compiler itself.
     // mostly for codegen development use
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
         warn(
           `Failed to generate render function:\n\n` +
-          fnGenErrors.map(({ err, code }) => `${err.toString()} in\n\n${code}\n`).join('\n'),
+            fnGenErrors
+              .map(
+                ({ err, code }) => `${(err as any).toString()} in\n\n${code}\n`
+              )
+              .join('\n'),
           vm
         )
       }

package/src/core/components/{keep-alive.js → keep-alive.ts}

@@ -1,22 +1,26 @@
-/* @flow */
-
-import { isRegExp, remove } from 'shared/util'
+import { isRegExp, isArray, remove } from 'shared/util'
 import { getFirstComponentChild } from 'core/vdom/helpers/index'
+import type VNode from 'core/vdom/vnode'
+import type { VNodeComponentOptions } from 'types/vnode'
+import type { Component } from 'types/component'
 
 type CacheEntry = {
-  name: ?string;
-  tag: ?string;
-  componentInstance: Component;
-};
+  name?: string
+  tag?: string
+  componentInstance?: Component
+}
 
-type CacheEntryMap = { [key: string]: ?CacheEntry };
+type CacheEntryMap = Record<string, CacheEntry | null>
 
-function getComponentName (opts: ?VNodeComponentOptions): ?string {
+function getComponentName(opts?: VNodeComponentOptions): string | null {
   return opts && (opts.Ctor.options.name || opts.tag)
 }
 
-function matches (pattern: string | RegExp | Array<string>, name: string): boolean {
-  if (Array.isArray(pattern)) {
+function matches(
+  pattern: string | RegExp | Array<string>,
+  name: string
+): boolean {
+  if (isArray(pattern)) {
     return pattern.indexOf(name) > -1
   } else if (typeof pattern === 'string') {
     return pattern.split(',').indexOf(name) > -1
@@ -27,12 +31,15 @@ function matches (pattern: string | RegExp | Array<string>, name: string): boole
   return false
 }
 
-function pruneCache (keepAliveInstance: any, filter: Function) {
+function pruneCache(
+  keepAliveInstance: { cache: CacheEntryMap; keys: string[]; _vnode: VNode },
+  filter: Function
+) {
   const { cache, keys, _vnode } = keepAliveInstance
   for (const key in cache) {
-    const entry: ?CacheEntry = cache[key]
+    const entry = cache[key]
     if (entry) {
-      const name: ?string = entry.name
+      const name = entry.name
       if (name && !filter(name)) {
         pruneCacheEntry(cache, key, keys, _vnode)
       }
@@ -40,14 +47,15 @@ function pruneCache (keepAliveInstance: any, filter: Function) {
   }
 }
 
-function pruneCacheEntry (
+function pruneCacheEntry(
   cache: CacheEntryMap,
   key: string,
   keys: Array<string>,
   current?: VNode
 ) {
-  const entry: ?CacheEntry = cache[key]
+  const entry = cache[key]
   if (entry && (!current || entry.tag !== current.tag)) {
+    // @ts-expect-error can be undefined
     entry.componentInstance.$destroy()
   }
   cache[key] = null
@@ -56,6 +64,7 @@ function pruneCacheEntry (
 
 const patternTypes: Array<Function> = [String, RegExp, Array]
 
+// TODO defineComponent
 export default {
   name: 'keep-alive',
   abstract: true,
@@ -74,7 +83,7 @@ export default {
         cache[keyToCache] = {
           name: getComponentName(componentOptions),
           tag,
-          componentInstance,
+          componentInstance
         }
         keys.push(keyToCache)
         // prune oldest entry
@@ -86,18 +95,18 @@ export default {
     }
   },
 
-  created () {
+  created() {
     this.cache = Object.create(null)
     this.keys = []
   },
 
-  destroyed () {
+  destroyed() {
     for (const key in this.cache) {
       pruneCacheEntry(this.cache, key, this.keys)
     }
   },
 
-  mounted () {
+  mounted() {
     this.cacheVNode()
     this.$watch('include', val => {
       pruneCache(this, name => matches(val, name))
@@ -107,17 +116,17 @@ export default {
     })
   },
 
-  updated () {
+  updated() {
     this.cacheVNode()
   },
 
-  render () {
+  render() {
     const slot = this.$slots.default
-    const vnode: VNode = getFirstComponentChild(slot)
-    const componentOptions: ?VNodeComponentOptions = vnode && vnode.componentOptions
+    const vnode = getFirstComponentChild(slot)
+    const componentOptions = vnode && vnode.componentOptions
     if (componentOptions) {
       // check pattern
-      const name: ?string = getComponentName(componentOptions)
+      const name = getComponentName(componentOptions)
       const { include, exclude } = this
       if (
         // not included
@@ -129,11 +138,13 @@ export default {
       }
 
       const { cache, keys } = this
-      const key: ?string = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? `::${componentOptions.tag}` : '')
-        : vnode.key
+      const key =
+        vnode.key == null
+          ? // same constructor may get registered as different local components
+            // so cid alone is not enough (#3269)
+            componentOptions.Ctor.cid +
+            (componentOptions.tag ? `::${componentOptions.tag}` : '')
+          : vnode.key
       if (cache[key]) {
         vnode.componentInstance = cache[key].componentInstance
         // make current key freshest
@@ -145,6 +156,7 @@ export default {
         this.keyToCache = key
       }
 
+      // @ts-expect-error can vnode.data can be undefined
       vnode.data.keepAlive = true
     }
     return vnode || (slot && slot[0])

package/src/core/{config.js → config.ts}

@@ -1,41 +1,39 @@
-/* @flow */
-
-import {
-  no,
-  noop,
-  identity
-} from 'shared/util'
+import { no, noop, identity } from 'shared/util'
 
 import { LIFECYCLE_HOOKS } from 'shared/constants'
+import type { Component } from 'types/component'
 
-export type Config = {
+/**
+ * @internal
+ */
+export interface Config {
   // user
-  optionMergeStrategies: { [key: string]: Function };
-  silent: boolean;
-  productionTip: boolean;
-  performance: boolean;
-  devtools: boolean;
-  errorHandler: ?(err: Error, vm: Component, info: string) => void;
-  warnHandler: ?(msg: string, vm: Component, trace: string) => void;
-  ignoredElements: Array<string | RegExp>;
-  keyCodes: { [key: string]: number | Array<number> };
+  optionMergeStrategies: { [key: string]: Function }
+  silent: boolean
+  productionTip: boolean
+  performance: boolean
+  devtools: boolean
+  errorHandler?: (err: Error, vm: Component, info: string) => void
+  warnHandler?: (msg: string, vm: Component, trace: string) => void
+  ignoredElements: Array<string | RegExp>
+  keyCodes: { [key: string]: number | Array<number> }
 
   // platform
-  isReservedTag: (x?: string) => boolean;
-  isReservedAttr: (x?: string) => boolean;
-  parsePlatformTagName: (x: string) => string;
-  isUnknownElement: (x?: string) => boolean;
-  getTagNamespace: (x?: string) => string | void;
-  mustUseProp: (tag: string, type: ?string, name: string) => boolean;
+  isReservedTag: (x: string) => boolean | undefined
+  isReservedAttr: (x: string) => true | undefined
+  parsePlatformTagName: (x: string) => string
+  isUnknownElement: (x: string) => boolean
+  getTagNamespace: (x: string) => string | undefined
+  mustUseProp: (tag: string, type?: string | null, name?: string) => boolean
 
   // private
-  async: boolean;
+  async: boolean
 
   // legacy
-  _lifecycleHooks: Array<string>;
-};
+  _lifecycleHooks: Array<string>
+}
 
-export default ({
+export default {
   /**
    * Option merge strategies (used in core/util/options)
    */
@@ -50,12 +48,12 @@ export default ({
   /**
    * Show production mode tip message on boot?
    */
-  productionTip: process.env.NODE_ENV !== 'production',
+  productionTip: __DEV__,
 
   /**
    * Whether to enable devtools
    */
-  devtools: process.env.NODE_ENV !== 'production',
+  devtools: __DEV__,
 
   /**
    * Whether to record perf
@@ -127,4 +125,4 @@ export default ({
    * Exposed for legacy reasons
    */
   _lifecycleHooks: LIFECYCLE_HOOKS
-}: Config)
+} as unknown as Config

package/src/core/global-api/{assets.js → assets.ts}

@@ -1,29 +1,30 @@
-/* @flow */
-
 import { ASSET_TYPES } from 'shared/constants'
-import { isPlainObject, validateComponentName } from '../util/index'
+import type { GlobalAPI } from 'types/global-api'
+import { isFunction, isPlainObject, validateComponentName } from '../util/index'
 
-export function initAssetRegisters (Vue: GlobalAPI) {
+export function initAssetRegisters(Vue: GlobalAPI) {
   /**
    * Create asset registration methods.
    */
   ASSET_TYPES.forEach(type => {
+    // @ts-expect-error function is not exact same type
     Vue[type] = function (
       id: string,
-      definition: Function | Object
+      definition?: Function | Object
     ): Function | Object | void {
       if (!definition) {
         return this.options[type + 's'][id]
       } else {
         /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && type === 'component') {
+        if (__DEV__ && type === 'component') {
           validateComponentName(id)
         }
         if (type === 'component' && isPlainObject(definition)) {
+          // @ts-expect-error
           definition.name = definition.name || id
           definition = this.options._base.extend(definition)
         }
-        if (type === 'directive' && typeof definition === 'function') {
+        if (type === 'directive' && isFunction(definition)) {
           definition = { bind: definition, update: definition }
         }
         this.options[type + 's'][id] = definition

package/src/core/global-api/{extend.js → extend.ts}

@@ -1,10 +1,10 @@
-/* @flow */
-
 import { ASSET_TYPES } from 'shared/constants'
+import type { Component } from 'types/component'
+import type { GlobalAPI } from 'types/global-api'
 import { defineComputed, proxy } from '../instance/state'
 import { extend, mergeOptions, validateComponentName } from '../util/index'
 
-export function initExtend (Vue: GlobalAPI) {
+export function initExtend(Vue: GlobalAPI) {
   /**
    * Each instance constructor, including Vue, has a unique
    * cid. This enables us to create wrapped "child
@@ -16,7 +16,7 @@ export function initExtend (Vue: GlobalAPI) {
   /**
    * Class inheritance
    */
-  Vue.extend = function (extendOptions: Object): Function {
+  Vue.extend = function (extendOptions: any): typeof Component {
     extendOptions = extendOptions || {}
     const Super = this
     const SuperId = Super.cid
@@ -26,20 +26,17 @@ export function initExtend (Vue: GlobalAPI) {
     }
 
     const name = extendOptions.name || Super.options.name
-    if (process.env.NODE_ENV !== 'production' && name) {
+    if (__DEV__ && name) {
       validateComponentName(name)
     }
 
-    const Sub = function VueComponent (options) {
+    const Sub = function VueComponent(this: any, options: any) {
       this._init(options)
-    }
+    } as unknown as typeof Component
     Sub.prototype = Object.create(Super.prototype)
     Sub.prototype.constructor = Sub
     Sub.cid = cid++
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    )
+    Sub.options = mergeOptions(Super.options, extendOptions)
     Sub['super'] = Super
 
     // For props and computed properties, we define the proxy getters on
@@ -80,14 +77,14 @@ export function initExtend (Vue: GlobalAPI) {
   }
 }
 
-function initProps (Comp) {
+function initProps(Comp: typeof Component) {
   const props = Comp.options.props
   for (const key in props) {
     proxy(Comp.prototype, `_props`, key)
   }
 }
 
-function initComputed (Comp) {
+function initComputed(Comp: typeof Component) {
   const computed = Comp.options.computed
   for (const key in computed) {
     defineComputed(Comp.prototype, key, computed[key])

package/src/core/global-api/{index.js → index.ts}

@@ -1,5 +1,3 @@
-/* @flow */
-
 import config from '../config'
 import { initUse } from './use'
 import { initMixin } from './mixin'
@@ -17,12 +15,13 @@ import {
   mergeOptions,
   defineReactive
 } from '../util/index'
+import type { GlobalAPI } from 'types/global-api'
 
-export function initGlobalAPI (Vue: GlobalAPI) {
+export function initGlobalAPI(Vue: GlobalAPI) {
   // config
-  const configDef = {}
+  const configDef: Record<string, any> = {}
   configDef.get = () => config
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     configDef.set = () => {
       warn(
         'Do not replace the Vue.config object, set individual fields instead.'

package/src/core/global-api/{mixin.js → mixin.ts}

@@ -1,8 +1,7 @@
-/* @flow */
-
+import type { GlobalAPI } from 'types/global-api'
 import { mergeOptions } from '../util/index'
 
-export function initMixin (Vue: GlobalAPI) {
+export function initMixin(Vue: GlobalAPI) {
   Vue.mixin = function (mixin: Object) {
     this.options = mergeOptions(this.options, mixin)
     return this

package/src/core/global-api/use.ts

@@ -0,0 +1,23 @@
+import type { GlobalAPI } from 'types/global-api'
+import { toArray, isFunction } from '../util/index'
+
+export function initUse(Vue: GlobalAPI) {
+  Vue.use = function (plugin: Function | any) {
+    const installedPlugins =
+      this._installedPlugins || (this._installedPlugins = [])
+    if (installedPlugins.indexOf(plugin) > -1) {
+      return this
+    }
+
+    // additional parameters
+    const args = toArray(arguments, 1)
+    args.unshift(this)
+    if (isFunction(plugin.install)) {
+      plugin.install.apply(plugin, args)
+    } else if (isFunction(plugin)) {
+      plugin.apply(null, args)
+    }
+    installedPlugins.push(plugin)
+    return this
+  }
+}

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

@@ -10,7 +10,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
 })
 
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get () {
+  get() {
     /* istanbul ignore next */
     return this.$vnode && this.$vnode.ssrContext
   }