feat: more strictly return type locale detector (#1640)

Author: kazupon

packages/core-base/src/errors.ts

@@ -16,7 +16,10 @@ export const CoreErrorCodes = {
   INVALID_DATE_ARGUMENT: inc(), // 19
   INVALID_ISO_DATE_ARGUMENT: inc(), // 20
   NOT_SUPPORT_NON_STRING_MESSAGE: inc(), // 21
-  __EXTEND_POINT__: inc() // 22
+  NOT_SUPPORT_LOCALE_PROMISE_VALUE: inc(), // 22
+  NOT_SUPPORT_LOCALE_ASYNC_FUNCTION: inc(), // 23
+  NOT_SUPPORT_LOCALE_TYPE: inc(), // 24
+  __EXTEND_POINT__: inc() // 25
 } as const
 
 export type CoreErrorCodes =
@@ -39,5 +42,10 @@ export const errorMessages: { [code: number]: string } = {
   [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]:
     'The argument provided is not a valid ISO date string',
   [CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE]:
-    'Not support non-string message'
+    'Not support non-string message',
+  [CoreErrorCodes.NOT_SUPPORT_LOCALE_PROMISE_VALUE]:
+    'cannot support promise value',
+  [CoreErrorCodes.NOT_SUPPORT_LOCALE_ASYNC_FUNCTION]:
+    'cannot support async function',
+  [CoreErrorCodes.NOT_SUPPORT_LOCALE_TYPE]: 'cannot support locale type'
 }

packages/core-base/src/fallbacker.ts

@@ -3,9 +3,12 @@ import {
   isArray,
   isBoolean,
   isPlainObject,
-  isObject
+  isObject,
+  isPromise,
+  isFunction
 } from '@intlify/shared'
 import { DEFAULT_LOCALE } from './context'
+import { CoreErrorCodes, createCoreError } from './errors'
 
 import type { Locale, LocaleDetector, FallbackLocale } from './runtime'
 import type { CoreContext, CoreInternalContext } from './context'
@@ -33,12 +36,25 @@ let _resolveLocale: string
 
 /** @internal */
 export function resolveLocale(locale: Locale | LocaleDetector) {
-  // prettier-ignore
-  return isString(locale)
-    ? locale
-    : _resolveLocale != null && locale.resolvedOnce
-      ? _resolveLocale
-      : (_resolveLocale = locale())
+  if (isString(locale)) {
+    return locale
+  } else {
+    if (isFunction(locale)) {
+      if (locale.resolvedOnce && _resolveLocale != null) {
+        return _resolveLocale
+      } else if (locale.constructor.name === 'Function') {
+        const resolve = locale()
+        if (isPromise(resolve)) {
+          throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_PROMISE_VALUE)
+        }
+        return (_resolveLocale = resolve)
+      } else {
+        throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_ASYNC_FUNCTION)
+      }
+    } else {
+      throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_TYPE)
+    }
+  }
 }
 
 /**

packages/core-base/src/runtime.ts

@@ -27,7 +27,7 @@ export type Locale = string
 /** @VueI18nGeneral */
 // prettier-ignore
 export interface LocaleDetector<Args extends any[] = any[]> { // eslint-disable-line @typescript-eslint/no-explicit-any
-  (...args: Args): Locale
+  (...args: Args): Locale | Promise<Locale>
   resolvedOnce?: boolean
 }
 

packages/core-base/test/fallbacker.test.ts

@@ -1,5 +1,11 @@
 import { createCoreContext as context, CoreContext } from '../src/context'
-import { fallbackWithLocaleChain, fallbackWithSimple } from '../src/fallbacker'
+import {
+  fallbackWithLocaleChain,
+  fallbackWithSimple,
+  resolveLocale
+} from '../src/fallbacker'
+import { errorMessages, CoreErrorCodes } from '../src/errors'
+import { LocaleDetector } from '@intlify/core-base'
 
 describe('fallbackWithSimple', () => {
   let ctx: CoreContext<string>
@@ -283,3 +289,34 @@ describe('fallbackWithLocaleChain', () => {
     })
   })
 })
