@intlify/core-base 11.4.7 → 11.4.9

package/dist/core-base.cjs

@@ -1,5 +1,5 @@
 /*!
-  * core-base v11.4.7
+  * core-base v11.4.9
   * (c) 2026 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -321,7 +321,7 @@ function resolveLocale(locale) {
  * @remarks
  * A fallback locale function implemented with a simple fallback algorithm.
  *
- * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ * Basically, the chain consists of `start` plus the specified fallback: for a string or array `fallbackLocale`, the value as specified in the props is used; for a map `fallbackLocale`, the map's **keys** are used and the `default` key is skipped since it is not a locale name.
  *
  * @param ctx - A {@link CoreContext | context}
  * @param fallback - A {@link FallbackLocale | fallback locale}
@@ -338,7 +338,7 @@ function fallbackWithSimple(ctx, fallback, start) {
             ...(shared.isArray(fallback)
                 ? fallback
                 : shared.isObject(fallback)
-                    ? Object.keys(fallback)
+                    ? Object.keys(fallback).filter(locale => locale !== 'default')
                     : shared.isString(fallback)
                         ? [fallback]
                         : [start])
@@ -366,29 +366,36 @@ function fallbackWithLocaleChain(ctx, fallback, start) {
     if (!context.__localeChainCache) {
         context.__localeChainCache = new Map();
     }
-    let chain = context.__localeChainCache.get(startLocale);
-    if (!chain) {
-        chain = [];
-        // first block defined by start
-        let block = [start];
-        // while any intervening block found
-        while (shared.isArray(block)) {
-            block = appendBlockToChain(chain, block, fallback);
-        }
-        // prettier-ignore
-        // last block defined by default
-        const defaults = shared.isArray(fallback) || !shared.isPlainObject(fallback)
-            ? fallback
-            : fallback['default']
-                ? fallback['default']
-                : null;
-        // convert defaults to array
-        block = shared.isString(defaults) ? [defaults] : defaults;
-        if (shared.isArray(block)) {
-            appendBlockToChain(chain, block, false);
-        }
-        context.__localeChainCache.set(startLocale, chain);
+    const fallbackKey = shared.friendlyJSONstringify(fallback);
+    let chains = context.__localeChainCache.get(startLocale);
+    if (!chains) {
+        chains = new Map();
+        context.__localeChainCache.set(startLocale, chains);
+    }
+    const cached = chains.get(fallbackKey);
+    if (cached) {
+        return cached;
     }
+    const chain = [];
+    // first block defined by start
+    let block = [start];
+    // while any intervening block found
+    while (shared.isArray(block)) {
+        block = appendBlockToChain(chain, block, fallback);
+    }
+    // prettier-ignore
+    // last block defined by default
+    const defaults = shared.isArray(fallback) || !shared.isPlainObject(fallback)
+        ? fallback
+        : fallback['default']
+            ? fallback['default']
+            : null;
+    // convert defaults to array
+    block = shared.isString(defaults) ? [defaults] : defaults;
+    if (shared.isArray(block)) {
+        appendBlockToChain(chain, block, false);
+    }
+    chains.set(fallbackKey, chain);
     return chain;
 }
 function appendBlockToChain(chain, block, blocks) {
@@ -747,7 +754,7 @@ function getWarnMessage(code, ...args) {
  * Intlify core-base version
  * @internal
  */
-const VERSION = '11.4.7';
+const VERSION = '11.4.9';
 const NOT_REOSLVED = -1;
 const DEFAULT_LOCALE = 'en-US';
 const MISSING_RESOLVE_VALUE = '';
@@ -997,6 +1004,88 @@ function isImplicitFallback(targetLocale, locales) {
 }
 /* eslint-enable @typescript-eslint/no-explicit-any */
 
