@stacksjs/i18n 0.70.88 → 0.70.91

package/dist/locale-switch.js

@@ -0,0 +1,45 @@
+function normalizeLocale(code, config) {
+  const normalized = code.trim().toLowerCase();
+  if (config.locales.includes(normalized))
+    return normalized;
+  const short = normalized.split("-")[0];
+  if (short && config.locales.includes(short))
+    return short;
+  return null;
+}
+export function stripLocalePrefix(path, locales) {
+  for (const loc of locales) {
+    if (path === `/${loc}` || path === `/${loc}/`)
+      return { locale: loc, path: "/" };
+    if (path.startsWith(`/${loc}/`))
+      return { locale: loc, path: path.slice(loc.length + 1) };
+  }
+  return { locale: null, path };
+}
+export function localizePath(path, locale, defaultLocale) {
+  if (locale === defaultLocale)
+    return path;
+  if (path === "/")
+    return `/${locale}/`;
+  if (path === "/404.html")
+    return `/${locale}/404.html`;
+  return `/${locale}${path}`;
+}
+export function createLocaleSwitchResponse(request, localeCode, config) {
+  const locale = normalizeLocale(localeCode, config);
+  if (!locale)
+    return Response.redirect(new URL("/", request.url).href, 302);
+  const referer = request.headers.get("referer");
+  let basePath = "/";
+  if (referer)
+    try {
+      const ref = new URL(referer);
+      if (!ref.pathname.startsWith("/locale/"))
+        basePath = stripLocalePrefix(ref.pathname, config.locales).path || "/";
+    } catch {
+      basePath = "/";
+    }
+  const targetPath = localizePath(basePath, locale, config.defaultLocale), target = new URL(targetPath, request.url), res = Response.redirect(target.href, 302);
+  res.headers.append("Set-Cookie", `locale=${locale}; Path=/; Max-Age=31536000; SameSite=Lax`);
+  return res;
+}

package/dist/pluralization.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Get the plural category for a number in a given locale
+ */
+export declare function getPluralCategory(n: number, locale: string): PluralCategory;
+/**
+ * Get the plural rule function for a locale
+ */
+export declare function getPluralRule(locale: string): PluralRule;
+/**
+ * Parse a plural string into its forms
+ *
+ * Supports formats:
+ * - "one | other" (simple)
+ * - "zero | one | other" (with zero)
+ * - "{0} item | {0} items" (with placeholders)
+ * - "no items | one item | {n} items" (with special forms)
+ */
+export declare function parsePluralForms(str: string, separator?: string): Map<PluralCategory, string>;
+/**
+ * Select the appropriate plural form for a count
+ */
+export declare function selectPluralForm(forms: Map<PluralCategory, string>, count: number, locale: string): string;
+/**
+ * Get all supported locales for pluralization
+ */
+export declare function getSupportedPluralLocales(): string[];
+/**
+ * Check if a locale has custom plural rules
+ */
+export declare function hasPluralRule(locale: string): boolean;
+/**
+ * Add a custom plural rule for a locale
+ */
+export declare function addPluralRule(locale: string, rule: PluralRule): void;
+/**
+ * Pluralization Rules
+ *
+ * Implements CLDR plural rules for various languages.
+ * @see https://cldr.unicode.org/index/cldr-spec/plural-rules
+ */
+export type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+export type PluralRule = (_n: number) => PluralCategory;

package/dist/pluralization.js

