inline-i18n-multi 0.2.0 → 0.4.0

package/dist/index.js

@@ -10,9 +10,203 @@ function setLocale(locale) {
 function getLocale() {
   return currentLocale;
 }
+var DATE_STYLES = {
+  short: { dateStyle: "short" },
+  medium: { dateStyle: "medium" },
+  long: { dateStyle: "long" },
+  full: { dateStyle: "full" }
+};
+var TIME_STYLES = {
+  short: { timeStyle: "short" },
+  medium: { timeStyle: "medium" },
+  long: { timeStyle: "long" },
+  full: { timeStyle: "full" }
+};
+var NUMBER_STYLES = {
+  decimal: { style: "decimal" },
+  percent: { style: "percent" },
+  integer: { style: "decimal", maximumFractionDigits: 0 }
+};
+var RELATIVE_TIME_STYLES = {
+  long: { style: "long", numeric: "auto" },
+  short: { style: "short", numeric: "auto" },
+  narrow: { style: "narrow", numeric: "auto" }
+};
+var LIST_TYPES = {
+  conjunction: "conjunction",
+  disjunction: "disjunction",
+  unit: "unit"
+};
+var LIST_STYLES = {
+  long: "long",
+  short: "short",
+  narrow: "narrow"
+};
+function toDate(value) {
+  if (value instanceof Date) {
+    return value;
+  }
+  return new Date(value);
+}
+function formatNumberElement(el, vars, locale) {
+  const value = vars[el.value];
+  if (value === void 0) {
+    return `{${el.value}}`;
+  }
+  const num = typeof value === "number" ? value : Number(value);
+  if (isNaN(num)) {
+    return `{${el.value}}`;
+  }
+  let options = {};
+  if (el.style) {
+    if (typeof el.style === "string") {
+      if (el.style === "currency") {
+        options = { style: "currency", currency: "USD" };
+      } else if (NUMBER_STYLES[el.style]) {
+        options = NUMBER_STYLES[el.style];
+      }
+    } else if ("parsedOptions" in el.style) {
+      options = el.style.parsedOptions;
+    }
+  }
+  try {
+    return new Intl.NumberFormat(locale, options).format(num);
+  } catch {
+    return String(num);
+  }
+}
+function formatDateElement(el, vars, locale) {
+  const value = vars[el.value];
+  if (value === void 0) {
+    return `{${el.value}}`;
+  }
+  let options = {};
+  if (el.style) {
+    if (typeof el.style === "string") {
+      options = DATE_STYLES[el.style] || {};
+    } else if ("parsedOptions" in el.style) {
+      options = el.style.parsedOptions;
+    }
+  }
+  try {
+    const date = toDate(value);
+    return new Intl.DateTimeFormat(locale, options).format(date);
+  } catch {
+    return `{${el.value}}`;
+  }
+}
+function formatTimeElement(el, vars, locale) {
+  const value = vars[el.value];
+  if (value === void 0) {
+    return `{${el.value}}`;
+  }
+  let options = {};
+  if (el.style) {
+    if (typeof el.style === "string") {
+      options = TIME_STYLES[el.style] || {};
+    } else if ("parsedOptions" in el.style) {
+      options = el.style.parsedOptions;
+    }
+  }
+  try {
+    const date = toDate(value);
+    return new Intl.DateTimeFormat(locale, options).format(date);
+  } catch {
+    return `{${el.value}}`;
+  }
+}
+function getRelativeTimeUnit(date, now = /* @__PURE__ */ new Date()) {
+  const diffMs = date.getTime() - now.getTime();
+  const diffSeconds = Math.round(diffMs / 1e3);
+  const diffMinutes = Math.round(diffSeconds / 60);
+  const diffHours = Math.round(diffMinutes / 60);
+  const diffDays = Math.round(diffHours / 24);
+  const diffWeeks = Math.round(diffDays / 7);
+  const diffMonths = Math.round(diffDays / 30);
+  const diffYears = Math.round(diffDays / 365);
+  if (Math.abs(diffSeconds) < 60) return { value: diffSeconds, unit: "second" };
+  if (Math.abs(diffMinutes) < 60) return { value: diffMinutes, unit: "minute" };
+  if (Math.abs(diffHours) < 24) return { value: diffHours, unit: "hour" };
+  if (Math.abs(diffDays) < 7) return { value: diffDays, unit: "day" };
+  if (Math.abs(diffWeeks) < 4) return { value: diffWeeks, unit: "week" };
+  if (Math.abs(diffMonths) < 12) return { value: diffMonths, unit: "month" };
+  return { value: diffYears, unit: "year" };
+}
+var RELATIVE_TIME_PATTERN = /\{(\w+),\s*relativeTime(?:,\s*(\w+))?\}/g;
+function preprocessRelativeTime(template) {
+  const replacements = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const processed = template.replace(RELATIVE_TIME_PATTERN, (_, variable, style) => {
+    const placeholder = `__RELTIME_${counter++}__`;
+    replacements.set(placeholder, { variable, style });
+    return `{${placeholder}}`;
+  });
+  return { processed, replacements };
+}
+function formatRelativeTimeValue(variableName, style, vars, locale) {
+  const value = vars[variableName];
+  if (value === void 0) {
+    return `{${variableName}}`;
+  }
+  try {
+    const date = toDate(value);
+    const { value: relValue, unit } = getRelativeTimeUnit(date);
+    const options = style && RELATIVE_TIME_STYLES[style] || RELATIVE_TIME_STYLES.long;
+    return new Intl.RelativeTimeFormat(locale, options).format(relValue, unit);
+  } catch {
+    return `{${variableName}}`;
+  }
+}
+var LIST_PATTERN = /\{(\w+),\s*list(?:,\s*(\w+))?(?:,\s*(\w+))?\}/g;
+function preprocessList(template) {
+  const replacements = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const processed = template.replace(LIST_PATTERN, (_, variable, arg1, arg2) => {
+    const placeholder = `__LIST_${counter++}__`;
+    let type;
+    let style;
+    if (arg1) {
+      if (LIST_TYPES[arg1]) {
+        type = arg1;
+        style = arg2;
+      } else if (LIST_STYLES[arg1]) {
+        style = arg1;
+      }
+    }
+    replacements.set(placeholder, { variable, type, style });
+    return `{${placeholder}}`;
+  });
+  return { processed, replacements };
+}
+function formatListValue(variableName, type, style, vars, locale) {
+  const value = vars[variableName];
+  if (value === void 0 || !Array.isArray(value)) {
+    return `{${variableName}}`;
+  }
+  const options = {
+    type: type || "conjunction",
+    style: style || "long"
+  };
+  try {
+    return new Intl.ListFormat(locale, options).format(value);
+  } catch {
+    return value.join(", ");
+  }
+}
 function interpolateICU(template, vars, locale) {
-  const ast = icuMessageformatParser.parse(template);
-  return formatElements(ast, vars, locale, null);
+  const { processed: afterRelTime, replacements: relTimeReplacements } = preprocessRelativeTime(template);
+  const { processed: afterList, replacements: listReplacements } = preprocessList(afterRelTime);
+  const ast = icuMessageformatParser.parse(afterList);
+  let result = formatElements(ast, vars, locale, null);
+  for (const [placeholder, { variable, style }] of relTimeReplacements) {
+    const formatted = formatRelativeTimeValue(variable, style, vars, locale);
+    result = result.replace(`{${placeholder}}`, formatted);
+  }
+  for (const [placeholder, { variable, type, style }] of listReplacements) {
+    const formatted = formatListValue(variable, type, style, vars, locale);
+    result = result.replace(`{${placeholder}}`, formatted);
+  }
+  return result;
 }
 function formatElements(elements, vars, locale, currentPluralValue) {
   return elements.map((el) => formatElement(el, vars, locale, currentPluralValue)).join("");
@@ -34,6 +228,15 @@ function formatElement(el, vars, locale, currentPluralValue) {
   if (icuMessageformatParser.isSelectElement(el)) {
     return formatSelect(el, vars, locale);
   }
+  if (icuMessageformatParser.isNumberElement(el)) {
+    return formatNumberElement(el, vars, locale);
+  }
+  if (icuMessageformatParser.isDateElement(el)) {
+    return formatDateElement(el, vars, locale);
+  }
+  if (icuMessageformatParser.isTimeElement(el)) {
+    return formatTimeElement(el, vars, locale);
+  }
   return "";
 }
 function formatPlural(el, vars, locale) {
@@ -67,7 +270,7 @@ function formatSelect(el, vars, locale) {
   }
   return `{${el.value}}`;
 }
-var ICU_PATTERN = /\{[^}]+,\s*(plural|select|selectordinal)\s*,/;
+var ICU_PATTERN = /\{[^}]+,\s*(plural|select|selectordinal|number|date|time|relativeTime|list)\s*[,}]/;
 function hasICUPattern(template) {
   return ICU_PATTERN.test(template);
 }
@@ -85,45 +288,205 @@ function interpolate(template, vars, locale) {
   });
 }
 
