@stacksjs/i18n 0.70.88 → 0.70.90

package/dist/bootstrap.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Load translation files from the project `locales/` directory once.
+ * Locale subdirectories (`locales/de.yml`, `locales/en.yml`, …) are detected
+ * automatically by `loadFromDirectory`.
+ */
+export declare function ensureLocalesLoaded(): Promise<void>;
+/**
+ * Resolve the active locale for an HTTP request.
+ * Order: STX locale prefix (`/en/...`), `?locale=`, `locale` cookie,
+ * Accept-Language, then `config.app.locale`.
+ */
+export declare function resolveRequestLocale(request?: Request): string;
+/** Load `locales/` and activate the global translator for this request. */
+export declare function applyRequestLocale(request?: Request): Promise<string>;

package/dist/bootstrap.js

@@ -0,0 +1,70 @@
+import { existsSync } from "node:fs";
+import { config } from "@stacksjs/config";
+import { projectPath } from "@stacksjs/path";
+import { loadFromDirectory } from "./loader";
+import { configure, getAvailableLocales, setLocale } from "./translator";
+let localesLoaded = !1;
+export async function ensureLocalesLoaded() {
+  if (localesLoaded)
+    return;
+  const directory = projectPath("locales");
+  if (existsSync(directory))
+    await loadFromDirectory({
+      directory,
+      extensions: [".yaml", ".yml", ".json"]
+    });
+  const app = config.app, defaultLocale = app?.locale ?? "en", fallback = app?.fallbackLocale ?? defaultLocale, available = getAvailableLocales();
+  configure({
+    locale: defaultLocale,
+    fallbackLocale: fallback,
+    availableLocales: available.length > 0 ? available : [defaultLocale],
+    warnMissing: (app?.env ?? process.env.APP_ENV) !== "production"
+  });
+  localesLoaded = !0;
+}
+export function resolveRequestLocale(request) {
+  const defaultLocale = config.app?.locale ?? "en", available = new Set(getAvailableLocales());
+  if (!available.size)
+    available.add(defaultLocale);
+  const pick = (code) => {
+    const normalized = code.trim().toLowerCase();
+    if (available.has(normalized))
+      return normalized;
+    const short = normalized.split("-")[0];
+    if (short && available.has(short))
+      return short;
+    return defaultLocale;
+  };
+  if (!request)
+    return defaultLocale;
+  const url = new URL(request.url), pathname = url.pathname, fromStx = request.headers.get("x-stx-locale");
+  if (fromStx)
+    return pick(fromStx);
+  for (const code of available) {
+    if (code === defaultLocale)
+      continue;
+    if (pathname === `/${code}` || pathname === `/${code}/`)
+      return pick(code);
+    if (pathname.startsWith(`/${code}/`))
+      return pick(code);
+  }
+  const fromQuery = url.searchParams.get("locale");
+  if (fromQuery)
+    return pick(fromQuery);
+  const match = (request.headers.get("cookie") ?? "").match(/(?:^|;\s*)locale=([a-z]{2}(?:-[a-z]{2})?)(?:;|$)/i);
+  if (match?.[1])
+    return pick(match[1]);
+  const accept = request.headers.get("accept-language") ?? "";
+  for (const part of accept.split(",")) {
+    const tag = part.split(";")[0]?.trim();
+    if (tag)
+      return pick(tag);
+  }
+  return defaultLocale;
+}
+export async function applyRequestLocale(request) {
+  await ensureLocalesLoaded();
+  const locale = resolveRequestLocale(request);
+  setLocale(locale);
+  return locale;
+}

