👕 refactor(flowtype): update flowtype definitions

Author: kazupon

decls/i18n.js

@@ -1,44 +1,47 @@
-declare type Dictionary<T> = { [key: string]: T }
+declare type Locale = string;
+declare type Path = string;
+declare type Message = ?string | MessageObject | MessageArray;
+declare type MessageObject = { [key: Path]: Message };
+declare type MessageArray = Array<Message>;
+declare type Messages = { [key: Locale]: MessageObject };
+declare type TranslateResult = string | Array<string>;
 
-declare type Messages = Dictionary<any>
-
-declare type MissingHandler = (locale: string, key: string, vm?: any) => void
+declare type MissingHandler = (locale: Locale, key: Path, vm?: any) => void;
 
 declare type I18nOptions = {
-  locale?: string,
-  fallbackLocale?: string,
+  locale?: Locale,
+  fallbackLocale?: Locale,
   messages?: Messages,
   formatter?: Formatter,
   missing?: MissingHandler,
   root?: I18n,
   fallbackRoot?: boolean,
   sync?: boolean
-}
+};
 
 declare interface I18n {
   static install: () => void,
   static version: string,
   get vm() :any,
-  get locale (): string,
-  set locale (locale: string): void,
-  get fallbackLocale (): string,
-  set fallbackLocale (locale: string): void,
+  get locale (): Locale,
+  set locale (locale: Locale): void,
+  get fallbackLocale (): Locale,
+  set fallbackLocale (locale: Locale): void,
   get messages (): Messages,
   set messages (messages: Messages): void,
   get missing (): ?MissingHandler,
   set missing (handler: MissingHandler): void,
   get formatter (): Formatter,
   set formatter (formatter: Formatter): void,
-  t (key: string, ...args: any): string,
-  tc (key: string, choice?: number, ...args: any): any,
-  te (key: string, ...args: any): boolean,
+  t (key: Path, ...args: any): TranslateResult,
+  tc (key: Path, choice?: number, ...args: any): TranslateResult,
+  te (key: Path, ...args: any): boolean,
   watchLocale (): any,
   unwatchLocale (): boolean
-}
+};
 
-declare type FormatterOptions = Dictionary<any>
+declare type FormatterOptions = { [key: string]: any };
 
 declare interface Formatter {
-  format (message: string, ...args: any): any
-}
-
+  format (message: string, ...args: any): string
+};

src/format.js