@@ -0,0 +1,190 @@
+export function getPluralCategory(n, locale) {
+  return getPluralRule(locale)(n);
+}
+export function getPluralRule(locale) {
+  const lang = locale.split("-")[0]?.toLowerCase() ?? locale.toLowerCase(), rule = pluralRules[lang];
+  if (rule)
+    return rule;
+  return () => "other";
+}
+export function parsePluralForms(str, separator = "|") {
+  const parts = str.split(separator).map((s) => s.trim()), forms = new Map;
+  if (parts.length === 1)
+    forms.set("other", parts[0] ?? "");
+  else if (parts.length === 2) {
+    forms.set("one", parts[0] ?? "");
+    forms.set("other", parts[1] ?? "");
+  } else if (parts.length === 3) {
+    forms.set("zero", parts[0] ?? "");
+    forms.set("one", parts[1] ?? "");
+    forms.set("other", parts[2] ?? "");
+  } else if (parts.length >= 4) {
+    const categories = ["zero", "one", "two", "few", "many", "other"];
+    for (let i = 0;i < parts.length && i < categories.length; i++) {
+      const category = categories[i], part = parts[i];
+      if (category !== void 0 && part !== void 0)
+        forms.set(category, part);
+    }
+  }
+  return forms;
+}
+export function selectPluralForm(forms, count, locale) {
+  const category = getPluralCategory(count, locale);
+  if (forms.has(category))
+    return forms.get(category);
+  if (forms.has("other"))
+    return forms.get("other");
+  const first = forms.values().next();
+  return first.done ? "" : first.value;
+}
+const pluralRules = {
+  en: (n) => n === 1 ? "one" : "other",
+  de: (n) => n === 1 ? "one" : "other",
+  nl: (n) => n === 1 ? "one" : "other",
+  es: (n) => n === 1 ? "one" : "other",
+  it: (n) => n === 1 ? "one" : "other",
+  pt: (n) => n === 1 ? "one" : "other",
+  sv: (n) => n === 1 ? "one" : "other",
+  da: (n) => n === 1 ? "one" : "other",
+  no: (n) => n === 1 ? "one" : "other",
+  fi: (n) => n === 1 ? "one" : "other",
+  el: (n) => n === 1 ? "one" : "other",
+  he: (n) => n === 1 ? "one" : "other",
+  hu: (n) => n === 1 ? "one" : "other",
+  tr: (n) => n === 1 ? "one" : "other",
+  zh: () => "other",
+  ja: () => "other",
+  ko: () => "other",
+  vi: () => "other",
+  th: () => "other",
+  id: () => "other",
+  ms: () => "other",
+  fr: (n) => n === 0 || n === 1 ? "one" : "other",
+  ru: (n) => {
+    const mod10 = n % 10, mod100 = n % 100;
+    if (mod10 === 1 && mod100 !== 11)
+      return "one";
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14))
+      return "few";
+    if (mod10 === 0 || mod10 >= 5 && mod10 <= 9 || mod100 >= 11 && mod100 <= 14)
+      return "many";
+    return "other";
+  },
+  uk: (n) => {
+    const mod10 = n % 10, mod100 = n % 100;
+    if (mod10 === 1 && mod100 !== 11)
+      return "one";
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14))
+      return "few";
+    if (mod10 === 0 || mod10 >= 5 && mod10 <= 9 || mod100 >= 11 && mod100 <= 14)
+      return "many";
+    return "other";
+  },
+  pl: (n) => {
+    const mod10 = n % 10, mod100 = n % 100;
+    if (n === 1)
+      return "one";
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14))
+      return "few";
+    if (mod10 === 0 || mod10 === 1 || mod10 >= 5 && mod10 <= 9 || mod100 >= 12 && mod100 <= 14)
+      return "many";
+    return "other";
+  },
+  cs: (n) => {
+    if (n === 1)
+      return "one";
+    if (n >= 2 && n <= 4)
+      return "few";
+    return "other";
+  },
+  sk: (n) => {
+    if (n === 1)
+      return "one";
+    if (n >= 2 && n <= 4)
+      return "few";
+    return "other";
+  },
+  ar: (n) => {
+    if (n === 0)
+      return "zero";
+    if (n === 1)
+      return "one";
+    if (n === 2)
+      return "two";
+    const mod100 = n % 100;
+    if (mod100 >= 3 && mod100 <= 10)
+      return "few";
+    if (mod100 >= 11 && mod100 <= 99)
+      return "many";
+    return "other";
+  },
+  cy: (n) => {
+    if (n === 0)
+      return "zero";
+    if (n === 1)
+      return "one";
+    if (n === 2)
+      return "two";
+    if (n === 3)
+      return "few";
+    if (n === 6)
+      return "many";
+    return "other";
+  },
+  sl: (n) => {
+    const mod100 = n % 100;
+    if (mod100 === 1)
+      return "one";
+    if (mod100 === 2)
+      return "two";
+    if (mod100 === 3 || mod100 === 4)
+      return "few";
+    return "other";
+  },
+  ga: (n) => {
+    if (n === 1)
+      return "one";
+    if (n === 2)
+      return "two";
+    if (n >= 3 && n <= 6)
+      return "few";
+    if (n >= 7 && n <= 10)
+      return "many";
+    return "other";
+  },
+  lt: (n) => {
+    const mod10 = n % 10, mod100 = n % 100;
+    if (mod10 === 1 && (mod100 < 11 || mod100 > 19))
+      return "one";
+    if (mod10 >= 2 && mod10 <= 9 && (mod100 < 11 || mod100 > 19))
+      return "few";
+    return "other";
+  },
+  lv: (n) => {
+    const mod10 = n % 10, mod100 = n % 100;
+    if (n === 0)
+      return "zero";
+    if (mod10 === 1 && mod100 !== 11)
+      return "one";
+    return "other";
+  },
+  ro: (n) => {
+    if (n === 1)
+      return "one";
+    const mod100 = n % 100;
+    if (n === 0 || mod100 >= 1 && mod100 <= 19)
+      return "few";
+    return "other";
+  },
+  hi: (n) => n === 0 || n === 1 ? "one" : "other"
+};
+export function getSupportedPluralLocales() {
+  return Object.keys(pluralRules);
+}
+export function hasPluralRule(locale) {
+  return (locale.split("-")[0]?.toLowerCase() ?? locale.toLowerCase()) in pluralRules;
+}
+export function addPluralRule(locale, rule) {
+  const lang = locale.split("-")[0]?.toLowerCase() ?? locale.toLowerCase();
+  pluralRules[lang] = rule;
+}