package/dist/formatter.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Format a date
+ */
+export declare function formatDate(date: Date | number | string, style?: DateStyle | DateFormatOptions, locale?: string): string;
+/**
+ * Format a time
+ */
+export declare function formatTime(date: Date | number | string, style?: TimeStyle | DateFormatOptions, locale?: string): string;
+/**
+ * Format a date and time
+ */
+export declare function formatDateTime(date: Date | number | string, dateStyle?: DateStyle, timeStyle?: TimeStyle, locale?: string): string;
+/**
+ * Format relative time (e.g., "2 days ago", "in 3 hours")
+ */
+export declare function formatRelativeTime(date: Date | number | string, baseDate?: Date | number | string, style?: 'long' | 'short' | 'narrow', locale?: string): string;
+/**
+ * Format a number
+ */
+export declare function formatNumber(value: number, options?: NumberFormatOptions, locale?: string): string;
+/**
+ * Format a currency value
+ */
+export declare function formatCurrency(value: number, currency?: string, options?: Omit<NumberFormatOptions, 'style' | 'currency'>, locale?: string): string;
+/**
+ * Format a percentage
+ */
+export declare function formatPercent(value: number, options?: Omit<NumberFormatOptions, 'style'>, locale?: string): string;
+/**
+ * Format a number with units (e.g., "5 kilograms", "10 miles")
+ */
+export declare function formatUnit(value: number, unit: string, unitDisplay?: 'long' | 'short' | 'narrow', locale?: string): string;
+/**
+ * Format bytes to human-readable format
+ */
+export declare function formatBytes(bytes: number, decimals?: number, locale?: string): string;
+/**
+ * Format a list of items
+ */
+export declare function formatList(items: string[], type?: ListType, style?: ListStyle, locale?: string): string;
+/**
+ * Get the plural category for a number
+ */
+export declare function formatPlural(value: number, locale?: string): Intl.LDMLPluralRule;
+/**
+ * Select from plural options based on a number
+ */
+export declare function selectPlural<T>(value: number, options: Partial<Record<Intl.LDMLPluralRule, T>> & { other: T }, locale?: string): T;
+/**
+ * Get display name for a code
+ */
+export declare function getDisplayName(code: string, type?: DisplayNameType, style?: 'long' | 'short' | 'narrow', locale?: string): string | undefined;
+/**
+ * Get language name
+ */
+export declare function getLanguageName(languageCode: string, locale?: string): string | undefined;
+/**
+ * Get region/country name
+ */
+export declare function getRegionName(regionCode: string, locale?: string): string | undefined;
+/**
+ * Get currency name
+ */
+export declare function getCurrencyName(currencyCode: string, locale?: string): string | undefined;
+/**
+ * Compare strings in a locale-aware manner
+ */
+export declare function compareStrings(a: string, b: string, options?: Intl.CollatorOptions, locale?: string): number;
+/**
+ * Sort an array of strings in locale-aware order
+ */
+export declare function sortStrings(strings: string[], options?: Intl.CollatorOptions, locale?: string): string[];
+/**
+ * Get the text direction for a locale
+ */
+export declare function getTextDirection(locale?: string): 'ltr' | 'rtl';
+/**
+ * Check if a locale uses RTL text direction
+ */
+export declare function isRTL(locale?: string): boolean;
+export declare interface DateFormatOptions extends Intl.DateTimeFormatOptions {
+  dateStyle?: DateStyle
+  timeStyle?: TimeStyle
+}
+// =============================================================================
+// Number Formatting
+// =============================================================================
+export declare interface NumberFormatOptions extends Intl.NumberFormatOptions {
+  compact?: boolean
+  precision?: number
+}
+// =============================================================================
+// Date Formatting
+// =============================================================================
+export type DateStyle = 'full' | 'long' | 'medium' | 'short';
+export type TimeStyle = 'full' | 'long' | 'medium' | 'short';
+// =============================================================================
+// List Formatting
+// =============================================================================
+export type ListType = 'conjunction' | 'disjunction' | 'unit';
+export type ListStyle = 'long' | 'short' | 'narrow';
+// =============================================================================
+// Display Names
+// =============================================================================
+export type DisplayNameType = 'language' | 'region' | 'script' | 'currency' | 'calendar' | 'dateTimeField';

package/dist/formatter.js