+// src/config.ts
+function defaultWarningHandler(warning) {
+  const parts = [`[inline-i18n] Missing translation for locale "${warning.requestedLocale}"`];
+  if (warning.key) {
+    parts.push(`key: "${warning.key}"`);
+  }
+  parts.push(`Available: [${warning.availableLocales.join(", ")}]`);
+  if (warning.fallbackUsed) {
+    parts.push(`Using fallback: "${warning.fallbackUsed}"`);
+  }
+  console.warn(parts.join(" | "));
+}
+function isDevMode() {
+  try {
+    if (typeof globalThis !== "undefined" && "process" in globalThis) {
+      const proc = globalThis.process;
+      return proc?.env?.NODE_ENV !== "production";
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+var defaultConfig = {
+  defaultLocale: "en",
+  fallbackLocale: "en",
+  autoParentLocale: true,
+  fallbackChain: {},
+  warnOnMissing: isDevMode(),
+  onMissingTranslation: defaultWarningHandler,
+  debugMode: false
+};
+var config = { ...defaultConfig };
+function configure(options) {
+  config = { ...config, ...options };
+}
+function getConfig() {
+  return {
+    ...defaultConfig,
+    ...config
+  };
+}
+function resetConfig() {
+  config = { ...defaultConfig };
+}
+function getParentLocale(locale) {
+  const dashIndex = locale.indexOf("-");
+  if (dashIndex > 0) {
+    return locale.substring(0, dashIndex);
+  }
+  return void 0;
+}
+function buildFallbackChain(locale) {
+  const cfg = getConfig();
+  if (cfg.fallbackChain[locale]) {
+    return [locale, ...cfg.fallbackChain[locale]];
+  }
+  const chain = [locale];
+  if (cfg.autoParentLocale) {
+    let current = locale;
+    while (true) {
+      const parent = getParentLocale(current);
+      if (parent && !chain.includes(parent)) {
+        chain.push(parent);
+        current = parent;
+      } else {
+        break;
+      }
+    }
+  }
+  const finalFallback = cfg.fallbackLocale;
+  if (finalFallback && !chain.includes(finalFallback)) {
+    chain.push(finalFallback);
+  }
+  return chain;
+}
+function emitWarning(warning) {
+  const cfg = getConfig();
+  if (cfg.warnOnMissing && cfg.onMissingTranslation) {
+    cfg.onMissingTranslation(warning);
+  }
+}
+function applyDebugFormat(output, debugInfo) {
+  const cfg = getConfig();
+  if (!cfg.debugMode) {
+    return output;
+  }
+  const options = typeof cfg.debugMode === "object" ? cfg.debugMode : { showMissingPrefix: true, showFallbackPrefix: true };
+  if (debugInfo.isMissing && options.showMissingPrefix !== false) {
+    const prefix = options.missingPrefixFormat ? options.missingPrefixFormat(debugInfo.requestedLocale, debugInfo.key) : `[MISSING: ${debugInfo.requestedLocale}] `;
+    return prefix + output;
+  }
+  if (debugInfo.isFallback && options.showFallbackPrefix !== false && debugInfo.usedLocale) {
+    const prefix = options.fallbackPrefixFormat ? options.fallbackPrefixFormat(debugInfo.requestedLocale, debugInfo.usedLocale, debugInfo.key) : `[${debugInfo.requestedLocale} -> ${debugInfo.usedLocale}] `;
+    return prefix + output;
+  }
+  return output;
+}
+
 // src/translate.ts
 function resolveTemplate(translations) {
   const locale = getLocale();
-  const template = translations[locale];
-  if (template) return { template, locale };
-  const fallback = translations.en ?? Object.values(translations)[0];
-  if (fallback) return { template: fallback, locale: "en" };
+  const availableLocales = Object.keys(translations);
+  const fallbackChain = buildFallbackChain(locale);
+  for (const tryLocale of fallbackChain) {
+    const template = translations[tryLocale];
+    if (template) {
+      const isFallback = tryLocale !== locale;
+      if (isFallback) {
+        emitWarning({
+          type: "missing_translation",
+          requestedLocale: locale,
+          availableLocales,
+          fallbackUsed: tryLocale
+        });
+      }
+      return {
+        template,
+        locale: tryLocale,
+        debugInfo: {
+          isMissing: false,
+          isFallback,
+          requestedLocale: locale,
+          usedLocale: tryLocale
+        }
+      };
+    }
+  }
+  const firstAvailable = Object.entries(translations)[0];
+  if (firstAvailable) {
+    emitWarning({
+      type: "missing_translation",
+      requestedLocale: locale,
+      availableLocales,
+      fallbackUsed: firstAvailable[0]
+    });
+    return {
+      template: firstAvailable[1],
+      locale: firstAvailable[0],
+      debugInfo: {
+        isMissing: false,
+        isFallback: true,
+        requestedLocale: locale,
+        usedLocale: firstAvailable[0]
+      }
+    };
+  }
   throw new Error(
-    `No translation found for locale "${locale}". Available: ${Object.keys(translations).join(", ")}`
+    `No translation found for locale "${locale}". Available: ${availableLocales.join(", ")}`
   );
 }
 function it(first, second, third) {
   if (typeof first === "object") {
     const translations2 = first;
     const vars2 = second;
-    const { template: template2, locale: locale2 } = resolveTemplate(translations2);
-    return interpolate(template2, vars2, locale2);
+    const { template: template2, locale: locale2, debugInfo: debugInfo2 } = resolveTemplate(translations2);
+    const result2 = interpolate(template2, vars2, locale2);
+    return applyDebugFormat(result2, debugInfo2);
   }
   const ko = first;
   const en = second;
   const vars = third;
   const translations = { ko, en };
-  const { template, locale } = resolveTemplate(translations);
-  return interpolate(template, vars, locale);
+  const { template, locale, debugInfo } = resolveTemplate(translations);
+  const result = interpolate(template, vars, locale);
+  return applyDebugFormat(result, debugInfo);
 }
 
 // src/runtime.ts
 function __i18n_lookup(_hash, translations, vars) {
   const locale = getLocale();
-  const template = translations[locale];
-  if (template) {
-    return interpolate(template, vars);
+  const availableLocales = Object.keys(translations);
+  const fallbackChain = buildFallbackChain(locale);
+  for (const tryLocale of fallbackChain) {
+    const template = translations[tryLocale];
+    if (template) {
+      if (tryLocale !== locale) {
+        emitWarning({
+          type: "missing_translation",
+          requestedLocale: locale,
+          availableLocales,
+          fallbackUsed: tryLocale
+        });
+      }
+      return interpolate(template, vars, tryLocale);
+    }
   }
-  const fallback = translations.en ?? Object.values(translations)[0];
-  if (fallback) {
-    return interpolate(fallback, vars);
+  const firstAvailable = Object.entries(translations)[0];
+  if (firstAvailable) {
+    emitWarning({
+      type: "missing_translation",
+      requestedLocale: locale,
+      availableLocales,
+      fallbackUsed: firstAvailable[0]
+    });
+    return interpolate(firstAvailable[1], vars, firstAvailable[0]);
   }
   throw new Error(
-    `No translation found for locale "${locale}". Available: ${Object.keys(translations).join(", ")}`
+    `No translation found for locale "${locale}". Available: ${availableLocales.join(", ")}`
   );
 }
 if (typeof globalThis !== "undefined") {
@@ -155,15 +518,48 @@ var ja_es = createPair("ja", "es");
 var zh_es = createPair("zh", "es");
 
 // src/dictionary.ts
-var dictionaries = {};
-function loadDictionaries(dicts) {
-  dictionaries = { ...dictionaries, ...dicts };
+var DEFAULT_NAMESPACE = "default";
+var NAMESPACE_SEPARATOR = ":";
+var namespacedDictionaries = {};
+function parseKey(fullKey) {
+  const separatorIndex = fullKey.indexOf(NAMESPACE_SEPARATOR);
+  if (separatorIndex > 0) {
+    return {
+      namespace: fullKey.substring(0, separatorIndex),
+      key: fullKey.substring(separatorIndex + 1)
+    };
+  }
+  return {
+    namespace: DEFAULT_NAMESPACE,
+    key: fullKey
+  };
+}
+function loadDictionaries(dicts, namespace) {
+  const ns = namespace || DEFAULT_NAMESPACE;
+  if (!namespacedDictionaries[ns]) {
+    namespacedDictionaries[ns] = {};
+  }
+  namespacedDictionaries[ns] = {
+    ...namespacedDictionaries[ns],
+    ...dicts
+  };
 }
-function loadDictionary(locale, dict) {
-  dictionaries[locale] = { ...dictionaries[locale], ...dict };
+function loadDictionary(locale, dict, namespace) {
+  const ns = namespace || DEFAULT_NAMESPACE;
+  if (!namespacedDictionaries[ns]) {
+    namespacedDictionaries[ns] = {};
+  }
+  namespacedDictionaries[ns][locale] = {
+    ...namespacedDictionaries[ns][locale],
+    ...dict
+  };
 }
-function clearDictionaries() {
-  dictionaries = {};
+function clearDictionaries(namespace) {
+  if (namespace) {
+    delete namespacedDictionaries[namespace];
+  } else {
+    namespacedDictionaries = {};
+  }
 }
 function getNestedValue(dict, key) {
   const parts = key.split(".");
@@ -183,54 +579,109 @@ function getPluralCategory(count, locale) {
   const rules = new Intl.PluralRules(locale);
   return rules.select(count);
 }
-function t(key, vars, locale) {
-  const currentLocale2 = locale ?? getLocale();
-  const dict = dictionaries[currentLocale2];
-  if (!dict) {
-    console.warn(`[inline-i18n] No dictionary loaded for locale: ${currentLocale2}`);
-    return key;
-  }
+function findInDictionary(dict, key, vars, locale) {
   let template = getNestedValue(dict, key);
   if (vars && typeof vars.count === "number") {
-    const pluralKey = `${key}_${getPluralCategory(vars.count, currentLocale2)}`;
+    const pluralKey = `${key}_${getPluralCategory(vars.count, locale)}`;
     const pluralTemplate = getNestedValue(dict, pluralKey);
     if (pluralTemplate) {
       template = pluralTemplate;
     }
   }
-  if (!template) {
-    const fallbackDict = dictionaries["en"];
-    if (fallbackDict && currentLocale2 !== "en") {
-      template = getNestedValue(fallbackDict, key);
+  return template;
+}
+function t(key, vars, locale) {
+  const { namespace, key: actualKey } = parseKey(key);
+  const currentLocale2 = locale ?? getLocale();
+  const fallbackChain = buildFallbackChain(currentLocale2);
+  const nsDictionaries = namespacedDictionaries[namespace] || {};
+  const availableLocales = Object.keys(nsDictionaries);
+  let template;
+  let usedLocale;
+  for (const tryLocale of fallbackChain) {
+    const dict = nsDictionaries[tryLocale];
+    if (!dict) continue;
+    const found = findInDictionary(dict, actualKey, vars, tryLocale);
+    if (found) {
+      template = found;
+      usedLocale = tryLocale;
+      break;
     }
   }
   if (!template) {
-    console.warn(`[inline-i18n] Missing translation: ${key} (${currentLocale2})`);
-    return key;
+    emitWarning({
+      type: "missing_translation",
+      key,
+      requestedLocale: currentLocale2,
+      availableLocales
+    });
+    const debugInfo2 = {
+      isMissing: true,
+      isFallback: false,
+      requestedLocale: currentLocale2,
+      key
+    };
+    return applyDebugFormat(key, debugInfo2);
   }
-  return interpolate(template, vars, currentLocale2);
+  const isFallback = usedLocale !== currentLocale2;
+  if (isFallback) {
+    emitWarning({
+      type: "missing_translation",
+      key,
+      requestedLocale: currentLocale2,
+      availableLocales,
+      fallbackUsed: usedLocale
+    });
+  }
+  const result = interpolate(template, vars, usedLocale || currentLocale2);
+  const debugInfo = {
+    isMissing: false,
+    isFallback,
+    requestedLocale: currentLocale2,
+    usedLocale,
+    key
+  };
+  return applyDebugFormat(result, debugInfo);
 }
 function hasTranslation(key, locale) {
+  const { namespace, key: actualKey } = parseKey(key);
   const currentLocale2 = locale ?? getLocale();
-  const dict = dictionaries[currentLocale2];
-  return dict ? getNestedValue(dict, key) !== void 0 : false;
+  const nsDictionaries = namespacedDictionaries[namespace] || {};
+  const dict = nsDictionaries[currentLocale2];
+  return dict ? getNestedValue(dict, actualKey) !== void 0 : false;
+}
+function getLoadedLocales(namespace) {
+  if (namespace) {
+    return Object.keys(namespacedDictionaries[namespace] || {});
+  }
+  const locales = /* @__PURE__ */ new Set();
+  for (const ns of Object.values(namespacedDictionaries)) {
+    for (const locale of Object.keys(ns)) {
+      locales.add(locale);
+    }
+  }
+  return Array.from(locales);
 }
-function getLoadedLocales() {
-  return Object.keys(dictionaries);
+function getDictionary(locale, namespace) {
+  const ns = namespace || DEFAULT_NAMESPACE;
+  return namespacedDictionaries[ns]?.[locale];
 }
-function getDictionary(locale) {
-  return dictionaries[locale];
+function getLoadedNamespaces() {
+  return Object.keys(namespacedDictionaries);
 }
 
 exports.__i18n_lookup = __i18n_lookup;
 exports.clearDictionaries = clearDictionaries;
+exports.configure = configure;
 exports.en_de = en_de;
 exports.en_es = en_es;
 exports.en_fr = en_fr;
 exports.en_ja = en_ja;
 exports.en_zh = en_zh;
+exports.getConfig = getConfig;
 exports.getDictionary = getDictionary;
 exports.getLoadedLocales = getLoadedLocales;
+exports.getLoadedNamespaces = getLoadedNamespaces;
 exports.getLocale = getLocale;
 exports.hasTranslation = hasTranslation;
 exports.it = it;
@@ -243,6 +694,7 @@ exports.ja_es = ja_es;
 exports.ja_zh = ja_zh;
 exports.loadDictionaries = loadDictionaries;
 exports.loadDictionary = loadDictionary;
+exports.resetConfig = resetConfig;
 exports.setLocale = setLocale;
 exports.t = t;
 exports.zh_es = zh_es;