vue 2.6.13 → 2.7.0-alpha.2

package/src/sfc/{parser.js → parser.ts}

@@ -1,8 +1,12 @@
-/* @flow */
-
 import deindent from 'de-indent'
 import { parseHTML } from 'compiler/parser/html-parser'
 import { makeMap } from 'shared/util'
+import {
+  ASTAttr,
+  SFCBlock,
+  SFCDescriptor,
+  WarningMessage
+} from 'types/compiler'
 
 const splitRE = /\r?\n/g
 const replaceRE = /./g
@@ -11,9 +15,9 @@ const isSpecialTag = makeMap('script,style,template', true)
 /**
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
  */
-export function parseComponent (
+export function parseComponent(
   content: string,
-  options?: Object = {}
+  options: Record<string, any> = {}
 ): SFCDescriptor {
   const sfc: SFCDescriptor = {
     template: null,
@@ -23,13 +27,13 @@ export function parseComponent (
     errors: []
   }
   let depth = 0
-  let currentBlock: ?SFCBlock = null
+  let currentBlock: SFCBlock | null = null
 
-  let warn = msg => {
+  let warn: any = msg => {
     sfc.errors.push(msg)
   }
 
-  if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+  if (__DEV__ && options.outputSourceRange) {
     warn = (msg, range) => {
       const data: WarningMessage = { msg }
       if (range.start != null) {
@@ -42,7 +46,7 @@ export function parseComponent (
     }
   }
 
-  function start (
+  function start(
     tag: string,
     attrs: Array<ASTAttr>,
     unary: boolean,
@@ -66,7 +70,8 @@ export function parseComponent (
         } else {
           sfc[tag] = currentBlock
         }
-      } else { // custom blocks
+      } else {
+        // custom blocks
         sfc.customBlocks.push(currentBlock)
       }
     }
@@ -75,7 +80,7 @@ export function parseComponent (
     }
   }
 
-  function checkAttrs (block: SFCBlock, attrs: Array<ASTAttr>) {
+  function checkAttrs(block: SFCBlock, attrs: Array<ASTAttr>) {
     for (let i = 0; i < attrs.length; i++) {
       const attr = attrs[i]
       if (attr.name === 'lang') {
@@ -93,7 +98,7 @@ export function parseComponent (
     }
   }
 
-  function end (tag: string, start: number) {
+  function end(tag: string, start: number) {
     if (depth === 1 && currentBlock) {
       currentBlock.end = start
       let text = content.slice(currentBlock.start, currentBlock.end)
@@ -111,14 +116,12 @@ export function parseComponent (
     depth--
   }
 
-  function padContent (block: SFCBlock, pad: true | "line" | "space") {
+  function padContent(block: SFCBlock, pad: true | 'line' | 'space') {
     if (pad === 'space') {
       return content.slice(0, block.start).replace(replaceRE, ' ')
     } else {
       const offset = content.slice(0, block.start).split(splitRE).length
-      const padChar = block.type === 'script' && !block.lang
-        ? '//\n'
-        : '\n'
+      const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'
       return Array(offset).join(padChar)
     }
   }

package/src/shared/{constants.js → constants.ts}

@@ -1,10 +1,6 @@
 export const SSR_ATTR = 'data-server-rendered'
 
-export const ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-]
+export const ASSET_TYPES = ['component', 'directive', 'filter'] as const
 
 export const LIFECYCLE_HOOKS = [
   'beforeCreate',
@@ -19,4 +15,4 @@ export const LIFECYCLE_HOOKS = [
   'deactivated',
   'errorCaptured',
   'serverPrefetch'
-]
+] as const

package/src/shared/{util.js → util.ts}

@@ -1,29 +1,29 @@
-/* @flow */
+export const emptyObject: Record<string, any> = Object.freeze({})
 
-export const emptyObject = Object.freeze({})
+export const isArray = Array.isArray
 
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-export function isUndef (v: any): boolean %checks {
+export function isUndef(v: any): v is undefined | null {
   return v === undefined || v === null
 }
 
-export function isDef (v: any): boolean %checks {
+export function isDef<T>(v: T): v is NonNullable<T> {
   return v !== undefined && v !== null
 }
 
-export function isTrue (v: any): boolean %checks {
+export function isTrue(v: any): boolean {
   return v === true
 }
 
-export function isFalse (v: any): boolean %checks {
+export function isFalse(v: any): boolean {
   return v === false
 }
 
 /**
  * Check if value is primitive.
  */
-export function isPrimitive (value: any): boolean %checks {
+export function isPrimitive(value: any): boolean {
   return (
     typeof value === 'string' ||
     typeof value === 'number' ||
@@ -33,12 +33,16 @@ export function isPrimitive (value: any): boolean %checks {
   )
 }
 
+export function isFunction(value: any): value is (...args: any[]) => any {
+  return typeof value === 'function'
+}
+
 /**
  * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
+ * objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-export function isObject (obj: mixed): boolean %checks {
+export function isObject(obj: any): boolean {
   return obj !== null && typeof obj === 'object'
 }
 
@@ -47,7 +51,7 @@ export function isObject (obj: mixed): boolean %checks {
  */
 const _toString = Object.prototype.toString
 
-export function toRawType (value: any): string {
+export function toRawType(value: any): string {
   return _toString.call(value).slice(8, -1)
 }
 
@@ -55,23 +59,23 @@ export function toRawType (value: any): string {
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-export function isPlainObject (obj: any): boolean {
+export function isPlainObject(obj: any): boolean {
   return _toString.call(obj) === '[object Object]'
 }
 
-export function isRegExp (v: any): boolean {
+export function isRegExp(v: any): v is RegExp {
   return _toString.call(v) === '[object RegExp]'
 }
 
 /**
  * Check if val is a valid array index.
  */
-export function isValidArrayIndex (val: any): boolean {
+export function isValidArrayIndex(val: any): boolean {
   const n = parseFloat(String(val))
   return n >= 0 && Math.floor(n) === n && isFinite(val)
 }
 
-export function isPromise (val: any): boolean {
+export function isPromise(val: any): val is Promise<any> {
   return (
     isDef(val) &&
     typeof val.then === 'function' &&
@@ -82,19 +86,19 @@ export function isPromise (val: any): boolean {
 /**
  * Convert a value to a string that is actually rendered.
  */
-export function toString (val: any): string {
+export function toString(val: any): string {
   return val == null
     ? ''
     : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+    ? JSON.stringify(val, null, 2)
+    : String(val)
 }
 
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-export function toNumber (val: string): number | string {
+export function toNumber(val: string): number | string {
   const n = parseFloat(val)
   return isNaN(n) ? val : n
 }
@@ -103,18 +107,16 @@ export function toNumber (val: string): number | string {
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-export function makeMap (
+export function makeMap(
   str: string,
   expectsLowerCase?: boolean
-): (key: string) => true | void {
+): (key: string) => true | undefined {
   const map = Object.create(null)
   const list: Array<string> = str.split(',')
   for (let i = 0; i < list.length; i++) {
     map[list[i]] = true
   }
-  return expectsLowerCase
-    ? val => map[val.toLowerCase()]
-    : val => map[val]
+  return expectsLowerCase ? val => map[val.toLowerCase()] : val => map[val]
 }
 
 /**
@@ -130,7 +132,7 @@ export const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is')
 /**
  * Remove an item from an array.
  */
-export function remove (arr: Array<any>, item: any): Array<any> | void {
+export function remove(arr: Array<any>, item: any): Array<any> | void {
   if (arr.length) {
     const index = arr.indexOf(item)
     if (index > -1) {
@@ -143,19 +145,19 @@ export function remove (arr: Array<any>, item: any): Array<any> | void {
  * Check whether an object has the property.
  */
 const hasOwnProperty = Object.prototype.hasOwnProperty
-export function hasOwn (obj: Object | Array<*>, key: string): boolean {
+export function hasOwn(obj: Object | Array<any>, key: string): boolean {
   return hasOwnProperty.call(obj, key)
 }
 
 /**
  * Create a cached version of a pure function.
  */
-export function cached<F: Function> (fn: F): F {
-  const cache = Object.create(null)
-  return (function cachedFn (str: string) {
+export function cached<R>(fn: (str: string) => R): (sr: string) => R {
+  const cache: Record<string, R> = Object.create(null)
+  return function cachedFn(str: string) {
     const hit = cache[str]
     return hit || (cache[str] = fn(str))
-  }: any)
+  }
 }
 
 /**
@@ -163,7 +165,7 @@ export function cached<F: Function> (fn: F): F {
  */
 const camelizeRE = /-(\w)/g
 export const camelize = cached((str: string): string => {
-  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '')
+  return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''))
 })
 
 /**
@@ -190,8 +192,8 @@ export const hyphenate = cached((str: string): string => {
  */
 
 /* istanbul ignore next */
-function polyfillBind (fn: Function, ctx: Object): Function {
-  function boundFn (a) {
+function polyfillBind(fn: Function, ctx: Object): Function {
+  function boundFn(a: any) {
     const l = arguments.length
     return l
       ? l > 1
@@ -204,18 +206,17 @@ function polyfillBind (fn: Function, ctx: Object): Function {
   return boundFn
 }
 
-function nativeBind (fn: Function, ctx: Object): Function {
+function nativeBind(fn: Function, ctx: Object): Function {
   return fn.bind(ctx)
 }
 
-export const bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind
+// @ts-expect-error bind cannot be `undefined`
+export const bind = Function.prototype.bind ? nativeBind : polyfillBind
 
 /**
  * Convert an Array-like object to a real Array.
  */
-export function toArray (list: any, start?: number): Array<any> {
+export function toArray(list: any, start?: number): Array<any> {
   start = start || 0
   let i = list.length - start
   const ret: Array<any> = new Array(i)
@@ -228,7 +229,10 @@ export function toArray (list: any, start?: number): Array<any> {
 /**
  * Mix properties into target object.
  */
-export function extend (to: Object, _from: ?Object): Object {
+export function extend(
+  to: Record<PropertyKey, any>,
+  _from?: Record<PropertyKey, any>
+): Record<PropertyKey, any> {
   for (const key in _from) {
     to[key] = _from[key]
   }
@@ -238,7 +242,7 @@ export function extend (to: Object, _from: ?Object): Object {
 /**
  * Merge an Array of Objects into a single Object.
  */
-export function toObject (arr: Array<any>): Object {
+export function toObject(arr: Array<any>): object {
   const res = {}
   for (let i = 0; i < arr.length; i++) {
     if (arr[i]) {
@@ -255,7 +259,7 @@ export function toObject (arr: Array<any>): Object {
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-export function noop (a?: any, b?: any, c?: any) {}
+export function noop(a?: any, b?: any, c?: any) {}
 
 /**
  * Always return false.
@@ -272,17 +276,21 @@ export const identity = (_: any) => _
 /**
  * Generate a string containing static keys from compiler modules.
  */
-export function genStaticKeys (modules: Array<ModuleOptions>): string {
-  return modules.reduce((keys, m) => {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+export function genStaticKeys(
+  modules: Array<{ staticKeys?: string[] } /* ModuleOptions */>
+): string {
+  return modules
+    .reduce((keys, m) => {
+      return keys.concat(m.staticKeys || [])
+    }, [] as string[])
+    .join(',')
 }
 
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-export function looseEqual (a: any, b: any): boolean {
+export function looseEqual(a: any, b: any): boolean {
   if (a === b) return true
   const isObjectA = isObject(a)
   const isObjectB = isObject(b)
@@ -291,22 +299,28 @@ export function looseEqual (a: any, b: any): boolean {
       const isArrayA = Array.isArray(a)
       const isArrayB = Array.isArray(b)
       if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every((e, i) => {
-          return looseEqual(e, b[i])
-        })
+        return (
+          a.length === b.length &&
+          a.every((e: any, i: any) => {
+            return looseEqual(e, b[i])
+          })
+        )
       } else if (a instanceof Date && b instanceof Date) {
         return a.getTime() === b.getTime()
       } else if (!isArrayA && !isArrayB) {
         const keysA = Object.keys(a)
         const keysB = Object.keys(b)
-        return keysA.length === keysB.length && keysA.every(key => {
-          return looseEqual(a[key], b[key])
-        })
+        return (
+          keysA.length === keysB.length &&
+          keysA.every(key => {
+            return looseEqual(a[key], b[key])
+          })
+        )
       } else {
         /* istanbul ignore next */
         return false
       }
-    } catch (e) {
+    } catch (e: any) {
       /* istanbul ignore next */
       return false
     }
@@ -322,7 +336,7 @@ export function looseEqual (a: any, b: any): boolean {
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-export function looseIndexOf (arr: Array<mixed>, val: mixed): number {
+export function looseIndexOf(arr: Array<unknown>, val: unknown): number {
   for (let i = 0; i < arr.length; i++) {
     if (looseEqual(arr[i], val)) return i
   }
@@ -332,12 +346,21 @@ export function looseIndexOf (arr: Array<mixed>, val: mixed): number {
 /**
  * Ensure a function is called only once.
  */
-export function once (fn: Function): Function {
+export function once<T extends (...args: any[]) => any>(fn: T): T {
   let called = false
   return function () {
     if (!called) {
       called = true
-      fn.apply(this, arguments)
+      fn.apply(this, arguments as any)
     }
+  } as any
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill
+export function hasChanged(x: unknown, y: unknown): boolean {
+  if (x === y) {
+    return x === 0 && 1 / x !== 1 / (y as number)
+  } else {
+    return x === x && y === y
   }
 }

package/src/types/compiler.ts

@@ -0,0 +1,224 @@
+export type CompilerOptions = {
+  warn?: Function // allow customizing warning in different environments; e.g. node
+  modules?: Array<ModuleOptions> // platform specific modules; e.g. style; class
+  directives?: { [key: string]: Function } // platform specific directives
+  staticKeys?: string // a list of AST properties to be considered static; for optimization
+  isUnaryTag?: (tag: string) => boolean | undefined // check if a tag is unary for the platform
+  canBeLeftOpenTag?: (tag: string) => boolean | undefined // check if a tag can be left opened
+  isReservedTag?: (tag: string) => boolean | undefined // check if a tag is a native for the platform
+  preserveWhitespace?: boolean // preserve whitespace between elements? (Deprecated)
+  whitespace?: 'preserve' | 'condense' // whitespace handling strategy
+  optimize?: boolean // optimize static content?
+
+  // web specific
+  mustUseProp?: (tag: string, type: string | null, name: string) => boolean // check if an attribute should be bound as a property
+  isPreTag?: (attr: string) => boolean | null // check if a tag needs to preserve whitespace
+  getTagNamespace?: (tag: string) => string | undefined // check the namespace for a tag
+  expectHTML?: boolean // only false for non-web builds
+  isFromDOM?: boolean
+  shouldDecodeTags?: boolean
+  shouldDecodeNewlines?: boolean
+  shouldDecodeNewlinesForHref?: boolean
+  outputSourceRange?: boolean
+
+  // runtime user-configurable
+  delimiters?: [string, string] // template delimiters
+  comments?: boolean // preserve comments in template
+
+  // for ssr optimization compiler
+  scopeId?: string
+}
+
+export type WarningMessage = {
+  msg: string
+  start?: number
+  end?: number
+}
+
+export type CompiledResult = {
+  ast: ASTElement | null
+  render: string
+  staticRenderFns: Array<string>
+  stringRenderFns?: Array<string>
+  errors?: Array<string | WarningMessage>
+  tips?: Array<string | WarningMessage>
+}
+
+export type ModuleOptions = {
+  // transform an AST node before any attributes are processed
+  // returning an ASTElement from pre/transforms replaces the element
+  preTransformNode: (el: ASTElement) => ASTElement | null
+  // transform an AST node after built-ins like v-if, v-for are processed
+  transformNode: (el: ASTElement) => ASTElement | null
+  // transform an AST node after its children have been processed
+  // cannot return replacement in postTransform because tree is already finalized
+  postTransformNode: (el: ASTElement) => void
+  genData: (el: ASTElement) => string // generate extra data string for an element
+  transformCode?: (el: ASTElement, code: string) => string // further transform generated code for an element
+  staticKeys?: Array<string> // AST properties to be considered static
+}
+
+export type ASTModifiers = { [key: string]: boolean }
+export type ASTIfCondition = { exp: string | null; block: ASTElement }
+export type ASTIfConditions = Array<ASTIfCondition>
+
+export type ASTAttr = {
+  name: string
+  value: any
+  dynamic?: boolean
+  start?: number
+  end?: number
+}
+
+export type ASTElementHandler = {
+  value: string
+  params?: Array<any>
+  modifiers: ASTModifiers | null
+  dynamic?: boolean
+  start?: number
+  end?: number
+}
+
+export type ASTElementHandlers = {
+  [key: string]: ASTElementHandler | Array<ASTElementHandler>
+}
+
+export type ASTDirective = {
+  name: string
+  rawName: string
+  value: string
+  arg: string | null
+  isDynamicArg: boolean
+  modifiers: ASTModifiers | null
+  start?: number
+  end?: number
+}
+
+export type ASTNode = ASTElement | ASTText | ASTExpression
+
+export type ASTElement = {
+  type: 1
+  tag: string
+  attrsList: Array<ASTAttr>
+  attrsMap: { [key: string]: any }
+  rawAttrsMap: { [key: string]: ASTAttr }
+  parent: ASTElement | void
+  children: Array<ASTNode>
+
+  start?: number
+  end?: number
+
+  processed?: true
+
+  static?: boolean
+  staticRoot?: boolean
+  staticInFor?: boolean
+  staticProcessed?: boolean
+  hasBindings?: boolean
+
+  text?: string
+  attrs?: Array<ASTAttr>
+  dynamicAttrs?: Array<ASTAttr>
+  props?: Array<ASTAttr>
+  plain?: boolean
+  pre?: true
+  ns?: string
+
+  component?: string
+  inlineTemplate?: true
+  transitionMode?: string | null
+  slotName?: string | null
+  slotTarget?: string | null
+  slotTargetDynamic?: boolean
+  slotScope?: string | null
+  scopedSlots?: { [name: string]: ASTElement }
+
+  ref?: string
+  refInFor?: boolean
+
+  if?: string
+  ifProcessed?: boolean
+  elseif?: string
+  else?: true
+  ifConditions?: ASTIfConditions
+
+  for?: string
+  forProcessed?: boolean
+  key?: string
+  alias?: string
+  iterator1?: string
+  iterator2?: string
+
+  staticClass?: string
+  classBinding?: string
+  staticStyle?: string
+  styleBinding?: string
+  events?: ASTElementHandlers
+  nativeEvents?: ASTElementHandlers
+
+  transition?: string | true
+  transitionOnAppear?: boolean
+
+  model?: {
+    value: string
+    callback: string
+    expression: string
+  }
+
+  directives?: Array<ASTDirective>
+
+  forbidden?: true
+  once?: true
+  onceProcessed?: boolean
+  wrapData?: (code: string) => string
+  wrapListeners?: (code: string) => string
+
+  // 2.4 ssr optimization
+  ssrOptimizability?: number
+}
+
+export type ASTExpression = {
+  type: 2
+  expression: string
+  text: string
+  tokens: Array<string | Object>
+  static?: boolean
+  // 2.4 ssr optimization
+  ssrOptimizability?: number
+  start?: number
+  end?: number
+}
+
+export type ASTText = {
+  type: 3
+  text: string
+  static?: boolean
+  isComment?: boolean
+  // 2.4 ssr optimization
+  ssrOptimizability?: number
+  start?: number
+  end?: number
+}
+
+// SFC-parser related declarations
+
+// an object format describing a single-file component
+export type SFCDescriptor = {
+  template: SFCBlock | null
+  script: SFCBlock | null
+  styles: Array<SFCBlock>
+  customBlocks: Array<SFCBlock>
+  errors: Array<string | WarningMessage>
+}
+
+export type SFCBlock = {
+  type: string
+  content: string
+  attrs: { [attribute: string]: string }
+  start?: number
+  end?: number
+  lang?: string
+  src?: string
+  scoped?: boolean
+  module?: string | boolean
+}