package/dist/translator.d.ts

@@ -0,0 +1,79 @@
+import type { I18nConfig, I18nInstance, InterpolationValues, TranslationMessages, Translations } from './types';
+/**
+ * Set the current locale
+ */
+export declare function setLocale(locale: string): void;
+/**
+ * Get the current locale
+ */
+export declare function getLocale(): string;
+/**
+ * Set the fallback locale
+ */
+export declare function setFallbackLocale(locale: string): void;
+/**
+ * Get available locales
+ */
+export declare function getAvailableLocales(): string[];
+/**
+ * Add translations for a locale
+ */
+export declare function addTranslations(locale: string, messages: TranslationMessages): void;
+/**
+ * Load translations (alias for addTranslations for multiple locales)
+ */
+export declare function loadTranslations(messages: Translations): void;
+/**
+ * Check if a translation exists
+ */
+export declare function hasTranslation(key: string, locale?: string): boolean;
+/**
+ * Translate a key
+ */
+export declare function t(key: string, values?: InterpolationValues, locale?: string): string;
+/**
+ * Translate with pluralization
+ */
+export declare function tc(key: string, count: number, values?: InterpolationValues, locale?: string): string;
+/**
+ * Check if translation exists
+ */
+export declare function te(key: string, locale?: string): boolean;
+/**
+ * Get translation message object
+ */
+export declare function tm(key: string, locale?: string): TranslationMessages | string | undefined;
+/**
+ * Create a new i18n instance
+ */
+export declare function createI18n(options?: Partial<I18nConfig>): I18n;
+/**
+ * Use i18n composable (for Vue-like usage)
+ */
+export declare function useI18n(options?: Partial<I18nConfig>): I18nInstance;
+/**
+ * Configure the global i18n instance
+ */
+export declare function configure(options: Partial<I18nConfig>): void;
+/**
+ * Alias for t()
+ */
+export declare const trans: unknown;
+/**
+ * I18n class for creating isolated instances
+ */
+export declare class I18n implements I18nInstance {
+  constructor(options?: Partial<I18nConfig>);
+  get locale(): string;
+  set locale(value: string);
+  get fallbackLocale(): string;
+  get availableLocales(): string[];
+  t: unknown;
+  tc: unknown;
+  te: unknown;
+  tm: unknown;
+  setLocale: unknown;
+  addTranslations: unknown;
+  d: unknown;
+  n: unknown;
+}