@@ -0,0 +1,128 @@
+import { getLocale } from "./translator";
+export function formatDate(date, style = "medium", locale) {
+  const targetLocale = locale || getLocale(), dateObj = toDate(date), options = typeof style === "string" ? { dateStyle: style } : style;
+  return new Intl.DateTimeFormat(targetLocale, options).format(dateObj);
+}
+export function formatTime(date, style = "short", locale) {
+  const targetLocale = locale || getLocale(), dateObj = toDate(date), options = typeof style === "string" ? { timeStyle: style } : style;
+  return new Intl.DateTimeFormat(targetLocale, options).format(dateObj);
+}
+export function formatDateTime(date, dateStyle = "medium", timeStyle = "short", locale) {
+  const targetLocale = locale || getLocale(), dateObj = toDate(date);
+  return new Intl.DateTimeFormat(targetLocale, {
+    dateStyle,
+    timeStyle
+  }).format(dateObj);
+}
+export function formatRelativeTime(date, baseDate = new Date, style = "long", locale) {
+  const targetLocale = locale || getLocale(), dateObj = toDate(date), baseDateObj = toDate(baseDate), diffMs = dateObj.getTime() - baseDateObj.getTime(), diffSeconds = Math.round(diffMs / 1000), diffMinutes = Math.round(diffSeconds / 60), diffHours = Math.round(diffMinutes / 60), diffDays = Math.round(diffHours / 24), diffWeeks = Math.round(diffDays / 7), diffMonths = Math.round(diffDays / 30), diffYears = Math.round(diffDays / 365), rtf = new Intl.RelativeTimeFormat(targetLocale, { style });
+  if (Math.abs(diffSeconds) < 60)
+    return rtf.format(diffSeconds, "second");
+  if (Math.abs(diffMinutes) < 60)
+    return rtf.format(diffMinutes, "minute");
+  if (Math.abs(diffHours) < 24)
+    return rtf.format(diffHours, "hour");
+  if (Math.abs(diffDays) < 7)
+    return rtf.format(diffDays, "day");
+  if (Math.abs(diffWeeks) < 4)
+    return rtf.format(diffWeeks, "week");
+  if (Math.abs(diffMonths) < 12)
+    return rtf.format(diffMonths, "month");
+  return rtf.format(diffYears, "year");
+}
+export function formatNumber(value, options = {}, locale) {
+  const targetLocale = locale || getLocale(), formatOptions = { ...options };
+  if (options.compact) {
+    formatOptions.notation = "compact";
+    formatOptions.compactDisplay = "short";
+  }
+  if (options.precision !== void 0) {
+    formatOptions.minimumFractionDigits = options.precision;
+    formatOptions.maximumFractionDigits = options.precision;
+  }
+  return new Intl.NumberFormat(targetLocale, formatOptions).format(value);
+}
+export function formatCurrency(value, currency = "USD", options = {}, locale) {
+  const targetLocale = locale || getLocale();
+  return new Intl.NumberFormat(targetLocale, {
+    style: "currency",
+    currency,
+    ...options
+  }).format(value);
+}
+export function formatPercent(value, options = {}, locale) {
+  const targetLocale = locale || getLocale();
+  return new Intl.NumberFormat(targetLocale, {
+    style: "percent",
+    ...options
+  }).format(value);
+}
+export function formatUnit(value, unit, unitDisplay = "short", locale) {
+  const targetLocale = locale || getLocale();
+  return new Intl.NumberFormat(targetLocale, {
+    style: "unit",
+    unit,
+    unitDisplay
+  }).format(value);
+}
+export function formatBytes(bytes, decimals = 2, locale) {
+  const targetLocale = locale || getLocale();
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024, sizes = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"], i = Math.floor(Math.log(bytes) / Math.log(k)), value = bytes / Math.pow(k, i);
+  return `${new Intl.NumberFormat(targetLocale, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: decimals
+  }).format(value)} ${sizes[i]}`;
+}
+export function formatList(items, type = "conjunction", style = "long", locale) {
+  const targetLocale = locale || getLocale();
+  return new Intl.ListFormat(targetLocale, { type, style }).format(items);
+}
+export function formatPlural(value, locale) {
+  const targetLocale = locale || getLocale();
+  return new Intl.PluralRules(targetLocale).select(value);
+}
+export function selectPlural(value, options, locale) {
+  const category = formatPlural(value, locale);
+  return options[category] ?? options.other;
+}
+export function getDisplayName(code, type = "language", style = "long", locale) {
+  const targetLocale = locale || getLocale();
+  try {
+    return new Intl.DisplayNames(targetLocale, { type, style }).of(code);
+  } catch {
+    return;
+  }
+}
+export function getLanguageName(languageCode, locale) {
+  return getDisplayName(languageCode, "language", "long", locale);
+}
+export function getRegionName(regionCode, locale) {
+  return getDisplayName(regionCode, "region", "long", locale);
+}
+export function getCurrencyName(currencyCode, locale) {
+  return getDisplayName(currencyCode, "currency", "long", locale);
+}
+export function compareStrings(a, b, options = {}, locale) {
+  const targetLocale = locale || getLocale();
+  return new Intl.Collator(targetLocale, options).compare(a, b);
+}
+export function sortStrings(strings, options = {}, locale) {
+  const targetLocale = locale || getLocale(), collator = new Intl.Collator(targetLocale, options);
+  return [...strings].sort((a, b) => collator.compare(a, b));
+}
+function toDate(date) {
+  if (date instanceof Date)
+    return date;
+  if (typeof date === "number")
+    return new Date(date);
+  return new Date(date);
+}
+export function getTextDirection(locale) {
+  const targetLocale = locale || getLocale(), lang = (targetLocale.split("-")[0] ?? targetLocale).toLowerCase();
+  return ["ar", "he", "fa", "ur", "yi", "ps", "sd", "ug", "ku", "ckb"].includes(lang) ? "rtl" : "ltr";
+}
+export function isRTL(locale) {
+  return getTextDirection(locale) === "rtl";
+}

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+export type { I18nConfig as TsI18nConfig, TranslationTree, TranslationValue } from '@stacksjs/ts-i18n';
+/**
+ * Stacks i18n - Internationalization System
+ *
+ * A comprehensive internationalization system with support for:
+ * - Translation loading from JSON/YAML files
+ * - Plural forms
+ * - Variable interpolation
+ * - Nested translations
+ * - Date/time formatting
+ * - Number formatting
+ * - Currency formatting
+ * - Relative time formatting
+ *
+ * @example
+ * ```ts
+ * import { t, setLocale, addTranslations } from '@stacksjs/i18n'
+ *
+ * // Add translations
+ * addTranslations('en', {
+ *   greeting: 'Hello, {name}!',
+ *   items: '{count} item | {count} items',
+ * })
+ *
+ * // Use translations
+ * t('greeting', { name: 'World' }) // "Hello, World!"
+ * t('items', { count: 1 }) // "1 item"
+ * t('items', { count: 5 }) // "5 items"
+ *
+ * // Format dates and numbers
+ * formatDate(new Date(), 'long') // "January 8, 2026"
+ * formatNumber(1234567.89) // "1,234,567.89"
+ * formatCurrency(99.99, 'USD') // "$99.99"
+ * ```
+ */
+export * from './translator';
+export * from './formatter';
+export * from './pluralization';
+export * from './loader';
+export * from './types';
+// Re-export the file-loading and type-generation surface from
+// `@stacksjs/ts-i18n`. The library handles disk loading (YAML / TS /
+// JSON), namespace resolution, and `.d.ts` codegen for translation
+// keys; the Stacks-side translator/formatter sits on top of that
+// data with locale management, ICU pluralization, and Intl-backed
+// formatters. Importing both names from `@stacksjs/i18n` keeps the
+// app side from caring which symbol comes from which package.
+export {
+  loadTranslations as loadTranslationsFromDisk,
+  generateTypes as generateI18nTypes,
+  generateTypesFromModule as generateI18nTypesFromModule,
+  generateSampleConfig as generateI18nSampleConfig,
+  writeOutputs as writeI18nOutputs,
+  createTranslator as createSimpleTranslator,
+} from '@stacksjs/ts-i18n';
+// Re-export main functions for convenience
+export {
+  t,
+  trans,
+  tc,
+  te,
+  tm,
+  setLocale,
+  getLocale,
+  addTranslations,
+  loadTranslations,
+  getAvailableLocales,
+  hasTranslation,
+  I18n,
+  createI18n,
+  useI18n,
+} from './translator';
+export {
+  ensureLocalesLoaded,
+  resolveRequestLocale,
+  applyRequestLocale,
+} from './bootstrap';
+export {
+  createLocaleSwitchResponse,
+  localizePath,
+  stripLocalePrefix,
+  type LocaleSwitchConfig,
+} from './locale-switch';
+export {
+  formatDate,
+  formatTime,
+  formatDateTime,
+  formatNumber,
+  formatCurrency,
+  formatPercent,
+  formatRelativeTime,
+  formatList,
+  formatPlural,
+} from './formatter';

