1173 lines
38 KiB
JavaScript
1173 lines
38 KiB
JavaScript
import { m as makeSymbol, a as assign, i as isNumber, b as isString, c as isObject, d as isArray, e as isBoolean, f as createCompileError, g as isEmptyObject, r as registerMessageCompiler, h as getGlobalThis, s as setDevToolsHook, j as isPlainObject, k as hasOwn, l as handleFlatJson, n as isRegExp, o as isFunction, p as createCoreContext, u as updateFallbackLocale, q as compileToFunction, t as resolveValue, v as clearDateTimeFormat, w as clearNumberFormat, x as setAdditionalMeta, N as NOT_REOSLVED, y as parseTranslateArgs, z as translate, M as MISSING_RESOLVE_VALUE, A as parseDateTimeArgs, B as datetime, C as parseNumberArgs, D as number, E as getLocaleChain } from "../@intlify/index.js";
|
|
import { h, Fragment, getCurrentInstance, inject, onMounted, onUnmounted, isRef, ref, computed, watch, createVNode, Text } from "vue";
|
|
/*!
|
|
* vue-i18n v9.1.10
|
|
* (c) 2022 kazuya kawaguchi
|
|
* Released under the MIT License.
|
|
*/
|
|
const VERSION = "9.1.10";
|
|
function initFeatureFlags() {
|
|
if (typeof __VUE_I18N_FULL_INSTALL__ !== "boolean") {
|
|
getGlobalThis().__VUE_I18N_FULL_INSTALL__ = true;
|
|
}
|
|
if (typeof __VUE_I18N_LEGACY_API__ !== "boolean") {
|
|
getGlobalThis().__VUE_I18N_LEGACY_API__ = true;
|
|
}
|
|
if (typeof __INTLIFY_PROD_DEVTOOLS__ !== "boolean") {
|
|
getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;
|
|
}
|
|
}
|
|
function createI18nError(code, ...args) {
|
|
return createCompileError(code, null, void 0);
|
|
}
|
|
const DEVTOOLS_META = "__INTLIFY_META__";
|
|
const TransrateVNodeSymbol = makeSymbol("__transrateVNode");
|
|
const DatetimePartsSymbol = makeSymbol("__datetimeParts");
|
|
const NumberPartsSymbol = makeSymbol("__numberParts");
|
|
makeSymbol("__enableEmitter");
|
|
makeSymbol("__disableEmitter");
|
|
const SetPluralRulesSymbol = makeSymbol("__setPluralRules");
|
|
makeSymbol("__intlifyMeta");
|
|
const InejctWithOption = makeSymbol("__injectWithOption");
|
|
let composerID = 0;
|
|
function defineCoreMissingHandler(missing) {
|
|
return (ctx, locale, key, type) => {
|
|
return missing(locale, key, getCurrentInstance() || void 0, type);
|
|
};
|
|
}
|
|
function getLocaleMessages(locale, options) {
|
|
const { messages, __i18n } = options;
|
|
const ret = isPlainObject(messages) ? messages : isArray(__i18n) ? {} : { [locale]: {} };
|
|
if (isArray(__i18n)) {
|
|
__i18n.forEach(({ locale: locale2, resource }) => {
|
|
if (locale2) {
|
|
ret[locale2] = ret[locale2] || {};
|
|
deepCopy(resource, ret[locale2]);
|
|
} else {
|
|
deepCopy(resource, ret);
|
|
}
|
|
});
|
|
}
|
|
if (options.flatJson) {
|
|
for (const key in ret) {
|
|
if (hasOwn(ret, key)) {
|
|
handleFlatJson(ret[key]);
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
const isNotObjectOrIsArray = (val) => !isObject(val) || isArray(val);
|
|
function deepCopy(src, des) {
|
|
if (isNotObjectOrIsArray(src) || isNotObjectOrIsArray(des)) {
|
|
throw createI18nError(20);
|
|
}
|
|
for (const key in src) {
|
|
if (hasOwn(src, key)) {
|
|
if (isNotObjectOrIsArray(src[key]) || isNotObjectOrIsArray(des[key])) {
|
|
des[key] = src[key];
|
|
} else {
|
|
deepCopy(src[key], des[key]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const getMetaInfo = () => {
|
|
const instance = getCurrentInstance();
|
|
return instance && instance.type[DEVTOOLS_META] ? { [DEVTOOLS_META]: instance.type[DEVTOOLS_META] } : null;
|
|
};
|
|
function createComposer(options = {}) {
|
|
const { __root } = options;
|
|
const _isGlobal = __root === void 0;
|
|
let _inheritLocale = isBoolean(options.inheritLocale) ? options.inheritLocale : true;
|
|
const _locale = ref(__root && _inheritLocale ? __root.locale.value : isString(options.locale) ? options.locale : "en-US");
|
|
const _fallbackLocale = ref(__root && _inheritLocale ? __root.fallbackLocale.value : isString(options.fallbackLocale) || isArray(options.fallbackLocale) || isPlainObject(options.fallbackLocale) || options.fallbackLocale === false ? options.fallbackLocale : _locale.value);
|
|
const _messages = ref(getLocaleMessages(_locale.value, options));
|
|
const _datetimeFormats = ref(isPlainObject(options.datetimeFormats) ? options.datetimeFormats : { [_locale.value]: {} });
|
|
const _numberFormats = ref(isPlainObject(options.numberFormats) ? options.numberFormats : { [_locale.value]: {} });
|
|
let _missingWarn = __root ? __root.missingWarn : isBoolean(options.missingWarn) || isRegExp(options.missingWarn) ? options.missingWarn : true;
|
|
let _fallbackWarn = __root ? __root.fallbackWarn : isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn) ? options.fallbackWarn : true;
|
|
let _fallbackRoot = __root ? __root.fallbackRoot : isBoolean(options.fallbackRoot) ? options.fallbackRoot : true;
|
|
let _fallbackFormat = !!options.fallbackFormat;
|
|
let _missing = isFunction(options.missing) ? options.missing : null;
|
|
let _runtimeMissing = isFunction(options.missing) ? defineCoreMissingHandler(options.missing) : null;
|
|
let _postTranslation = isFunction(options.postTranslation) ? options.postTranslation : null;
|
|
let _warnHtmlMessage = isBoolean(options.warnHtmlMessage) ? options.warnHtmlMessage : true;
|
|
let _escapeParameter = !!options.escapeParameter;
|
|
const _modifiers = __root ? __root.modifiers : isPlainObject(options.modifiers) ? options.modifiers : {};
|
|
let _pluralRules = options.pluralRules || __root && __root.pluralRules;
|
|
let _context;
|
|
function getCoreContext() {
|
|
return createCoreContext({
|
|
version: VERSION,
|
|
locale: _locale.value,
|
|
fallbackLocale: _fallbackLocale.value,
|
|
messages: _messages.value,
|
|
datetimeFormats: _datetimeFormats.value,
|
|
numberFormats: _numberFormats.value,
|
|
modifiers: _modifiers,
|
|
pluralRules: _pluralRules,
|
|
missing: _runtimeMissing === null ? void 0 : _runtimeMissing,
|
|
missingWarn: _missingWarn,
|
|
fallbackWarn: _fallbackWarn,
|
|
fallbackFormat: _fallbackFormat,
|
|
unresolving: true,
|
|
postTranslation: _postTranslation === null ? void 0 : _postTranslation,
|
|
warnHtmlMessage: _warnHtmlMessage,
|
|
escapeParameter: _escapeParameter,
|
|
__datetimeFormatters: isPlainObject(_context) ? _context.__datetimeFormatters : void 0,
|
|
__numberFormatters: isPlainObject(_context) ? _context.__numberFormatters : void 0,
|
|
__v_emitter: isPlainObject(_context) ? _context.__v_emitter : void 0,
|
|
__meta: { framework: "vue" }
|
|
});
|
|
}
|
|
_context = getCoreContext();
|
|
updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
|
|
function trackReactivityValues() {
|
|
return [
|
|
_locale.value,
|
|
_fallbackLocale.value,
|
|
_messages.value,
|
|
_datetimeFormats.value,
|
|
_numberFormats.value
|
|
];
|
|
}
|
|
const locale = computed({
|
|
get: () => _locale.value,
|
|
set: (val) => {
|
|
_locale.value = val;
|
|
_context.locale = _locale.value;
|
|
}
|
|
});
|
|
const fallbackLocale = computed({
|
|
get: () => _fallbackLocale.value,
|
|
set: (val) => {
|
|
_fallbackLocale.value = val;
|
|
_context.fallbackLocale = _fallbackLocale.value;
|
|
updateFallbackLocale(_context, _locale.value, val);
|
|
}
|
|
});
|
|
const messages = computed(() => _messages.value);
|
|
const datetimeFormats = computed(() => _datetimeFormats.value);
|
|
const numberFormats = computed(() => _numberFormats.value);
|
|
function getPostTranslationHandler() {
|
|
return isFunction(_postTranslation) ? _postTranslation : null;
|
|
}
|
|
function setPostTranslationHandler(handler) {
|
|
_postTranslation = handler;
|
|
_context.postTranslation = handler;
|
|
}
|
|
function getMissingHandler() {
|
|
return _missing;
|
|
}
|
|
function setMissingHandler(handler) {
|
|
if (handler !== null) {
|
|
_runtimeMissing = defineCoreMissingHandler(handler);
|
|
}
|
|
_missing = handler;
|
|
_context.missing = _runtimeMissing;
|
|
}
|
|
function wrapWithDeps(fn, argumentParser, warnType, fallbackSuccess, fallbackFail, successCondition) {
|
|
trackReactivityValues();
|
|
let ret;
|
|
if (__INTLIFY_PROD_DEVTOOLS__) {
|
|
try {
|
|
setAdditionalMeta(getMetaInfo());
|
|
ret = fn(_context);
|
|
} finally {
|
|
setAdditionalMeta(null);
|
|
}
|
|
} else {
|
|
ret = fn(_context);
|
|
}
|
|
if (isNumber(ret) && ret === NOT_REOSLVED) {
|
|
const [key, arg2] = argumentParser();
|
|
return __root && _fallbackRoot ? fallbackSuccess(__root) : fallbackFail(key);
|
|
} else if (successCondition(ret)) {
|
|
return ret;
|
|
} else {
|
|
throw createI18nError(14);
|
|
}
|
|
}
|
|
function t(...args) {
|
|
return wrapWithDeps((context) => translate(context, ...args), () => parseTranslateArgs(...args), "translate", (root) => root.t(...args), (key) => key, (val) => isString(val));
|
|
}
|
|
function rt(...args) {
|
|
const [arg1, arg2, arg3] = args;
|
|
if (arg3 && !isObject(arg3)) {
|
|
throw createI18nError(15);
|
|
}
|
|
return t(...[arg1, arg2, assign({ resolvedMessage: true }, arg3 || {})]);
|
|
}
|
|
function d(...args) {
|
|
return wrapWithDeps((context) => datetime(context, ...args), () => parseDateTimeArgs(...args), "datetime format", (root) => root.d(...args), () => MISSING_RESOLVE_VALUE, (val) => isString(val));
|
|
}
|
|
function n(...args) {
|
|
return wrapWithDeps((context) => number(context, ...args), () => parseNumberArgs(...args), "number format", (root) => root.n(...args), () => MISSING_RESOLVE_VALUE, (val) => isString(val));
|
|
}
|
|
function normalize(values) {
|
|
return values.map((val) => isString(val) ? createVNode(Text, null, val, 0) : val);
|
|
}
|
|
const interpolate = (val) => val;
|
|
const processor = {
|
|
normalize,
|
|
interpolate,
|
|
type: "vnode"
|
|
};
|
|
function transrateVNode(...args) {
|
|
return wrapWithDeps((context) => {
|
|
let ret;
|
|
const _context2 = context;
|
|
try {
|
|
_context2.processor = processor;
|
|
ret = translate(_context2, ...args);
|
|
} finally {
|
|
_context2.processor = null;
|
|
}
|
|
return ret;
|
|
}, () => parseTranslateArgs(...args), "translate", (root) => root[TransrateVNodeSymbol](...args), (key) => [createVNode(Text, null, key, 0)], (val) => isArray(val));
|
|
}
|
|
function numberParts(...args) {
|
|
return wrapWithDeps((context) => number(context, ...args), () => parseNumberArgs(...args), "number format", (root) => root[NumberPartsSymbol](...args), () => [], (val) => isString(val) || isArray(val));
|
|
}
|
|
function datetimeParts(...args) {
|
|
return wrapWithDeps((context) => datetime(context, ...args), () => parseDateTimeArgs(...args), "datetime format", (root) => root[DatetimePartsSymbol](...args), () => [], (val) => isString(val) || isArray(val));
|
|
}
|
|
function setPluralRules(rules) {
|
|
_pluralRules = rules;
|
|
_context.pluralRules = _pluralRules;
|
|
}
|
|
function te(key, locale2) {
|
|
const targetLocale = isString(locale2) ? locale2 : _locale.value;
|
|
const message = getLocaleMessage(targetLocale);
|
|
return resolveValue(message, key) !== null;
|
|
}
|
|
function resolveMessages(key) {
|
|
let messages2 = null;
|
|
const locales = getLocaleChain(_context, _fallbackLocale.value, _locale.value);
|
|
for (let i = 0; i < locales.length; i++) {
|
|
const targetLocaleMessages = _messages.value[locales[i]] || {};
|
|
const messageValue = resolveValue(targetLocaleMessages, key);
|
|
if (messageValue != null) {
|
|
messages2 = messageValue;
|
|
break;
|
|
}
|
|
}
|
|
return messages2;
|
|
}
|
|
function tm(key) {
|
|
const messages2 = resolveMessages(key);
|
|
return messages2 != null ? messages2 : __root ? __root.tm(key) || {} : {};
|
|
}
|
|
function getLocaleMessage(locale2) {
|
|
return _messages.value[locale2] || {};
|
|
}
|
|
function setLocaleMessage(locale2, message) {
|
|
_messages.value[locale2] = message;
|
|
_context.messages = _messages.value;
|
|
}
|
|
function mergeLocaleMessage(locale2, message) {
|
|
_messages.value[locale2] = _messages.value[locale2] || {};
|
|
deepCopy(message, _messages.value[locale2]);
|
|
_context.messages = _messages.value;
|
|
}
|
|
function getDateTimeFormat(locale2) {
|
|
return _datetimeFormats.value[locale2] || {};
|
|
}
|
|
function setDateTimeFormat(locale2, format) {
|
|
_datetimeFormats.value[locale2] = format;
|
|
_context.datetimeFormats = _datetimeFormats.value;
|
|
clearDateTimeFormat(_context, locale2, format);
|
|
}
|
|
function mergeDateTimeFormat(locale2, format) {
|
|
_datetimeFormats.value[locale2] = assign(_datetimeFormats.value[locale2] || {}, format);
|
|
_context.datetimeFormats = _datetimeFormats.value;
|
|
clearDateTimeFormat(_context, locale2, format);
|
|
}
|
|
function getNumberFormat(locale2) {
|
|
return _numberFormats.value[locale2] || {};
|
|
}
|
|
function setNumberFormat(locale2, format) {
|
|
_numberFormats.value[locale2] = format;
|
|
_context.numberFormats = _numberFormats.value;
|
|
clearNumberFormat(_context, locale2, format);
|
|
}
|
|
function mergeNumberFormat(locale2, format) {
|
|
_numberFormats.value[locale2] = assign(_numberFormats.value[locale2] || {}, format);
|
|
_context.numberFormats = _numberFormats.value;
|
|
clearNumberFormat(_context, locale2, format);
|
|
}
|
|
composerID++;
|
|
if (__root) {
|
|
watch(__root.locale, (val) => {
|
|
if (_inheritLocale) {
|
|
_locale.value = val;
|
|
_context.locale = val;
|
|
updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
|
|
}
|
|
});
|
|
watch(__root.fallbackLocale, (val) => {
|
|
if (_inheritLocale) {
|
|
_fallbackLocale.value = val;
|
|
_context.fallbackLocale = val;
|
|
updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
|
|
}
|
|
});
|
|
}
|
|
const composer = {
|
|
id: composerID,
|
|
locale,
|
|
fallbackLocale,
|
|
get inheritLocale() {
|
|
return _inheritLocale;
|
|
},
|
|
set inheritLocale(val) {
|
|
_inheritLocale = val;
|
|
if (val && __root) {
|
|
_locale.value = __root.locale.value;
|
|
_fallbackLocale.value = __root.fallbackLocale.value;
|
|
updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
|
|
}
|
|
},
|
|
get availableLocales() {
|
|
return Object.keys(_messages.value).sort();
|
|
},
|
|
messages,
|
|
datetimeFormats,
|
|
numberFormats,
|
|
get modifiers() {
|
|
return _modifiers;
|
|
},
|
|
get pluralRules() {
|
|
return _pluralRules || {};
|
|
},
|
|
get isGlobal() {
|
|
return _isGlobal;
|
|
},
|
|
get missingWarn() {
|
|
return _missingWarn;
|
|
},
|
|
set missingWarn(val) {
|
|
_missingWarn = val;
|
|
_context.missingWarn = _missingWarn;
|
|
},
|
|
get fallbackWarn() {
|
|
return _fallbackWarn;
|
|
},
|
|
set fallbackWarn(val) {
|
|
_fallbackWarn = val;
|
|
_context.fallbackWarn = _fallbackWarn;
|
|
},
|
|
get fallbackRoot() {
|
|
return _fallbackRoot;
|
|
},
|
|
set fallbackRoot(val) {
|
|
_fallbackRoot = val;
|
|
},
|
|
get fallbackFormat() {
|
|
return _fallbackFormat;
|
|
},
|
|
set fallbackFormat(val) {
|
|
_fallbackFormat = val;
|
|
_context.fallbackFormat = _fallbackFormat;
|
|
},
|
|
get warnHtmlMessage() {
|
|
return _warnHtmlMessage;
|
|
},
|
|
set warnHtmlMessage(val) {
|
|
_warnHtmlMessage = val;
|
|
_context.warnHtmlMessage = val;
|
|
},
|
|
get escapeParameter() {
|
|
return _escapeParameter;
|
|
},
|
|
set escapeParameter(val) {
|
|
_escapeParameter = val;
|
|
_context.escapeParameter = val;
|
|
},
|
|
t,
|
|
rt,
|
|
d,
|
|
n,
|
|
te,
|
|
tm,
|
|
getLocaleMessage,
|
|
setLocaleMessage,
|
|
mergeLocaleMessage,
|
|
getDateTimeFormat,
|
|
setDateTimeFormat,
|
|
mergeDateTimeFormat,
|
|
getNumberFormat,
|
|
setNumberFormat,
|
|
mergeNumberFormat,
|
|
getPostTranslationHandler,
|
|
setPostTranslationHandler,
|
|
getMissingHandler,
|
|
setMissingHandler,
|
|
[TransrateVNodeSymbol]: transrateVNode,
|
|
[NumberPartsSymbol]: numberParts,
|
|
[DatetimePartsSymbol]: datetimeParts,
|
|
[SetPluralRulesSymbol]: setPluralRules,
|
|
[InejctWithOption]: options.__injectWithOption
|
|
};
|
|
return composer;
|
|
}
|
|
function convertComposerOptions(options) {
|
|
const locale = isString(options.locale) ? options.locale : "en-US";
|
|
const fallbackLocale = isString(options.fallbackLocale) || isArray(options.fallbackLocale) || isPlainObject(options.fallbackLocale) || options.fallbackLocale === false ? options.fallbackLocale : locale;
|
|
const missing = isFunction(options.missing) ? options.missing : void 0;
|
|
const missingWarn = isBoolean(options.silentTranslationWarn) || isRegExp(options.silentTranslationWarn) ? !options.silentTranslationWarn : true;
|
|
const fallbackWarn = isBoolean(options.silentFallbackWarn) || isRegExp(options.silentFallbackWarn) ? !options.silentFallbackWarn : true;
|
|
const fallbackRoot = isBoolean(options.fallbackRoot) ? options.fallbackRoot : true;
|
|
const fallbackFormat = !!options.formatFallbackMessages;
|
|
const modifiers = isPlainObject(options.modifiers) ? options.modifiers : {};
|
|
const pluralizationRules = options.pluralizationRules;
|
|
const postTranslation = isFunction(options.postTranslation) ? options.postTranslation : void 0;
|
|
const warnHtmlMessage = isString(options.warnHtmlInMessage) ? options.warnHtmlInMessage !== "off" : true;
|
|
const escapeParameter = !!options.escapeParameterHtml;
|
|
const inheritLocale = isBoolean(options.sync) ? options.sync : true;
|
|
let messages = options.messages;
|
|
if (isPlainObject(options.sharedMessages)) {
|
|
const sharedMessages = options.sharedMessages;
|
|
const locales = Object.keys(sharedMessages);
|
|
messages = locales.reduce((messages2, locale2) => {
|
|
const message = messages2[locale2] || (messages2[locale2] = {});
|
|
assign(message, sharedMessages[locale2]);
|
|
return messages2;
|
|
}, messages || {});
|
|
}
|
|
const { __i18n, __root, __injectWithOption } = options;
|
|
const datetimeFormats = options.datetimeFormats;
|
|
const numberFormats = options.numberFormats;
|
|
const flatJson = options.flatJson;
|
|
return {
|
|
locale,
|
|
fallbackLocale,
|
|
messages,
|
|
flatJson,
|
|
datetimeFormats,
|
|
numberFormats,
|
|
missing,
|
|
missingWarn,
|
|
fallbackWarn,
|
|
fallbackRoot,
|
|
fallbackFormat,
|
|
modifiers,
|
|
pluralRules: pluralizationRules,
|
|
postTranslation,
|
|
warnHtmlMessage,
|
|
escapeParameter,
|
|
inheritLocale,
|
|
__i18n,
|
|
__root,
|
|
__injectWithOption
|
|
};
|
|
}
|
|
function createVueI18n(options = {}) {
|
|
const composer = createComposer(convertComposerOptions(options));
|
|
const vueI18n = {
|
|
id: composer.id,
|
|
get locale() {
|
|
return composer.locale.value;
|
|
},
|
|
set locale(val) {
|
|
composer.locale.value = val;
|
|
},
|
|
get fallbackLocale() {
|
|
return composer.fallbackLocale.value;
|
|
},
|
|
set fallbackLocale(val) {
|
|
composer.fallbackLocale.value = val;
|
|
},
|
|
get messages() {
|
|
return composer.messages.value;
|
|
},
|
|
get datetimeFormats() {
|
|
return composer.datetimeFormats.value;
|
|
},
|
|
get numberFormats() {
|
|
return composer.numberFormats.value;
|
|
},
|
|
get availableLocales() {
|
|
return composer.availableLocales;
|
|
},
|
|
get formatter() {
|
|
return {
|
|
interpolate() {
|
|
return [];
|
|
}
|
|
};
|
|
},
|
|
set formatter(val) {
|
|
},
|
|
get missing() {
|
|
return composer.getMissingHandler();
|
|
},
|
|
set missing(handler) {
|
|
composer.setMissingHandler(handler);
|
|
},
|
|
get silentTranslationWarn() {
|
|
return isBoolean(composer.missingWarn) ? !composer.missingWarn : composer.missingWarn;
|
|
},
|
|
set silentTranslationWarn(val) {
|
|
composer.missingWarn = isBoolean(val) ? !val : val;
|
|
},
|
|
get silentFallbackWarn() {
|
|
return isBoolean(composer.fallbackWarn) ? !composer.fallbackWarn : composer.fallbackWarn;
|
|
},
|
|
set silentFallbackWarn(val) {
|
|
composer.fallbackWarn = isBoolean(val) ? !val : val;
|
|
},
|
|
get modifiers() {
|
|
return composer.modifiers;
|
|
},
|
|
get formatFallbackMessages() {
|
|
return composer.fallbackFormat;
|
|
},
|
|
set formatFallbackMessages(val) {
|
|
composer.fallbackFormat = val;
|
|
},
|
|
get postTranslation() {
|
|
return composer.getPostTranslationHandler();
|
|
},
|
|
set postTranslation(handler) {
|
|
composer.setPostTranslationHandler(handler);
|
|
},
|
|
get sync() {
|
|
return composer.inheritLocale;
|
|
},
|
|
set sync(val) {
|
|
composer.inheritLocale = val;
|
|
},
|
|
get warnHtmlInMessage() {
|
|
return composer.warnHtmlMessage ? "warn" : "off";
|
|
},
|
|
set warnHtmlInMessage(val) {
|
|
composer.warnHtmlMessage = val !== "off";
|
|
},
|
|
get escapeParameterHtml() {
|
|
return composer.escapeParameter;
|
|
},
|
|
set escapeParameterHtml(val) {
|
|
composer.escapeParameter = val;
|
|
},
|
|
get preserveDirectiveContent() {
|
|
return true;
|
|
},
|
|
set preserveDirectiveContent(val) {
|
|
},
|
|
get pluralizationRules() {
|
|
return composer.pluralRules || {};
|
|
},
|
|
__composer: composer,
|
|
t(...args) {
|
|
const [arg1, arg2, arg3] = args;
|
|
const options2 = {};
|
|
let list = null;
|
|
let named = null;
|
|
if (!isString(arg1)) {
|
|
throw createI18nError(15);
|
|
}
|
|
const key = arg1;
|
|
if (isString(arg2)) {
|
|
options2.locale = arg2;
|
|
} else if (isArray(arg2)) {
|
|
list = arg2;
|
|
} else if (isPlainObject(arg2)) {
|
|
named = arg2;
|
|
}
|
|
if (isArray(arg3)) {
|
|
list = arg3;
|
|
} else if (isPlainObject(arg3)) {
|
|
named = arg3;
|
|
}
|
|
return composer.t(key, list || named || {}, options2);
|
|
},
|
|
rt(...args) {
|
|
return composer.rt(...args);
|
|
},
|
|
tc(...args) {
|
|
const [arg1, arg2, arg3] = args;
|
|
const options2 = { plural: 1 };
|
|
let list = null;
|
|
let named = null;
|
|
if (!isString(arg1)) {
|
|
throw createI18nError(15);
|
|
}
|
|
const key = arg1;
|
|
if (isString(arg2)) {
|
|
options2.locale = arg2;
|
|
} else if (isNumber(arg2)) {
|
|
options2.plural = arg2;
|
|
} else if (isArray(arg2)) {
|
|
list = arg2;
|
|
} else if (isPlainObject(arg2)) {
|
|
named = arg2;
|
|
}
|
|
if (isString(arg3)) {
|
|
options2.locale = arg3;
|
|
} else if (isArray(arg3)) {
|
|
list = arg3;
|
|
} else if (isPlainObject(arg3)) {
|
|
named = arg3;
|
|
}
|
|
return composer.t(key, list || named || {}, options2);
|
|
},
|
|
te(key, locale) {
|
|
return composer.te(key, locale);
|
|
},
|
|
tm(key) {
|
|
return composer.tm(key);
|
|
},
|
|
getLocaleMessage(locale) {
|
|
return composer.getLocaleMessage(locale);
|
|
},
|
|
setLocaleMessage(locale, message) {
|
|
composer.setLocaleMessage(locale, message);
|
|
},
|
|
mergeLocaleMessage(locale, message) {
|
|
composer.mergeLocaleMessage(locale, message);
|
|
},
|
|
d(...args) {
|
|
return composer.d(...args);
|
|
},
|
|
getDateTimeFormat(locale) {
|
|
return composer.getDateTimeFormat(locale);
|
|
},
|
|
setDateTimeFormat(locale, format) {
|
|
composer.setDateTimeFormat(locale, format);
|
|
},
|
|
mergeDateTimeFormat(locale, format) {
|
|
composer.mergeDateTimeFormat(locale, format);
|
|
},
|
|
n(...args) {
|
|
return composer.n(...args);
|
|
},
|
|
getNumberFormat(locale) {
|
|
return composer.getNumberFormat(locale);
|
|
},
|
|
setNumberFormat(locale, format) {
|
|
composer.setNumberFormat(locale, format);
|
|
},
|
|
mergeNumberFormat(locale, format) {
|
|
composer.mergeNumberFormat(locale, format);
|
|
},
|
|
getChoiceIndex(choice, choicesLength) {
|
|
return -1;
|
|
},
|
|
__onComponentInstanceCreated(target) {
|
|
const { componentInstanceCreatedListener } = options;
|
|
if (componentInstanceCreatedListener) {
|
|
componentInstanceCreatedListener(target, vueI18n);
|
|
}
|
|
}
|
|
};
|
|
return vueI18n;
|
|
}
|
|
const baseFormatProps = {
|
|
tag: {
|
|
type: [String, Object]
|
|
},
|
|
locale: {
|
|
type: String
|
|
},
|
|
scope: {
|
|
type: String,
|
|
validator: (val) => val === "parent" || val === "global",
|
|
default: "parent"
|
|
},
|
|
i18n: {
|
|
type: Object
|
|
}
|
|
};
|
|
const Translation = {
|
|
name: "i18n-t",
|
|
props: assign({
|
|
keypath: {
|
|
type: String,
|
|
required: true
|
|
},
|
|
plural: {
|
|
type: [Number, String],
|
|
validator: (val) => isNumber(val) || !isNaN(val)
|
|
}
|
|
}, baseFormatProps),
|
|
setup(props, context) {
|
|
const { slots, attrs } = context;
|
|
const i18n = props.i18n || useI18n({
|
|
useScope: props.scope,
|
|
__useComponent: true
|
|
});
|
|
const keys = Object.keys(slots).filter((key) => key !== "_");
|
|
return () => {
|
|
const options = {};
|
|
if (props.locale) {
|
|
options.locale = props.locale;
|
|
}
|
|
if (props.plural !== void 0) {
|
|
options.plural = isString(props.plural) ? +props.plural : props.plural;
|
|
}
|
|
const arg = getInterpolateArg(context, keys);
|
|
const children = i18n[TransrateVNodeSymbol](props.keypath, arg, options);
|
|
const assignedAttrs = assign({}, attrs);
|
|
return isString(props.tag) ? h(props.tag, assignedAttrs, children) : isObject(props.tag) ? h(props.tag, assignedAttrs, children) : h(Fragment, assignedAttrs, children);
|
|
};
|
|
}
|
|
};
|
|
function getInterpolateArg({ slots }, keys) {
|
|
if (keys.length === 1 && keys[0] === "default") {
|
|
return slots.default ? slots.default() : [];
|
|
} else {
|
|
return keys.reduce((arg, key) => {
|
|
const slot = slots[key];
|
|
if (slot) {
|
|
arg[key] = slot();
|
|
}
|
|
return arg;
|
|
}, {});
|
|
}
|
|
}
|
|
function renderFormatter(props, context, slotKeys, partFormatter) {
|
|
const { slots, attrs } = context;
|
|
return () => {
|
|
const options = { part: true };
|
|
let overrides = {};
|
|
if (props.locale) {
|
|
options.locale = props.locale;
|
|
}
|
|
if (isString(props.format)) {
|
|
options.key = props.format;
|
|
} else if (isObject(props.format)) {
|
|
if (isString(props.format.key)) {
|
|
options.key = props.format.key;
|
|
}
|
|
overrides = Object.keys(props.format).reduce((options2, prop) => {
|
|
return slotKeys.includes(prop) ? assign({}, options2, { [prop]: props.format[prop] }) : options2;
|
|
}, {});
|
|
}
|
|
const parts = partFormatter(...[props.value, options, overrides]);
|
|
let children = [options.key];
|
|
if (isArray(parts)) {
|
|
children = parts.map((part, index) => {
|
|
const slot = slots[part.type];
|
|
return slot ? slot({ [part.type]: part.value, index, parts }) : [part.value];
|
|
});
|
|
} else if (isString(parts)) {
|
|
children = [parts];
|
|
}
|
|
const assignedAttrs = assign({}, attrs);
|
|
return isString(props.tag) ? h(props.tag, assignedAttrs, children) : isObject(props.tag) ? h(props.tag, assignedAttrs, children) : h(Fragment, assignedAttrs, children);
|
|
};
|
|
}
|
|
const NUMBER_FORMAT_KEYS = [
|
|
"localeMatcher",
|
|
"style",
|
|
"unit",
|
|
"unitDisplay",
|
|
"currency",
|
|
"currencyDisplay",
|
|
"useGrouping",
|
|
"numberingSystem",
|
|
"minimumIntegerDigits",
|
|
"minimumFractionDigits",
|
|
"maximumFractionDigits",
|
|
"minimumSignificantDigits",
|
|
"maximumSignificantDigits",
|
|
"notation",
|
|
"formatMatcher"
|
|
];
|
|
const NumberFormat = {
|
|
name: "i18n-n",
|
|
props: assign({
|
|
value: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
format: {
|
|
type: [String, Object]
|
|
}
|
|
}, baseFormatProps),
|
|
setup(props, context) {
|
|
const i18n = props.i18n || useI18n({ useScope: "parent", __useComponent: true });
|
|
return renderFormatter(props, context, NUMBER_FORMAT_KEYS, (...args) => i18n[NumberPartsSymbol](...args));
|
|
}
|
|
};
|
|
const DATETIME_FORMAT_KEYS = [
|
|
"dateStyle",
|
|
"timeStyle",
|
|
"fractionalSecondDigits",
|
|
"calendar",
|
|
"dayPeriod",
|
|
"numberingSystem",
|
|
"localeMatcher",
|
|
"timeZone",
|
|
"hour12",
|
|
"hourCycle",
|
|
"formatMatcher",
|
|
"weekday",
|
|
"era",
|
|
"year",
|
|
"month",
|
|
"day",
|
|
"hour",
|
|
"minute",
|
|
"second",
|
|
"timeZoneName"
|
|
];
|
|
const DatetimeFormat = {
|
|
name: "i18n-d",
|
|
props: assign({
|
|
value: {
|
|
type: [Number, Date],
|
|
required: true
|
|
},
|
|
format: {
|
|
type: [String, Object]
|
|
}
|
|
}, baseFormatProps),
|
|
setup(props, context) {
|
|
const i18n = props.i18n || useI18n({ useScope: "parent", __useComponent: true });
|
|
return renderFormatter(props, context, DATETIME_FORMAT_KEYS, (...args) => i18n[DatetimePartsSymbol](...args));
|
|
}
|
|
};
|
|
function getComposer$2(i18n, instance) {
|
|
const i18nInternal = i18n;
|
|
if (i18n.mode === "composition") {
|
|
return i18nInternal.__getInstance(instance) || i18n.global;
|
|
} else {
|
|
const vueI18n = i18nInternal.__getInstance(instance);
|
|
return vueI18n != null ? vueI18n.__composer : i18n.global.__composer;
|
|
}
|
|
}
|
|
function vTDirective(i18n) {
|
|
const bind = (el, { instance, value, modifiers }) => {
|
|
if (!instance || !instance.$) {
|
|
throw createI18nError(22);
|
|
}
|
|
const composer = getComposer$2(i18n, instance.$);
|
|
const parsedValue = parseValue(value);
|
|
el.textContent = composer.t(...makeParams(parsedValue));
|
|
};
|
|
return {
|
|
beforeMount: bind,
|
|
beforeUpdate: bind
|
|
};
|
|
}
|
|
function parseValue(value) {
|
|
if (isString(value)) {
|
|
return { path: value };
|
|
} else if (isPlainObject(value)) {
|
|
if (!("path" in value)) {
|
|
throw createI18nError(19, "path");
|
|
}
|
|
return value;
|
|
} else {
|
|
throw createI18nError(20);
|
|
}
|
|
}
|
|
function makeParams(value) {
|
|
const { path, locale, args, choice, plural } = value;
|
|
const options = {};
|
|
const named = args || {};
|
|
if (isString(locale)) {
|
|
options.locale = locale;
|
|
}
|
|
if (isNumber(choice)) {
|
|
options.plural = choice;
|
|
}
|
|
if (isNumber(plural)) {
|
|
options.plural = plural;
|
|
}
|
|
return [path, named, options];
|
|
}
|
|
function apply(app, i18n, ...options) {
|
|
const pluginOptions = isPlainObject(options[0]) ? options[0] : {};
|
|
const useI18nComponentName = !!pluginOptions.useI18nComponentName;
|
|
const globalInstall = isBoolean(pluginOptions.globalInstall) ? pluginOptions.globalInstall : true;
|
|
if (globalInstall) {
|
|
app.component(!useI18nComponentName ? Translation.name : "i18n", Translation);
|
|
app.component(NumberFormat.name, NumberFormat);
|
|
app.component(DatetimeFormat.name, DatetimeFormat);
|
|
}
|
|
app.directive("t", vTDirective(i18n));
|
|
}
|
|
function defineMixin(vuei18n, composer, i18n) {
|
|
return {
|
|
beforeCreate() {
|
|
const instance = getCurrentInstance();
|
|
if (!instance) {
|
|
throw createI18nError(22);
|
|
}
|
|
const options = this.$options;
|
|
if (options.i18n) {
|
|
const optionsI18n = options.i18n;
|
|
if (options.__i18n) {
|
|
optionsI18n.__i18n = options.__i18n;
|
|
}
|
|
optionsI18n.__root = composer;
|
|
if (this === this.$root) {
|
|
this.$i18n = mergeToRoot(vuei18n, optionsI18n);
|
|
} else {
|
|
optionsI18n.__injectWithOption = true;
|
|
this.$i18n = createVueI18n(optionsI18n);
|
|
}
|
|
} else if (options.__i18n) {
|
|
if (this === this.$root) {
|
|
this.$i18n = mergeToRoot(vuei18n, options);
|
|
} else {
|
|
this.$i18n = createVueI18n({
|
|
__i18n: options.__i18n,
|
|
__injectWithOption: true,
|
|
__root: composer
|
|
});
|
|
}
|
|
} else {
|
|
this.$i18n = vuei18n;
|
|
}
|
|
vuei18n.__onComponentInstanceCreated(this.$i18n);
|
|
i18n.__setInstance(instance, this.$i18n);
|
|
this.$t = (...args) => this.$i18n.t(...args);
|
|
this.$rt = (...args) => this.$i18n.rt(...args);
|
|
this.$tc = (...args) => this.$i18n.tc(...args);
|
|
this.$te = (key, locale) => this.$i18n.te(key, locale);
|
|
this.$d = (...args) => this.$i18n.d(...args);
|
|
this.$n = (...args) => this.$i18n.n(...args);
|
|
this.$tm = (key) => this.$i18n.tm(key);
|
|
},
|
|
mounted() {
|
|
},
|
|
beforeUnmount() {
|
|
const instance = getCurrentInstance();
|
|
if (!instance) {
|
|
throw createI18nError(22);
|
|
}
|
|
delete this.$t;
|
|
delete this.$rt;
|
|
delete this.$tc;
|
|
delete this.$te;
|
|
delete this.$d;
|
|
delete this.$n;
|
|
delete this.$tm;
|
|
i18n.__deleteInstance(instance);
|
|
delete this.$i18n;
|
|
}
|
|
};
|
|
}
|
|
function mergeToRoot(root, options) {
|
|
root.locale = options.locale || root.locale;
|
|
root.fallbackLocale = options.fallbackLocale || root.fallbackLocale;
|
|
root.missing = options.missing || root.missing;
|
|
root.silentTranslationWarn = options.silentTranslationWarn || root.silentFallbackWarn;
|
|
root.silentFallbackWarn = options.silentFallbackWarn || root.silentFallbackWarn;
|
|
root.formatFallbackMessages = options.formatFallbackMessages || root.formatFallbackMessages;
|
|
root.postTranslation = options.postTranslation || root.postTranslation;
|
|
root.warnHtmlInMessage = options.warnHtmlInMessage || root.warnHtmlInMessage;
|
|
root.escapeParameterHtml = options.escapeParameterHtml || root.escapeParameterHtml;
|
|
root.sync = options.sync || root.sync;
|
|
root.__composer[SetPluralRulesSymbol](options.pluralizationRules || root.pluralizationRules);
|
|
const messages = getLocaleMessages(root.locale, {
|
|
messages: options.messages,
|
|
__i18n: options.__i18n
|
|
});
|
|
Object.keys(messages).forEach((locale) => root.mergeLocaleMessage(locale, messages[locale]));
|
|
if (options.datetimeFormats) {
|
|
Object.keys(options.datetimeFormats).forEach((locale) => root.mergeDateTimeFormat(locale, options.datetimeFormats[locale]));
|
|
}
|
|
if (options.numberFormats) {
|
|
Object.keys(options.numberFormats).forEach((locale) => root.mergeNumberFormat(locale, options.numberFormats[locale]));
|
|
}
|
|
return root;
|
|
}
|
|
function createI18n(options = {}) {
|
|
const __legacyMode = __VUE_I18N_LEGACY_API__ && isBoolean(options.legacy) ? options.legacy : __VUE_I18N_LEGACY_API__;
|
|
const __globalInjection = !!options.globalInjection;
|
|
const __instances = /* @__PURE__ */ new Map();
|
|
const __global = __VUE_I18N_LEGACY_API__ && __legacyMode ? createVueI18n(options) : createComposer(options);
|
|
const symbol = makeSymbol("");
|
|
const i18n = {
|
|
get mode() {
|
|
return __VUE_I18N_LEGACY_API__ ? __legacyMode ? "legacy" : "composition" : "composition";
|
|
},
|
|
async install(app, ...options2) {
|
|
app.__VUE_I18N_SYMBOL__ = symbol;
|
|
app.provide(app.__VUE_I18N_SYMBOL__, i18n);
|
|
if (!__legacyMode && __globalInjection) {
|
|
injectGlobalFields(app, i18n.global);
|
|
}
|
|
if (__VUE_I18N_FULL_INSTALL__) {
|
|
apply(app, i18n, ...options2);
|
|
}
|
|
if (__VUE_I18N_LEGACY_API__ && __legacyMode) {
|
|
app.mixin(defineMixin(__global, __global.__composer, i18n));
|
|
}
|
|
},
|
|
get global() {
|
|
return __global;
|
|
},
|
|
__instances,
|
|
__getInstance(component) {
|
|
return __instances.get(component) || null;
|
|
},
|
|
__setInstance(component, instance) {
|
|
__instances.set(component, instance);
|
|
},
|
|
__deleteInstance(component) {
|
|
__instances.delete(component);
|
|
}
|
|
};
|
|
return i18n;
|
|
}
|
|
function useI18n(options = {}) {
|
|
const instance = getCurrentInstance();
|
|
if (instance == null) {
|
|
throw createI18nError(16);
|
|
}
|
|
if (!instance.appContext.app.__VUE_I18N_SYMBOL__) {
|
|
throw createI18nError(17);
|
|
}
|
|
const i18n = inject(instance.appContext.app.__VUE_I18N_SYMBOL__);
|
|
if (!i18n) {
|
|
throw createI18nError(22);
|
|
}
|
|
const global = i18n.mode === "composition" ? i18n.global : i18n.global.__composer;
|
|
const scope = isEmptyObject(options) ? "__i18n" in instance.type ? "local" : "global" : !options.useScope ? "local" : options.useScope;
|
|
if (scope === "global") {
|
|
let messages = isObject(options.messages) ? options.messages : {};
|
|
if ("__i18nGlobal" in instance.type) {
|
|
messages = getLocaleMessages(global.locale.value, {
|
|
messages,
|
|
__i18n: instance.type.__i18nGlobal
|
|
});
|
|
}
|
|
const locales = Object.keys(messages);
|
|
if (locales.length) {
|
|
locales.forEach((locale) => {
|
|
global.mergeLocaleMessage(locale, messages[locale]);
|
|
});
|
|
}
|
|
if (isObject(options.datetimeFormats)) {
|
|
const locales2 = Object.keys(options.datetimeFormats);
|
|
if (locales2.length) {
|
|
locales2.forEach((locale) => {
|
|
global.mergeDateTimeFormat(locale, options.datetimeFormats[locale]);
|
|
});
|
|
}
|
|
}
|
|
if (isObject(options.numberFormats)) {
|
|
const locales2 = Object.keys(options.numberFormats);
|
|
if (locales2.length) {
|
|
locales2.forEach((locale) => {
|
|
global.mergeNumberFormat(locale, options.numberFormats[locale]);
|
|
});
|
|
}
|
|
}
|
|
return global;
|
|
}
|
|
if (scope === "parent") {
|
|
let composer2 = getComposer(i18n, instance, options.__useComponent);
|
|
if (composer2 == null) {
|
|
composer2 = global;
|
|
}
|
|
return composer2;
|
|
}
|
|
if (i18n.mode === "legacy") {
|
|
throw createI18nError(18);
|
|
}
|
|
const i18nInternal = i18n;
|
|
let composer = i18nInternal.__getInstance(instance);
|
|
if (composer == null) {
|
|
const type = instance.type;
|
|
const composerOptions = assign({}, options);
|
|
if (type.__i18n) {
|
|
composerOptions.__i18n = type.__i18n;
|
|
}
|
|
if (global) {
|
|
composerOptions.__root = global;
|
|
}
|
|
composer = createComposer(composerOptions);
|
|
setupLifeCycle(i18nInternal, instance);
|
|
i18nInternal.__setInstance(instance, composer);
|
|
}
|
|
return composer;
|
|
}
|
|
function getComposer(i18n, target, useComponent = false) {
|
|
let composer = null;
|
|
const root = target.root;
|
|
let current = target.parent;
|
|
while (current != null) {
|
|
const i18nInternal = i18n;
|
|
if (i18n.mode === "composition") {
|
|
composer = i18nInternal.__getInstance(current);
|
|
} else {
|
|
const vueI18n = i18nInternal.__getInstance(current);
|
|
if (vueI18n != null) {
|
|
composer = vueI18n.__composer;
|
|
}
|
|
if (useComponent && composer && !composer[InejctWithOption]) {
|
|
composer = null;
|
|
}
|
|
}
|
|
if (composer != null) {
|
|
break;
|
|
}
|
|
if (root === current) {
|
|
break;
|
|
}
|
|
current = current.parent;
|
|
}
|
|
return composer;
|
|
}
|
|
function setupLifeCycle(i18n, target, composer) {
|
|
onMounted(() => {
|
|
}, target);
|
|
onUnmounted(() => {
|
|
i18n.__deleteInstance(target);
|
|
}, target);
|
|
}
|
|
const globalExportProps = [
|
|
"locale",
|
|
"fallbackLocale",
|
|
"availableLocales"
|
|
];
|
|
const globalExportMethods = ["t", "rt", "d", "n", "tm"];
|
|
function injectGlobalFields(app, composer) {
|
|
const i18n = /* @__PURE__ */ Object.create(null);
|
|
globalExportProps.forEach((prop) => {
|
|
const desc = Object.getOwnPropertyDescriptor(composer, prop);
|
|
if (!desc) {
|
|
throw createI18nError(22);
|
|
}
|
|
const wrap = isRef(desc.value) ? {
|
|
get() {
|
|
return desc.value.value;
|
|
},
|
|
set(val) {
|
|
desc.value.value = val;
|
|
}
|
|
} : {
|
|
get() {
|
|
return desc.get && desc.get();
|
|
}
|
|
};
|
|
Object.defineProperty(i18n, prop, wrap);
|
|
});
|
|
app.config.globalProperties.$i18n = i18n;
|
|
globalExportMethods.forEach((method) => {
|
|
const desc = Object.getOwnPropertyDescriptor(composer, method);
|
|
if (!desc || !desc.value) {
|
|
throw createI18nError(22);
|
|
}
|
|
Object.defineProperty(app.config.globalProperties, `$${method}`, desc);
|
|
});
|
|
}
|
|
registerMessageCompiler(compileToFunction);
|
|
{
|
|
initFeatureFlags();
|
|
}
|
|
if (__INTLIFY_PROD_DEVTOOLS__) {
|
|
const target = getGlobalThis();
|
|
target.__INTLIFY__ = true;
|
|
setDevToolsHook(target.__INTLIFY_DEVTOOLS_GLOBAL_HOOK__);
|
|
}
|
|
export { createI18n as c, useI18n as u };
|