vue 2.6.13 → 2.7.0-alpha.2

package/src/compiler/directives/{model.js → model.ts}

@@ -1,13 +1,13 @@
-/* @flow */
+import { ASTElement, ASTModifiers } from 'types/compiler'
 
 /**
  * Cross-platform code generation for component v-model
  */
-export function genComponentModel (
+export function genComponentModel(
   el: ASTElement,
   value: string,
-  modifiers: ?ASTModifiers
-): ?boolean {
+  modifiers: ASTModifiers | null
+): void {
   const { number, trim } = modifiers || {}
 
   const baseValueExpression = '$$v'
@@ -33,10 +33,7 @@ export function genComponentModel (
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-export function genAssignmentCode (
-  value: string,
-  assignment: string
-): string {
+export function genAssignmentCode(value: string, assignment: string): string {
   const res = parseModel(value)
   if (res.key === null) {
     return `${value}=${assignment}`
@@ -63,11 +60,11 @@ export function genAssignmentCode (
 let len, str, chr, index, expressionPos, expressionEndPos
 
 type ModelParseResult = {
-  exp: string,
+  exp: string
   key: string | null
 }
 
-export function parseModel (val: string): ModelParseResult {
+export function parseModel(val: string): ModelParseResult {
   // Fix https://github.com/vuejs/vue/pull/7730
   // allow v-model="obj.val " (trailing whitespace)
   val = val.trim()
@@ -96,7 +93,7 @@ export function parseModel (val: string): ModelParseResult {
     /* istanbul ignore if */
     if (isStringStart(chr)) {
       parseString(chr)
-    } else if (chr === 0x5B) {
+    } else if (chr === 0x5b) {
       parseBracket(chr)
     }
   }
@@ -107,19 +104,19 @@ export function parseModel (val: string): ModelParseResult {
   }
 }
 
-function next (): number {
+function next(): number {
   return str.charCodeAt(++index)
 }
 
-function eof (): boolean {
+function eof(): boolean {
   return index >= len
 }
 
-function isStringStart (chr: number): boolean {
+function isStringStart(chr: number): boolean {
   return chr === 0x22 || chr === 0x27
 }
 
-function parseBracket (chr: number): void {
+function parseBracket(chr: number): void {
   let inBracket = 1
   expressionPos = index
   while (!eof()) {
@@ -128,8 +125,8 @@ function parseBracket (chr: number): void {
       parseString(chr)
       continue
     }
-    if (chr === 0x5B) inBracket++
-    if (chr === 0x5D) inBracket--
+    if (chr === 0x5b) inBracket++
+    if (chr === 0x5d) inBracket--
     if (inBracket === 0) {
       expressionEndPos = index
       break
@@ -137,7 +134,7 @@ function parseBracket (chr: number): void {
   }
 }
 
-function parseString (chr: number): void {
+function parseString(chr: number): void {
   const stringQuote = chr
   while (!eof()) {
     chr = next()

package/src/compiler/directives/{on.js → on.ts}

@@ -1,9 +1,8 @@
-/* @flow */
-
 import { warn } from 'core/util/index'
+import { ASTDirective, ASTElement } from 'types/compiler'
 
-export default function on (el: ASTElement, dir: ASTDirective) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+export default function on(el: ASTElement, dir: ASTDirective) {
+  if (__DEV__ && dir.modifiers) {
     warn(`v-on without argument does not support modifiers.`)
   }
   el.wrapListeners = (code: string) => `_g(${code},${dir.value})`

package/src/compiler/{error-detector.js → error-detector.ts}

@@ -1,33 +1,41 @@
-/* @flow */
-
+import { ASTElement, ASTNode } from 'types/compiler'
 import { dirRE, onRE } from './parser/index'
 
-type Range = { start?: number, end?: number };
+type Range = { start?: number; end?: number }
 
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b')
+const prohibitedKeywordRE = new RegExp(
+  '\\b' +
+    (
+      'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+      'super,throw,while,yield,delete,export,import,return,switch,default,' +
+      'extends,finally,continue,debugger,function,arguments'
+    )
+      .split(',')
+      .join('\\b|\\b') +
+    '\\b'
+)
 
 // these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)')
+const unaryOperatorsRE = new RegExp(
+  '\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)'
+)
 
 // strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
+const stripStringRE =
+  /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
 
 // detect problematic expressions in a template
-export function detectErrors (ast: ?ASTNode, warn: Function) {
+export function detectErrors(ast: ASTNode | undefined, warn: Function) {
   if (ast) {
     checkNode(ast, warn)
   }
 }
 
-function checkNode (node: ASTNode, warn: Function) {
+function checkNode(node: ASTNode, warn: Function) {
   if (node.type === 1) {
     for (const name in node.attrsMap) {
       if (dirRE.test(name)) {
@@ -37,7 +45,12 @@ function checkNode (node: ASTNode, warn: Function) {
           if (name === 'v-for') {
             checkFor(node, `v-for="${value}"`, warn, range)
           } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range)
+            checkFunctionParameterExpression(
+              value,
+              `${name}="${value}"`,
+              warn,
+              range
+            )
           } else if (onRE.test(name)) {
             checkEvent(value, `${name}="${value}"`, warn, range)
           } else {
@@ -56,28 +69,33 @@ function checkNode (node: ASTNode, warn: Function) {
   }
 }
 
-function checkEvent (exp: string, text: string, warn: Function, range?: Range) {
+function checkEvent(exp: string, text: string, warn: Function, range?: Range) {
   const stripped = exp.replace(stripStringRE, '')
   const keywordMatch: any = stripped.match(unaryOperatorsRE)
   if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
     warn(
       `avoid using JavaScript unary operator as property name: ` +
-      `"${keywordMatch[0]}" in expression ${text.trim()}`,
+        `"${keywordMatch[0]}" in expression ${text.trim()}`,
       range
     )
   }
   checkExpression(exp, text, warn, range)
 }
 
-function checkFor (node: ASTElement, text: string, warn: Function, range?: Range) {
+function checkFor(
+  node: ASTElement,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
   checkExpression(node.for || '', text, warn, range)
   checkIdentifier(node.alias, 'v-for alias', text, warn, range)
   checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range)
   checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)
 }
 
-function checkIdentifier (
-  ident: ?string,
+function checkIdentifier(
+  ident: string | null | undefined,
   type: string,
   text: string,
   warn: Function,
@@ -86,42 +104,54 @@ function checkIdentifier (
   if (typeof ident === 'string') {
     try {
       new Function(`var ${ident}=_`)
-    } catch (e) {
+    } catch (e: any) {
       warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range)
     }
   }
 }
 
-function checkExpression (exp: string, text: string, warn: Function, range?: Range) {
+function checkExpression(
+  exp: string,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
   try {
     new Function(`return ${exp}`)
-  } catch (e) {
-    const keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE)
+  } catch (e: any) {
+    const keywordMatch = exp
+      .replace(stripStringRE, '')
+      .match(prohibitedKeywordRE)
     if (keywordMatch) {
       warn(
         `avoid using JavaScript keyword as property name: ` +
-        `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`,
+          `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`,
         range
       )
     } else {
       warn(
         `invalid expression: ${e.message} in\n\n` +
-        `    ${exp}\n\n` +
-        `  Raw expression: ${text.trim()}\n`,
+          `    ${exp}\n\n` +
+          `  Raw expression: ${text.trim()}\n`,
         range
       )
     }
   }
 }
 
-function checkFunctionParameterExpression (exp: string, text: string, warn: Function, range?: Range) {
+function checkFunctionParameterExpression(
+  exp: string,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
   try {
     new Function(exp, '')
-  } catch (e) {
+  } catch (e: any) {
     warn(
       `invalid function parameter expression: ${e.message} in\n\n` +
-      `    ${exp}\n\n` +
-      `  Raw expression: ${text.trim()}\n`,
+        `    ${exp}\n\n` +
+        `  Raw expression: ${text.trim()}\n`,
       range
     )
   }

package/src/compiler/{helpers.js → helpers.ts}

@@ -1,91 +1,111 @@
-/* @flow */
-
 import { emptyObject } from 'shared/util'
+import { ASTElement, ASTModifiers } from 'types/compiler'
 import { parseFilters } from './parser/filter-parser'
 
-type Range = { start?: number, end?: number };
+type Range = { start?: number; end?: number }
 
 /* eslint-disable no-unused-vars */
-export function baseWarn (msg: string, range?: Range) {
+export function baseWarn(msg: string, range?: Range) {
   console.error(`[Vue compiler]: ${msg}`)
 }
 /* eslint-enable no-unused-vars */
 
-export function pluckModuleFunction<F: Function> (
-  modules: ?Array<Object>,
-  key: string
-): Array<F> {
-  return modules
-    ? modules.map(m => m[key]).filter(_ => _)
-    : []
+export function pluckModuleFunction<T, K extends keyof T>(
+  modules: Array<T> | undefined,
+  key: K
+): Array<T[K]> {
+  return modules ? modules.map(m => m[key]).filter(_ => _) : []
 }
 
-export function addProp (el: ASTElement, name: string, value: string, range?: Range, dynamic?: boolean) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range))
+export function addProp(
+  el: ASTElement,
+  name: string,
+  value: string,
+  range?: Range,
+  dynamic?: boolean
+) {
+  ;(el.props || (el.props = [])).push(
+    rangeSetItem({ name, value, dynamic }, range)
+  )
   el.plain = false
 }
 
-export function addAttr (el: ASTElement, name: string, value: any, range?: Range, dynamic?: boolean) {
+export function addAttr(
+  el: ASTElement,
+  name: string,
+  value: any,
+  range?: Range,
+  dynamic?: boolean
+) {
   const attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []))
+    ? el.dynamicAttrs || (el.dynamicAttrs = [])
+    : el.attrs || (el.attrs = [])
   attrs.push(rangeSetItem({ name, value, dynamic }, range))
   el.plain = false
 }
 
 // add a raw attr (use this in preTransforms)
-export function addRawAttr (el: ASTElement, name: string, value: any, range?: Range) {
+export function addRawAttr(
+  el: ASTElement,
+  name: string,
+  value: any,
+  range?: Range
+) {
   el.attrsMap[name] = value
   el.attrsList.push(rangeSetItem({ name, value }, range))
 }
 
-export function addDirective (
+export function addDirective(
   el: ASTElement,
   name: string,
   rawName: string,
   value: string,
-  arg: ?string,
-  isDynamicArg: boolean,
-  modifiers: ?ASTModifiers,
+  arg?: string,
+  isDynamicArg?: boolean,
+  modifiers?: ASTModifiers,
   range?: Range
 ) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers
-  }, range))
+  ;(el.directives || (el.directives = [])).push(
+    rangeSetItem(
+      {
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers
+      },
+      range
+    )
+  )
   el.plain = false
 }
 
-function prependModifierMarker (symbol: string, name: string, dynamic?: boolean): string {
-  return dynamic
-    ? `_p(${name},"${symbol}")`
-    : symbol + name // mark the event as captured
+function prependModifierMarker(
+  symbol: string,
+  name: string,
+  dynamic?: boolean
+): string {
+  return dynamic ? `_p(${name},"${symbol}")` : symbol + name // mark the event as captured
 }
 
-export function addHandler (
+export function addHandler(
   el: ASTElement,
   name: string,
   value: string,
-  modifiers: ?ASTModifiers,
+  modifiers?: ASTModifiers | null,
   important?: boolean,
-  warn?: ?Function,
+  warn?: Function,
   range?: Range,
   dynamic?: boolean
 ) {
   modifiers = modifiers || emptyObject
   // warn prevent and passive modifier
   /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' && warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
+  if (__DEV__ && warn && modifiers.prevent && modifiers.passive) {
     warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
+      "passive and prevent can't be used together. " +
+        "Passive handler can't prevent default event.",
       range
     )
   }
@@ -149,23 +169,21 @@ export function addHandler (
   el.plain = false
 }
 
-export function getRawBindingAttr (
-  el: ASTElement,
-  name: string
-) {
-  return el.rawAttrsMap[':' + name] ||
+export function getRawBindingAttr(el: ASTElement, name: string) {
+  return (
+    el.rawAttrsMap[':' + name] ||
     el.rawAttrsMap['v-bind:' + name] ||
     el.rawAttrsMap[name]
+  )
 }
 
-export function getBindingAttr (
+export function getBindingAttr(
   el: ASTElement,
   name: string,
   getStatic?: boolean
-): ?string {
+): string | undefined {
   const dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name)
+    getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name)
   if (dynamicValue != null) {
     return parseFilters(dynamicValue)
   } else if (getStatic !== false) {
@@ -180,11 +198,11 @@ export function getBindingAttr (
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-export function getAndRemoveAttr (
+export function getAndRemoveAttr(
   el: ASTElement,
   name: string,
   removeFromMap?: boolean
-): ?string {
+): string | undefined {
   let val
   if ((val = el.attrsMap[name]) != null) {
     const list = el.attrsList
@@ -201,10 +219,7 @@ export function getAndRemoveAttr (
   return val
 }
 
-export function getAndRemoveAttrByRegex (
-  el: ASTElement,
-  name: RegExp
-) {
+export function getAndRemoveAttrByRegex(el: ASTElement, name: RegExp) {
   const list = el.attrsList
   for (let i = 0, l = list.length; i < l; i++) {
     const attr = list[i]
@@ -215,10 +230,7 @@ export function getAndRemoveAttrByRegex (
   }
 }
 
-function rangeSetItem (
-  item: any,
-  range?: { start?: number, end?: number }
-) {
+function rangeSetItem(item: any, range?: { start?: number; end?: number }) {
   if (range) {
     if (range.start != null) {
       item.start = range.start

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

@@ -1,14 +1,13 @@
-/* @flow */
-
 import { parse } from './parser/index'
 import { optimize } from './optimizer'
 import { generate } from './codegen/index'
 import { createCompilerCreator } from './create-compiler'
+import { CompilerOptions, CompiledResult } from 'types/compiler'
 
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-export const createCompiler = createCompilerCreator(function baseCompile (
+export const createCompiler = createCompilerCreator(function baseCompile(
   template: string,
   options: CompilerOptions
 ): CompiledResult {

package/src/compiler/{optimizer.js → optimizer.ts}

@@ -1,6 +1,5 @@
-/* @flow */
-
 import { makeMap, isBuiltInTag, cached, no } from 'shared/util'
+import { ASTElement, CompilerOptions, ASTNode } from 'types/compiler'
 
 let isStaticKey
 let isPlatformReservedTag
@@ -18,7 +17,10 @@ const genStaticKeysCached = cached(genStaticKeys)
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-export function optimize (root: ?ASTElement, options: CompilerOptions) {
+export function optimize(
+  root: ASTElement | null | undefined,
+  options: CompilerOptions
+) {
   if (!root) return
   isStaticKey = genStaticKeysCached(options.staticKeys || '')
   isPlatformReservedTag = options.isReservedTag || no
@@ -28,14 +30,14 @@ export function optimize (root: ?ASTElement, options: CompilerOptions) {
   markStaticRoots(root, false)
 }
 
-function genStaticKeys (keys: string): Function {
+function genStaticKeys(keys: string): Function {
   return makeMap(
     'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
+      (keys ? ',' + keys : '')
   )
 }
 
-function markStatic (node: ASTNode) {
+function markStatic(node: ASTNode) {
   node.static = isStatic(node)
   if (node.type === 1) {
     // do not make component slot content static. this avoids
@@ -67,7 +69,7 @@ function markStatic (node: ASTNode) {
   }
 }
 
-function markStaticRoots (node: ASTNode, isInFor: boolean) {
+function markStaticRoots(node: ASTNode, isInFor: boolean) {
   if (node.type === 1) {
     if (node.static || node.once) {
       node.staticInFor = isInFor
@@ -75,10 +77,11 @@ function markStaticRoots (node: ASTNode, isInFor: boolean) {
     // For a node to qualify as a static root, it should have children that
     // are not just static text. Otherwise the cost of hoisting out will
     // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
+    if (
+      node.static &&
+      node.children.length &&
+      !(node.children.length === 1 && node.children[0].type === 3)
+    ) {
       node.staticRoot = true
       return
     } else {
@@ -97,24 +100,28 @@ function markStaticRoots (node: ASTNode, isInFor: boolean) {
   }
 }
 
-function isStatic (node: ASTNode): boolean {
-  if (node.type === 2) { // expression
+function isStatic(node: ASTNode): boolean {
+  if (node.type === 2) {
+    // expression
     return false
   }
-  if (node.type === 3) { // text
+  if (node.type === 3) {
+    // text
     return true
   }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
+  return !!(
+    node.pre ||
+    (!node.hasBindings && // no dynamic bindings
+      !node.if &&
+      !node.for && // not v-if or v-for or v-else
+      !isBuiltInTag(node.tag) && // not a built-in
+      isPlatformReservedTag(node.tag) && // not a component
+      !isDirectChildOfTemplateFor(node) &&
+      Object.keys(node).every(isStaticKey))
+  )
 }
 
-function isDirectChildOfTemplateFor (node: ASTElement): boolean {
+function isDirectChildOfTemplateFor(node: ASTElement): boolean {
   while (node.parent) {
     node = node.parent
     if (node.tag !== 'template') {

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

@@ -1,9 +1,7 @@
-/* @flow */
-
 let decoder
 
 export default {
-  decode (html: string): string {
+  decode(html: string): string {
     decoder = decoder || document.createElement('div')
     decoder.innerHTML = html
     return decoder.textContent