@intlify/core-base 11.4.6 → 11.4.8

package/dist/core-base.cjs

@@ -1,5 +1,5 @@
 /*!
-  * core-base v11.4.6
+  * core-base v11.4.8
   * (c) 2026 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -747,7 +747,7 @@ function getWarnMessage(code, ...args) {
  * Intlify core-base version
  * @internal
  */
-const VERSION = '11.4.6';
+const VERSION = '11.4.8';
 const NOT_REOSLVED = -1;
 const DEFAULT_LOCALE = 'en-US';
 const MISSING_RESOLVE_VALUE = '';
@@ -997,6 +997,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 +1087,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 +1110,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 +1152,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 +1191,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 +1225,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 +1267,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;