+function resolveFormatLocale(context, key, locale, formats, missingWarn, fallbackWarn, type) {
+    const { fallbackLocale, localeFallbacker, onWarn } = context;
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    let from = locale;
+    for (let i = 0; i < locales.length; i++) {
+        const targetLocale = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(type === 'datetime format'
+                ? CoreWarnCodes.FALLBACK_TO_DATE_FORMAT
+                : CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit('fallback', {
+                    type,
+                    key,
+                    from,
+                    to: targetLocale,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        const format = (formats[targetLocale] || {})[key];
+        if (shared.isPlainObject(format) && shared.isString(targetLocale)) {
+            return targetLocale;
+        }
+        handleMissing(context, key, targetLocale, missingWarn, type);
+        from = targetLocale;
+    }
+    return null;
+}
+function getFormatterCacheKey(locale, key, overrides) {
+    let id = `${locale}__${key}`;
+    if (shared.isPlainObject(overrides) && !shared.isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    return id;
+}
+function clearFormatCache(formatters, locale, format) {
+    for (const key in format) {
+        const prefix = `${locale}__${key}`;
+        for (const id of formatters.keys()) {
+            if (id === prefix || id.startsWith(`${prefix}__`)) {
+                formatters.delete(id);
+            }
+        }
+    }
+}
+function parseFormatArgs(args, options, initialOverrides, optionsKeys) {
+    const [, arg2, arg3, arg4] = args;
+    let overrides = initialOverrides;
+    if (shared.isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (shared.isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (optionsKeys.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (shared.isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (shared.isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (shared.isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return overrides;
+}
+
 const intlDefined = typeof Intl !== 'undefined';
 const Availabilities = {
     dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
@@ -1005,7 +1094,7 @@ const Availabilities = {
 
 // implementation of `datetime` function
 function datetime(context, ...args) {
-    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { datetimeFormats, unresolving, onWarn } = context;
     const { __datetimeFormatters } = context;
     if (!Availabilities.dateTimeFormat) {
         onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
@@ -1028,57 +1117,16 @@ function datetime(context, ...args) {
         : context.fallbackWarn;
     const part = !!options.part;
     const locale = getLocale(context, options);
-    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
-    fallbackLocale, locale);
     if (!shared.isString(key) || key === '') {
         const formatter = new Intl.DateTimeFormat(locale.replace(/!/g, ''), overrides);
         return !part ? formatter.format(value) : formatter.formatToParts(value);
     }
-    // resolve format
-    let datetimeFormat = {};
-    let targetLocale;
-    let format = null;
-    let from = locale;
-    let to = null;
-    const type = 'datetime format';
-    for (let i = 0; i < locales.length; i++) {
-        targetLocale = to = locales[i];
-        if (locale !== targetLocale &&
-            isTranslateFallbackWarn(fallbackWarn, key)) {
-            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
-                key,
-                target: targetLocale
-            }));
-        }
-        // for vue-devtools timeline event
-        if (locale !== targetLocale) {
-            const emitter = context.__v_emitter;
-            if (emitter) {
-                emitter.emit('fallback', {
-                    type,
-                    key,
-                    from,
-                    to,
-                    groupId: `${type}:${key}`
-                });
-            }
-        }
-        datetimeFormat =
-            datetimeFormats[targetLocale] || {};
-        format = datetimeFormat[key];
-        if (shared.isPlainObject(format))
-            break;
-        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
-        from = to;
-    }
-    // checking format and target locale
-    if (!shared.isPlainObject(format) || !shared.isString(targetLocale)) {
+    const targetLocale = resolveFormatLocale(context, key, locale, datetimeFormats, missingWarn, fallbackWarn, 'datetime format');
+    if (!shared.isString(targetLocale)) {
         return unresolving ? NOT_REOSLVED : key;
     }
-    let id = `${targetLocale}__${key}`;
-    if (!shared.isEmptyObject(overrides)) {
-        id = `${id}__${JSON.stringify(overrides)}`;
-    }
+    const format = datetimeFormats[targetLocale][key];
+    const id = getFormatterCacheKey(targetLocale, key, overrides);
     let formatter = __datetimeFormatters.get(id);
     if (!formatter) {
         formatter = new Intl.DateTimeFormat(targetLocale, shared.assign({}, format, overrides));
@@ -1111,9 +1159,9 @@ const DATETIME_FORMAT_OPTIONS_KEYS = [
 ];
 /** @internal */
 function parseDateTimeArgs(...args) {
-    const [arg1, arg2, arg3, arg4] = args;
+    const [arg1] = args;
     const options = shared.create();
-    let overrides = shared.create();
+    const initialOverrides = shared.create();
     let value;
     if (shared.isString(arg1)) {
         // Only allow ISO strings - other date formats are often supported,
@@ -1150,45 +1198,18 @@ function parseDateTimeArgs(...args) {
     else {
         throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
     }
-    if (shared.isString(arg2)) {
-        options.key = arg2;
-    }
-    else if (shared.isPlainObject(arg2)) {
-        Object.keys(arg2).forEach(key => {
-            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
-                overrides[key] = arg2[key];
-            }
-            else {
-                options[key] = arg2[key];
-            }
-        });
-    }
-    if (shared.isString(arg3)) {
-        options.locale = arg3;
-    }
-    else if (shared.isPlainObject(arg3)) {
-        overrides = arg3;
-    }
-    if (shared.isPlainObject(arg4)) {
-        overrides = arg4;
-    }
+    const overrides = parseFormatArgs(args, options, initialOverrides, DATETIME_FORMAT_OPTIONS_KEYS);
     return [options.key || '', value, options, overrides];
 }
 /** @internal */
 function clearDateTimeFormat(ctx, locale, format) {
     const context = ctx;
-    for (const key in format) {
-        const id = `${locale}__${key}`;
-        if (!context.__datetimeFormatters.has(id)) {
-            continue;
-        }
-        context.__datetimeFormatters.delete(id);
-    }
+    clearFormatCache(context.__datetimeFormatters, locale, format);
 }
 
 // implementation of `number` function
 function number(context, ...args) {
-    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { numberFormats, unresolving, onWarn } = context;
     const { __numberFormatters } = context;
     if (!Availabilities.numberFormat) {
         onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
@@ -1211,57 +1232,16 @@ function number(context, ...args) {
         : context.fallbackWarn;
     const part = !!options.part;
     const locale = getLocale(context, options);
-    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
-    fallbackLocale, locale);
     if (!shared.isString(key) || key === '') {
         const formatter = new Intl.NumberFormat(locale.replace(/!/g, ''), overrides);
         return !part ? formatter.format(value) : formatter.formatToParts(value);
     }
-    // resolve format
-    let numberFormat = {};
-    let targetLocale;
-    let format = null;
-    let from = locale;
-    let to = null;
-    const type = 'number format';
-    for (let i = 0; i < locales.length; i++) {
-        targetLocale = to = locales[i];
-        if (locale !== targetLocale &&
-            isTranslateFallbackWarn(fallbackWarn, key)) {
-            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
-                key,
-                target: targetLocale
-            }));
-        }
-        // for vue-devtools timeline event
-        if (locale !== targetLocale) {
-            const emitter = context.__v_emitter;
-            if (emitter) {
-                emitter.emit('fallback', {
-                    type,
-                    key,
-                    from,
-                    to,
-                    groupId: `${type}:${key}`
-                });
-            }
-        }
-        numberFormat =
-            numberFormats[targetLocale] || {};
-        format = numberFormat[key];
-        if (shared.isPlainObject(format))
-            break;
-        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
-        from = to;
-    }
-    // checking format and target locale
-    if (!shared.isPlainObject(format) || !shared.isString(targetLocale)) {
+    const targetLocale = resolveFormatLocale(context, key, locale, numberFormats, missingWarn, fallbackWarn, 'number format');
+    if (!shared.isString(targetLocale)) {
         return unresolving ? NOT_REOSLVED : key;
     }
-    let id = `${targetLocale}__${key}`;
-    if (!shared.isEmptyObject(overrides)) {
-        id = `${id}__${JSON.stringify(overrides)}`;
-    }
+    const format = numberFormats[targetLocale][key];
+    const id = getFormatterCacheKey(targetLocale, key, overrides);
     let formatter = __numberFormatters.get(id);
     if (!formatter) {
         formatter = new Intl.NumberFormat(targetLocale, shared.assign({}, format, overrides));
@@ -1294,47 +1274,20 @@ const NUMBER_FORMAT_OPTIONS_KEYS = [
 ];
 /** @internal */
 function parseNumberArgs(...args) {
-    const [arg1, arg2, arg3, arg4] = args;
+    const [arg1] = args;
     const options = shared.create();
-    let overrides = shared.create();
+    const initialOverrides = shared.create();
     if (!shared.isNumber(arg1)) {
         throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
     }
     const value = arg1;
-    if (shared.isString(arg2)) {
-        options.key = arg2;
-    }
-    else if (shared.isPlainObject(arg2)) {
-        Object.keys(arg2).forEach(key => {
-            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
-                overrides[key] = arg2[key];
-            }
-            else {
-                options[key] = arg2[key];
-            }
-        });
-    }
-    if (shared.isString(arg3)) {
-        options.locale = arg3;
-    }
-    else if (shared.isPlainObject(arg3)) {
-        overrides = arg3;
-    }
-    if (shared.isPlainObject(arg4)) {
-        overrides = arg4;
-    }
+    const overrides = parseFormatArgs(args, options, initialOverrides, NUMBER_FORMAT_OPTIONS_KEYS);
     return [options.key || '', value, options, overrides];
 }
 /** @internal */
 function clearNumberFormat(ctx, locale, format) {
     const context = ctx;
-    for (const key in format) {
-        const id = `${locale}__${key}`;
-        if (!context.__numberFormatters.has(id)) {
-            continue;
-        }
-        context.__numberFormatters.delete(id);
-    }
+    clearFormatCache(context.__numberFormatters, locale, format);
 }
 
 const DEFAULT_MODIFIER = (str) => str;

package/dist/core-base.d.ts

@@ -71,7 +71,7 @@ export declare type CoreErrorCodes = (typeof CoreErrorCodes)[keyof typeof CoreEr
 export declare interface CoreInternalContext {
     __datetimeFormatters: Map<string, Intl.DateTimeFormat>;
     __numberFormatters: Map<string, Intl.NumberFormat>;
-    __localeChainCache?: Map<Locale, Locale[]>;
+    __localeChainCache?: Map<Locale, Map<string, Locale[]>>;
     __v_emitter?: VueDevToolsEmitter;
     __meta: MetaInfo;
 }
@@ -373,7 +373,7 @@ export declare function fallbackWithLocaleChain<Message = string>(ctx: CoreConte
  * @remarks
  * A fallback locale function implemented with a simple fallback algorithm.
  *
- * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ * Basically, the chain consists of `start` plus the specified fallback: for a string or array `fallbackLocale`, the value as specified in the props is used; for a map `fallbackLocale`, the map's **keys** are used and the `default` key is skipped since it is not a locale name.
  *
  * @param ctx - A {@link CoreContext | context}
  * @param fallback - A {@link FallbackLocale | fallback locale}