package/dist/index.js

@@ -0,0 +1,50 @@
+export * from "./translator";
+export * from "./formatter";
+export * from "./pluralization";
+export * from "./loader";
+export * from "./types";
+export {
+  loadTranslations as loadTranslationsFromDisk,
+  generateTypes as generateI18nTypes,
+  generateTypesFromModule as generateI18nTypesFromModule,
+  generateSampleConfig as generateI18nSampleConfig,
+  writeOutputs as writeI18nOutputs,
+  createTranslator as createSimpleTranslator
+} from "@stacksjs/ts-i18n";
+export {
+  t,
+  trans,
+  tc,
+  te,
+  tm,
+  setLocale,
+  getLocale,
+  addTranslations,
+  loadTranslations,
+  getAvailableLocales,
+  hasTranslation,
+  I18n,
+  createI18n,
+  useI18n
+} from "./translator";
+export {
+  ensureLocalesLoaded,
+  resolveRequestLocale,
+  applyRequestLocale
+} from "./bootstrap";
+export {
+  createLocaleSwitchResponse,
+  localizePath,
+  stripLocalePrefix
+} from "./locale-switch";
+export {
+  formatDate,
+  formatTime,
+  formatDateTime,
+  formatNumber,
+  formatCurrency,
+  formatPercent,
+  formatRelativeTime,
+  formatList,
+  formatPlural
+} from "./formatter";