@@ -11,7 +11,7 @@ export default class BaseFormatter {
 
   get options (): FormatterOptions { return this._options }
 
-  format (message: string, ...args: any): any {
+  format (message: string, ...args: any): string {
     return template(message, ...args)
   }
 }

src/index.js

@@ -1,7 +1,7 @@
 /* @flow */
 
 import { install, Vue } from './install'
-import { warn, isNull, parseArgs, fetchChoice } from './util'
+import { warn, isNull, parseArgs, fetchChoice, isPlainObject } from './util'
 import BaseFormatter from './format'
 import getPathValue from './path'
 
@@ -16,13 +16,13 @@ export default class VueI18n {
   _root: ?I18n
   _sync: ?boolean
   _fallbackRoot: boolean
-  _fallbackLocale: string
+  _fallbackLocale: Locale
   _missing: ?MissingHandler
   _exist: Function
   _watcher: any
 
   constructor (options: I18nOptions = {}) {
-    const locale: string = options.locale || 'en-US'
+    const locale: Locale = options.locale || 'en-US'
     const messages: Messages = options.messages || {}
     this._vm = null
     this._fallbackLocale = options.fallbackLocale || 'en-US'
@@ -32,15 +32,15 @@ export default class VueI18n {
     this._sync = options.sync || false
     this._fallbackRoot = options.fallbackRoot || false
 
-    this._exist = (message: Object, key: string): boolean => {
+    this._exist = (message: Object, key: Path): boolean => {
       if (!message || !key) { return false }
       return !isNull(getPathValue(message, key))
     }
 
     this._resetVM({ locale, messages })
   }
 
-  _resetVM (data: { locale: string, messages: Messages }): void {
+  _resetVM (data: { locale: Locale, messages: Messages }): void {
     const silent = Vue.config.silent
     Vue.config.silent = true
     this._vm = new Vue({ data })
@@ -70,19 +70,19 @@ export default class VueI18n {
   get messages (): Messages { return this._vm.$data.messages }
   set messages (messages: Messages): void { this._vm.$set(this._vm, 'messages', messages) }
 
-  get locale (): string { return this._vm.$data.locale }
-  set locale (locale: string): void { this._vm.$set(this._vm, 'locale', locale) }
+  get locale (): Locale { return this._vm.$data.locale }
+  set locale (locale: Locale): void { this._vm.$set(this._vm, 'locale', locale) }
 
-  get fallbackLocale (): string { return this._fallbackLocale }
-  set fallbackLocale (locale: string): void { this._fallbackLocale = locale }
+  get fallbackLocale (): Locale { return this._fallbackLocale }
+  set fallbackLocale (locale: Locale): void { this._fallbackLocale = locale }
 
   get missing (): ?MissingHandler { return this._missing }
   set missing (handler: MissingHandler): void { this._missing = handler }
 
   get formatter (): Formatter { return this._formatter }
   set formatter (formatter: Formatter): void { this._formatter = formatter }
 
-  _warnDefault (locale: string, key: string, result: ?any, vm: ?any): ?string {
+  _warnDefault (locale: Locale, key: Path, result: ?any, vm: ?any): ?string {
     if (!isNull(result)) { return result }
     if (this.missing) {
       this.missing.apply(null, [locale, key, vm])
@@ -101,43 +101,57 @@ export default class VueI18n {
     return !val && !isNull(this._root) && this._fallbackRoot
   }
 
-  _interpolate (message: Messages, key: string, args: any): any {
+  _interpolate (message: MessageObject, key: Path, args: any): any {
     if (!message) { return null }
 
-    let val: PathValue = getPathValue(message, key)
-    if (Array.isArray(val)) { return val }
-    if (isNull(val)) { val = message[key] }
-    if (isNull(val)) { return null }
-    if (typeof val !== 'string') {
-      warn(`Value of key '${key}' is not a string!`)
-      return null
+    const pathRet: PathValue = getPathValue(message, key)
+    if (Array.isArray(pathRet)) { return pathRet }
+
+    let ret: mixed
+    if (isNull(pathRet)) {
+      if (isPlainObject(message)) {
+        ret = message[key]
+        if (typeof ret !== 'string') {
+          warn(`Value of key '${key}' is not a string!`)
+          return null
+        }
+      } else {
+        return null
+      }
+    } else {
+      if (typeof pathRet === 'string') {
+        ret = pathRet
+      } else {
+        warn(`Value of key '${key}' is not a string!`)
+        return null
+      }
     }
 
     // Check for the existance of links within the translated string
-    if (val.indexOf('@:') >= 0) {
+    if (ret.indexOf('@:') >= 0) {
       // Match all the links within the local
       // We are going to replace each of
       // them with its translation
-      const matches: any = val.match(/(@:[\w|.]+)/g)
+      const matches: any = ret.match(/(@:[\w|.]+)/g)
       for (const idx in matches) {
         const link = matches[idx]
         // Remove the leading @:
         const linkPlaceholder = link.substr(2)
         // Translate the link
         const translatedstring = this._interpolate(message, linkPlaceholder, args)
         // Replace the link with the translated string
-        val = val.replace(link, translatedstring)
+        ret = ret.replace(link, translatedstring)
       }
     }
 
-    return !args ? val : this._format(val, args)
+    return !args ? ret : this._format(ret, args)
   }
 
-  _format (val: any, ...args: any): any {
-    return this._formatter.format(val, ...args)
+  _format (message: string, ...args: any): string {
+    return this._formatter.format(message, ...args)
   }
 
-  _translate (messages: Messages, locale: string, fallback: string, key: string, args: any): any {
+  _translate (messages: Messages, locale: Locale, fallback: Locale, key: Path, args: any): any {
     let res: any = null
     res = this._interpolate(messages[locale], key, args)
     if (!isNull(res)) { return res }
@@ -153,11 +167,11 @@ export default class VueI18n {
     }
   }
 
-  _t (key: string, _locale: string, messages: Messages, host: any, ...args: any): any {
+  _t (key: Path, _locale: Locale, messages: Messages, host: any, ...args: any): any {
     if (!key) { return '' }
 
     const parsedArgs = parseArgs(...args)
-    const locale = parsedArgs.locale || _locale
+    const locale: Locale = parsedArgs.locale || _locale
 
     const ret: any = this._translate(messages, locale, this.fallbackLocale, key, parsedArgs.params)
     if (this._isFallbackRoot(ret)) {
@@ -171,11 +185,11 @@ export default class VueI18n {
     }
   }
 
-  t (key: string, ...args: any): string {
+  t (key: Path, ...args: any): TranslateResult {
     return this._t(key, this.locale, this.messages, null, ...args)
   }
 
-  _tc (key: string, _locale: string, messages: Messages, host: any, choice?: number, ...args: any): any {
+  _tc (key: Path, _locale: Locale, messages: Messages, host: any, choice?: number, ...args: any): any {
     if (!key) { return '' }
     if (choice !== undefined) {
       return fetchChoice(this._t(key, _locale, messages, host, ...args), choice)
@@ -184,16 +198,16 @@ export default class VueI18n {
     }
   }
 
-  tc (key: string, choice?: number, ...args: any): any {
+  tc (key: Path, choice?: number, ...args: any): TranslateResult {
     return this._tc(key, this.locale, this.messages, null, choice, ...args)
   }
 
-  _te (key: string, _locale: string, messages: Messages, ...args: any): boolean {
-    const locale = parseArgs(...args).locale || _locale
+  _te (key: Path, _locale: Locale, messages: Messages, ...args: any): boolean {
+    const locale: Locale = parseArgs(...args).locale || _locale
     return this._exist(messages[locale], key)
   }
 
-  te (key: string, ...args: any): boolean {
+  te (key: Path, ...args: any): boolean {
     return this._te(key, this.locale, this.messages, ...args)
   }
 }

src/mixin.js

@@ -5,31 +5,31 @@ import { isPlainObject, warn } from './util'
 
 export default {
   computed: {
-    $t () {
+    $t (): Function {
       if (!this.$i18n) {
         throw Error(`Failed in $t due to not find VueI18n instance`)
       }
       // add dependency tracking !!
       const locale: string = this.$i18n.locale
       const messages: Messages = this.$i18n.messages
-      return (key: string, ...args: any): string => {
+      return (key: string, ...args: any): TranslateResult => {
         return this.$i18n._t(key, locale, messages, this, ...args)
       }
     },
 
-    $tc () {
+    $tc (): Function {
       if (!this.$i18n) {
         throw Error(`Failed in $tc due to not find VueI18n instance`)
       }
       // add dependency tracking !!
       const locale: string = this.$i18n.locale
       const messages: Messages = this.$i18n.messages
-      return (key: string, choice?: number, ...args: any): string => {
+      return (key: string, choice?: number, ...args: any): TranslateResult => {
         return this.$i18n._tc(key, locale, messages, this, choice, ...args)
       }
     },
 
-    $te () {
+    $te (): Function {
       if (!this.$i18n) {
         throw Error(`Failed in $te due to not find VueI18n instance`)
       }
@@ -42,7 +42,7 @@ export default {
     }
   },
 
-  beforeCreate () {
+  beforeCreate (): void {
     const options: any = this.$options
     if (options.i18n) {
       if (options.i18n instanceof VueI18n) {
@@ -67,7 +67,7 @@ export default {
     }
   },
 
-  destroyed () {
+  destroyed (): void {
     if (this._localeWatcher) {
       this.$i18n.unwatchLocale()
       delete this._localeWatcher

src/path.js

@@ -9,7 +9,7 @@ import { isObject, isPlainObject, hasOwn } from './util'
  */
 
 // cache
-const pathCache = Object.create(null)
+const pathCache: { [key: Path]: any } = Object.create(null)
 
 // actions
 const APPEND = 0
@@ -166,7 +166,7 @@ function formatSubPath (path: string): boolean | string {
  * Parse a string path into an array of segments
  */
 
-function parse (path): ?Array<string> {
+function parse (path: Path): ?Array<string> {
   const keys: Array<string> = []
   let index: number = -1
   let mode: number = BEFORE_PATH
@@ -265,7 +265,7 @@ function parse (path): ?Array<string> {
  * External parse that check for a cache hit first
  */
 
-function parsePath (path: string): Array<string> {
+function parsePath (path: Path): Array<string> {
   let hit: ?Array<string> = pathCache[path]
   if (!hit) {
     hit = parse(path)
@@ -276,8 +276,8 @@ function parsePath (path: string): Array<string> {
   return hit || []
 }
 
-export type PathValue = | string | number | boolean | null | PathValueObject | PathValueArray
-export type PathValueObject = Dictionary<PathValue>
+export type PathValue = PathValueObject | PathValueArray | string | number | boolean | null
+export type PathValueObject = { [key: string]: PathValue }
 export type PathValueArray = Array<PathValue>
 
 function empty (target: any): boolean {
@@ -298,17 +298,17 @@ function empty (target: any): boolean {
 /**
  * Get path value from path string
  */
-export default function getPathValue (obj: Object, path: string): PathValue {
+export default function getPathValue (obj: mixed, path: Path): PathValue {
   if (!isObject(obj)) { return null }
 
   const paths: Array<string> = parsePath(path)
   if (empty(paths)) {
     return null
   } else {
-    const length = paths.length
+    const length: number = paths.length
     let ret: any = null
     let last: any = obj
-    let i = 0
+    let i: number = 0
     while (i < length) {
       const value: any = last[paths[i]]
       if (value === undefined) {

src/util.js

@@ -13,7 +13,7 @@ export function warn (msg: string, err: ?Error): void {
   }
 }
 
-const hasOwnProperty = Object.prototype.hasOwnProperty
+const hasOwnProperty: Function = Object.prototype.hasOwnProperty
 export function hasOwn (obj: Object, key: string): boolean {
   return hasOwnProperty.call(obj, key)
 }
@@ -36,8 +36,8 @@ export function isObject (obj: mixed): boolean {
   return obj !== null && typeof obj === 'object'
 }
 
-const toString = Object.prototype.toString
-const OBJECT_STRING = '[object Object]'
+const toString: Function = Object.prototype.toString
+const OBJECT_STRING: string = '[object Object]'
 export function isPlainObject (obj: any): boolean {
   return toString.call(obj) === OBJECT_STRING
 }