package/dist/translator.js

@@ -0,0 +1,249 @@
+import { parsePluralForms, selectPluralForm, getPluralCategory } from "./pluralization";
+const defaultConfig = {
+  locale: "en",
+  fallbackLocale: "en",
+  availableLocales: ["en"],
+  messages: {},
+  warnMissing: !0,
+  escapeValues: !1,
+  keySeparator: ".",
+  pluralSeparator: "|"
+};
+let currentLocale = "en", fallbackLocale = "en";
+const translations = {};
+let config = { ...defaultConfig };
+
+export class I18n {
+  _locale;
+  _fallbackLocale;
+  _messages;
+  _config;
+  constructor(options = {}) {
+    this._config = { ...defaultConfig, ...options };
+    this._locale = this._config.locale;
+    this._fallbackLocale = this._config.fallbackLocale;
+    this._messages = this._config.messages || {};
+  }
+  get locale() {
+    return this._locale;
+  }
+  set locale(value) {
+    this._locale = value;
+  }
+  get fallbackLocale() {
+    return this._fallbackLocale;
+  }
+  get availableLocales() {
+    return Object.keys(this._messages);
+  }
+  t = (key, values, locale) => {
+    return this.translate(key, values, locale);
+  };
+  tc = (key, count, values, locale) => {
+    return this.translatePlural(key, count, values, locale);
+  };
+  te = (key, locale) => {
+    return this.hasTranslation(key, locale);
+  };
+  tm = (key, locale) => {
+    return this.getMessage(key, locale ?? this.locale);
+  };
+  setLocale = (locale) => {
+    this._locale = locale;
+  };
+  addTranslations = (locale, messages) => {
+    if (!this._messages[locale])
+      this._messages[locale] = {};
+    this._messages[locale] = deepMerge(this._messages[locale], messages);
+  };
+  d = (value, format) => {
+    const date = typeof value === "number" ? new Date(value) : value, options = this._config.dateTimeFormats?.[this._locale]?.[format || "short"] || {};
+    return new Intl.DateTimeFormat(this._locale, options).format(date);
+  };
+  n = (value, format) => {
+    const options = this._config.numberFormats?.[this._locale]?.[format || "decimal"] || {};
+    return new Intl.NumberFormat(this._locale, options).format(value);
+  };
+  translate(key, values, locale) {
+    const targetLocale = locale || this._locale;
+    let message = this.getMessage(key, targetLocale);
+    if (message === void 0) {
+      const dash = targetLocale.indexOf("-");
+      if (dash > 0) {
+        const langOnly = targetLocale.slice(0, dash);
+        if (langOnly !== this._fallbackLocale)
+          message = this.getMessage(key, langOnly);
+      }
+    }
+    if (message === void 0 && targetLocale !== this._fallbackLocale)
+      message = this.getMessage(key, this._fallbackLocale);
+    if (message === void 0) {
+      if (this._config.warnMissing)
+        console.warn(`[i18n] Missing translation: "${key}" for locale "${targetLocale}"`);
+      if (this._config.missingHandler) {
+        const result = this._config.missingHandler(targetLocale, key);
+        if (result !== void 0)
+          return result;
+      }
+      return key;
+    }
+    if (typeof message !== "string")
+      return key;
+    return this.interpolate(message, values);
+  }
+  translatePlural(key, count, values, locale) {
+    const targetLocale = locale || this._locale;
+    let message = this.getMessage(key, targetLocale);
+    if (message === void 0 && targetLocale !== this._fallbackLocale)
+      message = this.getMessage(key, this._fallbackLocale);
+    if (message === void 0 || typeof message !== "string") {
+      if (this._config.warnMissing)
+        console.warn(`[i18n] Missing plural translation: "${key}" for locale "${targetLocale}"`);
+      return key;
+    }
+    const forms = parsePluralForms(message, this._config.pluralSeparator), selectedForm = selectPluralForm(forms, count, targetLocale), allValues = { count, n: count, ...values };
+    return this.interpolate(selectedForm, allValues);
+  }
+  hasTranslation(key, locale) {
+    const targetLocale = locale || this._locale;
+    return this.getMessage(key, targetLocale) !== void 0;
+  }
+  getMessage(key, locale) {
+    const messages = this._messages[locale];
+    if (!messages)
+      return;
+    const parts = key.split(this._config.keySeparator || ".");
+    let current = messages;
+    for (const part of parts) {
+      if (current === void 0 || typeof current === "string")
+        return;
+      current = current[part];
+    }
+    return current;
+  }
+  interpolate(message, values) {
+    if (!values)
+      return message;
+    return message.replace(/\{(\w+)\}/g, (match, key) => {
+      const value = values[key];
+      if (value === void 0 || value === null)
+        return match;
+      const str = String(value);
+      return this._config.escapeValues ? escapeHtml(str) : str;
+    });
+  }
+}
+export function setLocale(locale) {
+  currentLocale = locale;
+}
+export function getLocale() {
+  return currentLocale;
+}
+export function setFallbackLocale(locale) {
+  fallbackLocale = locale;
+}
+export function getAvailableLocales() {
+  return Object.keys(translations);
+}
+export function addTranslations(locale, messages) {
+  if (!translations[locale])
+    translations[locale] = {};
+  translations[locale] = deepMerge(translations[locale], messages);
+}
+export function loadTranslations(messages) {
+  for (const [locale, localeMessages] of Object.entries(messages))
+    addTranslations(locale, localeMessages);
+}
+export function hasTranslation(key, locale) {
+  return getMessage(key, locale || currentLocale) !== void 0;
+}
+function getMessage(key, locale) {
+  const messages = translations[locale];
+  if (!messages)
+    return;
+  const parts = key.split(config.keySeparator || ".");
+  let current = messages;
+  for (const part of parts) {
+    if (current === void 0 || typeof current === "string")
+      return;
+    current = current[part];
+  }
+  return current;
+}
+function interpolate(message, values) {
+  if (!values)
+    return message;
+  return message.replace(/\{(\w+)\}/g, (match, key) => {
+    const value = values[key];
+    if (value === void 0 || value === null)
+      return match;
+    return String(value);
+  });
+}
+export function t(key, values, locale) {
+  const targetLocale = locale || currentLocale;
+  let message = getMessage(key, targetLocale);
+  if (message === void 0 && targetLocale !== fallbackLocale)
+    message = getMessage(key, fallbackLocale);
+  if (message === void 0) {
+    if (config.warnMissing)
+      console.warn(`[i18n] Missing translation: "${key}" for locale "${targetLocale}"`);
+    return key;
+  }
+  if (typeof message !== "string")
+    return key;
+  return interpolate(message, values);
+}
+export const trans = t;
+export function tc(key, count, values, locale) {
+  const targetLocale = locale || currentLocale;
+  let message = getMessage(key, targetLocale);
+  if (message === void 0 && targetLocale !== fallbackLocale)
+    message = getMessage(key, fallbackLocale);
+  if (message === void 0 || typeof message !== "string")
+    return key;
+  const forms = parsePluralForms(message, config.pluralSeparator), selectedForm = selectPluralForm(forms, count, targetLocale), allValues = { count, n: count, ...values };
+  return interpolate(selectedForm, allValues);
+}
+export function te(key, locale) {
+  return hasTranslation(key, locale);
+}
+export function tm(key, locale) {
+  return getMessage(key, locale || currentLocale);
+}
+export function createI18n(options = {}) {
+  return new I18n(options);
+}
+export function useI18n(options = {}) {
+  return createI18n(options);
+}
+export function configure(options) {
+  config = { ...config, ...options };
+  if (options.locale)
+    currentLocale = options.locale;
+  if (options.fallbackLocale)
+    fallbackLocale = options.fallbackLocale;
+  if (options.messages)
+    loadTranslations(options.messages);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key], targetValue = result[key];
+    if (typeof sourceValue === "object" && sourceValue !== null && typeof targetValue === "object" && targetValue !== null)
+      result[key] = deepMerge(targetValue, sourceValue);
+    else if (sourceValue !== void 0)
+      result[key] = sourceValue;
+  }
+  return result;
+}
+function escapeHtml(str) {
+  const htmlEscapes = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char] || char);
+}