package/dist/loader.d.ts

@@ -0,0 +1,52 @@
+import type { TranslationMessages, Translations } from './types';
+/**
+ * Load translations from a directory
+ */
+export declare function loadFromDirectory(options: LoaderOptions): Promise<Translations>;
+/**
+ * Load a single translation file
+ */
+export declare function loadFile(filePath: string): Promise<TranslationMessages>;
+/**
+ * Load a single locale from a file or directory
+ */
+export declare function loadLocale(locale: string, path: string): Promise<TranslationMessages>;
+/**
+ * Create a translation loader for a specific directory
+ */
+export declare function createLoader(directory: string, options?: Partial<Omit<LoaderOptions, 'directory'>>): {
+  load: () => unknown;
+  loadLocale: (locale: string, filename: string) => unknown
+};
+/**
+ * Load translations via `@stacksjs/ts-i18n` and register them with the
+ * global translator. This is the recommended path for new projects —
+ * it gets you:
+ *
+ *   - Per-locale subdirectory namespacing (en/auth.yaml → en.auth.*)
+ *   - First-class .ts/.json/.yaml support with consistent error
+ *     messages
+ *   - Optional `.d.ts` codegen via `generateI18nTypes()` so message
+ *     keys autocomplete in `t('…')` calls
+ *
+ * The legacy `loadFromDirectory()` remains for projects that depend
+ * on its specific behavior; new code should prefer this entry.
+ *
+ * @example
+ * ```ts
+ * await loadFromTsI18n({
+ *   translationsDir: path.userI18nPath(),
+ *   defaultLocale: 'en',
+ *   fallbackLocale: 'en',
+ *   sources: ['yaml', 'ts', 'json'],
+ *   optional: true,
+ * })
+ * ```
+ */
+export declare function loadFromTsI18n(config: import('@stacksjs/ts-i18n').I18nConfig): Promise<Translations>;
+export declare interface LoaderOptions {
+  directory: string
+  extensions?: string[]
+  recursive?: boolean
+  namespaceSeparator?: string
+}

package/dist/loader.js

