1. /* @flow */
    3. export const emptyObject = Object.freeze({})
    5. // These helpers produce better VM code in JS engines due to their
    6. // explicitness and function inlining.
    7. export function isUndef (v: any): boolean %checks {
    8.   return v === undefined || v === null
    9. }
    11. export function isDef (v: any): boolean %checks {
    12.   return v !== undefined && v !== null
    13. }
    15. export function isTrue (v: any): boolean %checks {
    16.   return v === true
    17. }
    19. export function isFalse (v: any): boolean %checks {
    20.   return v === false
    21. }
    23. /**
    24.  * Check if value is primitive.
    25.  */
    26. export function isPrimitive (value: any): boolean %checks {
    27.   return (
    28.     typeof value === 'string' ||
    29.     typeof value === 'number' ||
    30.     // $flow-disable-line
    31.     typeof value === 'symbol' ||
    32.     typeof value === 'boolean'
    33.   )
    34. }
    36. /**
    37.  * Quick object check - this is primarily used to tell
    38.  * Objects from primitive values when we know the value
    39.  * is a JSON-compliant type.
    40.  */
    41. export function isObject (obj: mixed): boolean %checks {
    42.   return obj !== null && typeof obj === 'object'
    43. }
    45. /**
    46.  * Get the raw type string of a value, e.g., [object Object].
    47.  */
    48. const _toString = Object.prototype.toString
    50. export function toRawType (value: any): string {
    51.   return _toString.call(value).slice(8, -1)
    52. }
    54. /**
    55.  * Strict object type check. Only returns true
    56.  * for plain JavaScript objects.
    57.  * 严格的对象类型检查。仅对普通JavaScript对象返回true。
    58.  */
    59. export function isPlainObject (obj: any): boolean {
    60.   return _toString.call(obj) === '[object Object]'
    61. }
    63. export function isRegExp (v: any): boolean {
    64.   return _toString.call(v) === '[object RegExp]'
    65. }
    67. /**
    68.  * Check if val is a valid array index.
    69.  */
    70. export function isValidArrayIndex (val: any): boolean {
    71.   const n = parseFloat(String(val))
    72.   return n >= 0 && Math.floor(n) === n && isFinite(val)
    73. }
    75. export function isPromise (val: any): boolean {
    76.   return (
    77.     isDef(val) &&
    78.     typeof val.then === 'function' &&
    79.     typeof val.catch === 'function'
    80.   )
    81. }
    83. /**
    84.  * Convert a value to a string that is actually rendered.
    85.  */
    86. export function toString (val: any): string {
    87.   return val == null
    88.     ? ''
    89.     : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
    90.       ? JSON.stringify(val, null, 2)
    91.       : String(val)
    92. }
    94. /**
    95.  * Convert an input value to a number for persistence.
    96.  * If the conversion fails, return original string.
    97.  */
    98. export function toNumber (val: string): number | string {
    99.   const n = parseFloat(val)
    100.   return isNaN(n) ? val : n
    101. }
    103. /**
    104.  * Make a map and return a function for checking if a key
    105.  * is in that map.
    106.  */
    107. export function makeMap (
    108.   str: string,
    109.   expectsLowerCase?: boolean
    110. ): (key: string) => true | void {
    111.   const map = Object.create(null)
    112.   const list: Array<string> = str.split(',')
    113.   for (let i = 0; i < list.length; i++) {
    114.     map[list[i]] = true
    115.   }
    116.   return expectsLowerCase
    117.     ? val => map[val.toLowerCase()]
    118.     : val => map[val]
    119. }
    121. /**
    122.  * Check if a tag is a built-in tag.
    123.  */
    124. export const isBuiltInTag = makeMap('slot,component', true)
    126. /**
    127.  * Check if an attribute is a reserved attribute.
    128.  */
    129. export const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is')
    131. /**
    132.  * Remove an item from an array.
    133.  */
    134. export function remove (arr: Array<any>, item: any): Array<any> | void {
    135.   if (arr.length) {
    136.     const index = arr.indexOf(item)
    137.     if (index > -1) {
    138.       return arr.splice(index, 1)
    139.     }
    140.   }
    141. }
    143. /**
    144.  * Check whether an object has the property.
    145.  */
    146. const hasOwnProperty = Object.prototype.hasOwnProperty
    147. export function hasOwn (obj: Object | Array<*>, key: string): boolean {
    148.   return hasOwnProperty.call(obj, key)
    149. }
    151. /**
    152.  * Create a cached version of a pure function.
    153.  */
    154. export function cached<F: Function> (fn: F): F {
    155.   const cache = Object.create(null)
    156.   return (function cachedFn (str: string) {
    157.     const hit = cache[str]
    158.     return hit || (cache[str] = fn(str))
    159.   }: any)
    160. }
    162. /**
    163.  * Camelize a hyphen-delimited string.
    164.  */
    165. const camelizeRE = /-(\w)/g
    166. export const camelize = cached((str: string): string => {
    167.   return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '')
    168. })
    170. /**
    171.  * Capitalize a string.
    172.  */
    173. export const capitalize = cached((str: string): string => {
    174.   return str.charAt(0).toUpperCase() + str.slice(1)
    175. })
    177. /**
    178.  * Hyphenate a camelCase string.
    179.  */
    180. const hyphenateRE = /\B([A-Z])/g
    181. export const hyphenate = cached((str: string): string => {
    182.   return str.replace(hyphenateRE, '-$1').toLowerCase()
    183. })
    185. /**
    186.  * Simple bind polyfill for environments that do not support it,
    187.  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
    188.  * since native bind is now performant enough in most browsers.
    189.  * But removing it would mean breaking code that was able to run in
    190.  * PhantomJS 1.x, so this must be kept for backward compatibility.
    191.  */
    193. /* istanbul ignore next */
    194. function polyfillBind (fn: Function, ctx: Object): Function {
    195.   function boundFn (a) {
    196.     const l = arguments.length
    197.     return l
    198.       ? l > 1
    199.         ? fn.apply(ctx, arguments)
    200.         : fn.call(ctx, a)
    201.       : fn.call(ctx)
    202.   }
    204.   boundFn._length = fn.length
    205.   return boundFn
    206. }
    208. function nativeBind (fn: Function, ctx: Object): Function {
    209.   return fn.bind(ctx)
    210. }
    212. export const bind = Function.prototype.bind
    213.   ? nativeBind
    214.   : polyfillBind
    216. /**
    217.  * Convert an Array-like object to a real Array.
    218.  */
    219. export function toArray (list: any, start?: number): Array<any> {
    220.   start = start || 0
    221.   let i = list.length - start
    222.   const ret: Array<any> = new Array(i)
    223.   while (i--) {
    224.     ret[i] = list[i + start]
    225.   }
    226.   return ret
    227. }
    229. /**
    230.  * Mix properties into target object.
    231.  */
    232. export function extend (to: Object, _from: ?Object): Object {
    233.   for (const key in _from) {
    234.     to[key] = _from[key]
    235.   }
    236.   return to
    237. }
    239. /**
    240.  * Merge an Array of Objects into a single Object.
    241.  */
    242. export function toObject (arr: Array<any>): Object {
    243.   const res = {}
    244.   for (let i = 0; i < arr.length; i++) {
    245.     if (arr[i]) {
    246.       extend(res, arr[i])
    247.     }
    248.   }
    249.   return res
    250. }
    252. /* eslint-disable no-unused-vars */
    254. /**
    255.  * Perform no operation.
    256.  * Stubbing args to make Flow happy without leaving useless transpiled code
    257.  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    258.  */
    259. export function noop (a?: any, b?: any, c?: any) {}
    261. /**
    262.  * Always return false.
    263.  */
    264. export const no = (a?: any, b?: any, c?: any) => false
    266. /* eslint-enable no-unused-vars */
    268. /**
    269.  * Return the same value.
    270.  */
    271. export const identity = (_: any) => _
    273. /**
    274.  * Generate a string containing static keys from compiler modules.
    275.  */
    276. export function genStaticKeys (modules: Array<ModuleOptions>): string {
    277.   return modules.reduce((keys, m) => {
    278.     return keys.concat(m.staticKeys || [])
    279.   }, []).join(',')
    280. }
    282. /**
    283.  * Check if two values are loosely equal - that is,
    284.  * if they are plain objects, do they have the same shape?
    285.  */
    286. export function looseEqual (a: any, b: any): boolean {
    287.   if (a === b) return true
    288.   const isObjectA = isObject(a)
    289.   const isObjectB = isObject(b)
    290.   if (isObjectA && isObjectB) {
    291.     try {
    292.       const isArrayA = Array.isArray(a)
    293.       const isArrayB = Array.isArray(b)
    294.       if (isArrayA && isArrayB) {
    295.         return a.length === b.length && a.every((e, i) => {
    296.           return looseEqual(e, b[i])
    297.         })
    298.       } else if (a instanceof Date && b instanceof Date) {
    299.         return a.getTime() === b.getTime()
    300.       } else if (!isArrayA && !isArrayB) {
    301.         const keysA = Object.keys(a)
    302.         const keysB = Object.keys(b)
    303.         return keysA.length === keysB.length && keysA.every(key => {
    304.           return looseEqual(a[key], b[key])
    305.         })
    306.       } else {
    307.         /* istanbul ignore next */
    308.         return false
    309.       }
    310.     } catch (e) {
    311.       /* istanbul ignore next */
    312.       return false
    313.     }
    314.   } else if (!isObjectA && !isObjectB) {
    315.     return String(a) === String(b)
    316.   } else {
    317.     return false
    318.   }
    319. }
    321. /**
    322.  * Return the first index at which a loosely equal value can be
    323.  * found in the array (if value is a plain object, the array must
    324.  * contain an object of the same shape), or -1 if it is not present.
    325.  */
    326. export function looseIndexOf (arr: Array<mixed>, val: mixed): number {
    327.   for (let i = 0; i < arr.length; i++) {
    328.     if (looseEqual(arr[i], val)) return i
    329.   }
    330.   return -1
    331. }
    333. /**
    334.  * Ensure a function is called only once.
    335.  */
    336. export function once (fn: Function): Function {
    337.   let called = false
    338.   return function () {
    339.     if (!called) {
    340.       called = true
    341.       fn.apply(this, arguments)
    342.     }
    343.   }
    344. }