+
+describe('resolveLocale', () => {
+  test('string', () => {
+    expect(resolveLocale('en')).toEqual('en')
+  })
+
+  test('function return promise value', () => {
+    expect(() => resolveLocale(() => Promise.resolve('en'))).toThrowError(
+      errorMessages[CoreErrorCodes.NOT_SUPPORT_LOCALE_PROMISE_VALUE]
+    )
+  })
+
+  test('function return string', () => {
+    const fn = vi.fn(() => 'en')
+    expect(resolveLocale(fn)).toEqual('en')
+    expect(resolveLocale(fn)).toEqual('en')
+  })
+
+  test('async function', () => {
+    expect(() => resolveLocale(async () => Promise.resolve('en'))).toThrowError(
+      errorMessages[CoreErrorCodes.NOT_SUPPORT_LOCALE_ASYNC_FUNCTION]
+    )
+  })
+
+  test('other type value', () => {
+    const fn = 1 as unknown as LocaleDetector
+    expect(() => resolveLocale(fn)).toThrowError(
+      errorMessages[CoreErrorCodes.NOT_SUPPORT_LOCALE_TYPE]
+    )
+  })
+})

packages/vue-i18n-core/src/errors.ts

@@ -10,31 +10,31 @@ const inc = incrementer(code)
 
 export const I18nErrorCodes = {
   // composer module errors
-  UNEXPECTED_RETURN_TYPE: code, // 23
+  UNEXPECTED_RETURN_TYPE: code, // 26
   // legacy module errors
-  INVALID_ARGUMENT: inc(), // 24
+  INVALID_ARGUMENT: inc(), // 27
   // i18n module errors
-  MUST_BE_CALL_SETUP_TOP: inc(), // 25
-  NOT_INSTALLED: inc(), // 26
-  NOT_AVAILABLE_IN_LEGACY_MODE: inc(), // 27
+  MUST_BE_CALL_SETUP_TOP: inc(), // 28
+  NOT_INSTALLED: inc(), // 29
+  NOT_AVAILABLE_IN_LEGACY_MODE: inc(), // 30
   // directive module errors
-  REQUIRED_VALUE: inc(), // 28
-  INVALID_VALUE: inc(), // 29
+  REQUIRED_VALUE: inc(), // 31
+  INVALID_VALUE: inc(), // 32
   // vue-devtools errors
-  CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN: inc(), // 30
-  NOT_INSTALLED_WITH_PROVIDE: inc(), // 31
+  CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN: inc(), // 33
+  NOT_INSTALLED_WITH_PROVIDE: inc(), // 34
   // unexpected error
-  UNEXPECTED_ERROR: inc(), // 32
+  UNEXPECTED_ERROR: inc(), // 35
   // not compatible legacy vue-i18n constructor
-  NOT_COMPATIBLE_LEGACY_VUE_I18N: inc(), // 33
+  NOT_COMPATIBLE_LEGACY_VUE_I18N: inc(), // 36
   // bridge support vue 2.x only
-  BRIDGE_SUPPORT_VUE_2_ONLY: inc(), // 34
+  BRIDGE_SUPPORT_VUE_2_ONLY: inc(), // 37
   // need to define `i18n` option in `allowComposition: true` and `useScope: 'local' at `useI18n``
-  MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION: inc(), // 35
+  MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION: inc(), // 38
   // Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly
-  NOT_AVAILABLE_COMPOSITION_IN_LEGACY: inc(), // 36
+  NOT_AVAILABLE_COMPOSITION_IN_LEGACY: inc(), // 39
   // for enhancement
-  __EXTEND_POINT__: inc() // 37
+  __EXTEND_POINT__: inc() // 40
 } as const
 
 type I18nErrorCodes = (typeof I18nErrorCodes)[keyof typeof I18nErrorCodes]