@@ -0,0 +1,144 @@
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { log } from "@stacksjs/logging";
+import { addTranslations, loadTranslations } from "./translator";
+export async function loadFromDirectory(options) {
+  const {
+    directory,
+    extensions = [".json", ".yaml", ".yml", ".ts", ".js"],
+    recursive = !1,
+    namespaceSeparator = "."
+  } = options, translations = {};
+  if (!existsSync(directory)) {
+    log.warn(`[i18n] Translation directory not found: ${directory}`);
+    return translations;
+  }
+  await loadDirectory(directory, translations, extensions, recursive, namespaceSeparator, "");
+  loadTranslations(translations);
+  return translations;
+}
+async function loadDirectory(dir, translations, extensions, recursive, namespaceSeparator, namespace) {
+  const entries = readdirSync(dir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const locale = entry.name;
+      if (isLocaleCode(locale))
+        await loadLocaleDirectory(fullPath, locale, translations, extensions);
+      else if (recursive) {
+        const newNamespace = namespace ? `${namespace}${namespaceSeparator}${entry.name}` : entry.name;
+        await loadDirectory(fullPath, translations, extensions, recursive, namespaceSeparator, newNamespace);
+      }
+    } else if (entry.isFile()) {
+      const ext = extname(entry.name);
+      if (extensions.includes(ext)) {
+        const locale = basename(entry.name, ext);
+        if (!translations[locale])
+          translations[locale] = {};
+        const messages = await loadFile(fullPath);
+        if (namespace)
+          setNested(translations[locale], namespace, messages, namespaceSeparator);
+        else
+          translations[locale] = deepMerge(translations[locale], messages);
+      }
+    }
+  }
+}
+async function loadLocaleDirectory(dir, locale, translations, extensions) {
+  if (!translations[locale])
+    translations[locale] = {};
+  const entries = readdirSync(dir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    if (!entry.isFile())
+      continue;
+    const ext = extname(entry.name);
+    if (!extensions.includes(ext))
+      continue;
+    const fullPath = join(dir, entry.name), namespace = basename(entry.name, ext), messages = await loadFile(fullPath);
+    if (namespace === locale)
+      translations[locale] = deepMerge(translations[locale], messages);
+    else
+      translations[locale][namespace] = messages;
+  }
+}
+export async function loadFile(filePath) {
+  const ext = extname(filePath).toLowerCase(), content = await readFile(filePath, "utf8");
+  switch (ext) {
+    case ".json":
+      try {
+        return JSON.parse(content);
+      } catch {
+        throw Error(`Invalid JSON in translation file: ${filePath}`);
+      }
+    case ".yaml":
+    case ".yml":
+      return parseYaml(content);
+    case ".ts":
+    case ".js": {
+      const module = await import(filePath);
+      return module.default || module;
+    }
+    default:
+      throw Error(`Unsupported file type: ${ext}`);
+  }
+}
+export async function loadLocale(locale, path) {
+  const messages = await loadFile(path);
+  addTranslations(locale, messages);
+  return messages;
+}
+function parseYaml(content) {
+  try {
+    const parsed = Bun.YAML.parse(content);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      throw Error("YAML content must be an object at the root level");
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown YAML parse error";
+    throw Error(`Invalid YAML translation file: ${message}`);
+  }
+}
+function isLocaleCode(str) {
+  return /^[a-z]{2}(?:-[A-Z]{2})?(?:-[A-Za-z]+)?$/i.test(str);
+}
+function setNested(obj, path, value, separator) {
+  const parts = path.split(separator);
+  let current = obj;
+  for (let i = 0;i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!part)
+      continue;
+    if (!current[part] || typeof current[part] === "string")
+      current[part] = {};
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  if (lastPart)
+    current[lastPart] = value;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    if (sourceValue === void 0)
+      continue;
+    const targetValue = result[key];
+    if (typeof sourceValue === "object" && sourceValue !== null && typeof targetValue === "object" && targetValue !== null)
+      result[key] = deepMerge(targetValue, sourceValue);
+    else
+      result[key] = sourceValue;
+  }
+  return result;
+}
+export function createLoader(directory, options = {}) {
+  return {
+    load: () => loadFromDirectory({ directory, ...options }),
+    loadLocale: (locale, filename) => loadLocale(locale, join(directory, filename))
+  };
+}
+export async function loadFromTsI18n(config) {
+  const { loadTranslations: tsLoad } = await import("@stacksjs/ts-i18n"), localeMap = await tsLoad(config);
+  loadTranslations(localeMap);
+  return localeMap;
+}

package/dist/locale-switch.d.ts

@@ -0,0 +1,16 @@
+export declare function stripLocalePrefix(path: string, locales: string[]): { locale: string | null, path: string };
+export declare function localizePath(path: string, locale: string, defaultLocale: string): string;
+/**
+ * Build a redirect Response that sets the `locale` cookie and sends the
+ * visitor to the equivalent path in the requested locale (STX-style).
+ */
+export declare function createLocaleSwitchResponse(request: Request, localeCode: string, config: LocaleSwitchConfig): Response;
+/**
+ * Locale switch redirect — mirrors STX `buildLangPickerScript` path logic
+ * (`/<code>/…` prefixes) so cookie-based fallbacks and `/locale/{code}`
+ * redirects stay consistent with stx-serve i18n routing.
+ */
+export declare interface LocaleSwitchConfig {
+  locales: string[]
+  defaultLocale: string
+}