@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/i18n.js

@@ -0,0 +1,678 @@
+import path from "node:path";
+import { ErrorCodes, inlineError } from "./error-handling.js";
+import { safeEvaluateObject } from "./safe-evaluator.js";
+let resolvedLoadLocale;
+async function resolveLoadLocale() {
+  if (resolvedLoadLocale !== void 0)
+    return resolvedLoadLocale;
+  try {
+    resolvedLoadLocale = (await import("@stacksjs/ts-i18n")).loadLocale ?? null;
+  } catch {
+    resolvedLoadLocale = null;
+  }
+  return resolvedLoadLocale;
+}
+export const defaultI18nConfig = {
+  defaultLocale: "en",
+  locale: "en",
+  translationsDir: "translations",
+  format: "yaml",
+  fallbackToKey: !0,
+  cache: !0
+};
+const translationsCache = {}, pendingLoads = {}, loadingStates = {};
+export function clearTranslationCache(locale) {
+  if (locale)
+    delete translationsCache[locale];
+  else
+    for (const key of Object.keys(translationsCache))
+      delete translationsCache[key];
+}
+export function getTranslationCacheStats() {
+  const entries = Object.entries(translationsCache).map(([locale, entry]) => ({
+    locale,
+    loadedAt: new Date(entry.loadedAt),
+    keyCount: countKeys(entry.translations)
+  }));
+  return {
+    size: Object.keys(translationsCache).length,
+    locales: Object.keys(translationsCache),
+    entries
+  };
+}
+function countKeys(obj, count = 0) {
+  for (const value of Object.values(obj)) {
+    count++;
+    if (value && typeof value === "object" && !Array.isArray(value))
+      count = countKeys(value, count);
+  }
+  return count;
+}
+function isCacheStale(entry, maxAge = 0) {
+  if (maxAge <= 0)
+    return !1;
+  return Date.now() - entry.loadedAt > maxAge;
+}
+export function getLoadingState(locale) {
+  if (translationsCache[locale])
+    return "loaded";
+  return loadingStates[locale] || "idle";
+}
+export function isLoading(locale) {
+  return loadingStates[locale] === "loading";
+}
+export function isLoaded(locale) {
+  return !!translationsCache[locale];
+}
+export async function preloadTranslations(config, options) {
+  const { locales, parallel = !0, priority = {}, onLocaleLoaded, onComplete, onError } = config, sortedLocales = parallel ? locales : [...locales].sort((a, b) => (priority[b] || 0) - (priority[a] || 0));
+  if (parallel) {
+    const promises = sortedLocales.map(async (locale) => {
+      try {
+        await loadTranslationLazy(locale, options);
+        onLocaleLoaded?.(locale);
+      } catch (error) {
+        onError?.(locale, error instanceof Error ? error : Error(String(error)));
+      }
+    });
+    await Promise.all(promises);
+  } else
+    for (const locale of sortedLocales)
+      try {
+        await loadTranslationLazy(locale, options);
+        onLocaleLoaded?.(locale);
+      } catch (error) {
+        onError?.(locale, error instanceof Error ? error : Error(String(error)));
+      }
+  onComplete?.();
+}
+export function preloadTranslationsBackground(config, options) {
+  queueMicrotask(() => {
+    preloadTranslations(config, options).catch((error) => {
+      if (options.debug)
+        console.error("Background preload error:", error);
+    });
+  });
+}
+export async function loadTranslationLazy(locale, options) {
+  if ({ ...defaultI18nConfig, ...options.i18n }.cache && translationsCache[locale]) {
+    const entry = translationsCache[locale], maxAge = options.i18n?.cacheMaxAge ?? 0;
+    if (!isCacheStale(entry, maxAge))
+      return entry.translations;
+  }
+  if (pendingLoads[locale]?.state === "loading")
+    return pendingLoads[locale].promise;
+  loadingStates[locale] = "loading";
+  const loadPromise = loadTranslationInternal(locale, options).then((translations) => {
+    loadingStates[locale] = "loaded";
+    delete pendingLoads[locale];
+    return translations;
+  }).catch((error) => {
+    loadingStates[locale] = "error";
+    pendingLoads[locale] = {
+      promise: loadPromise,
+      state: "error",
+      error: error instanceof Error ? error : Error(String(error))
+    };
+    throw error;
+  });
+  pendingLoads[locale] = {
+    promise: loadPromise,
+    state: "loading"
+  };
+  return loadPromise;
+}
+export function getTranslationSync(locale) {
+  return translationsCache[locale]?.translations;
+}
+export async function getTranslationAsync(locale, options) {
+  const cached = getTranslationSync(locale);
+  if (cached)
+    return cached;
+  return loadTranslationLazy(locale, options);
+}
+export async function waitForLocale(locale, timeoutMs) {
+  if (translationsCache[locale])
+    return translationsCache[locale].translations;
+  if (pendingLoads[locale]) {
+    if (timeoutMs)
+      return Promise.race([
+        pendingLoads[locale].promise,
+        new Promise((_, reject) => setTimeout(() => reject(Error(`Timeout waiting for locale: ${locale}`)), timeoutMs))
+      ]);
+    return pendingLoads[locale].promise;
+  }
+  throw Error(`Locale "${locale}" is not loading. Call loadTranslationLazy first.`);
+}
+export function getLoadingLocales() {
+  return Object.entries(loadingStates).filter(([_, state]) => state === "loading").map(([locale]) => locale);
+}
+export function cancelPendingLoads(locale) {
+  if (locale) {
+    delete pendingLoads[locale];
+    delete loadingStates[locale];
+  } else {
+    for (const key of Object.keys(pendingLoads))
+      delete pendingLoads[key];
+    for (const key of Object.keys(loadingStates))
+      delete loadingStates[key];
+  }
+}
+async function loadTranslationInternal(locale, options) {
+  const i18nConfig = {
+    ...defaultI18nConfig,
+    ...options.i18n
+  }, translationsDir = path.isAbsolute(i18nConfig.translationsDir) ? i18nConfig.translationsDir : path.resolve(options.root || process.cwd(), i18nConfig.translationsDir);
+  try {
+    const loadLocale = await resolveLoadLocale(), tree = loadLocale ? await loadLocale(locale, {
+      translationsDir,
+      defaultLocale: i18nConfig.defaultLocale,
+      sources: formatToSources(i18nConfig.format)
+    }) : await loadTranslationFromFile(locale, i18nConfig, translationsDir);
+    if (tree === void 0) {
+      if (locale !== i18nConfig.defaultLocale)
+        return loadTranslationInternal(i18nConfig.defaultLocale, options);
+      return {};
+    }
+    const translations = tree;
+    if (i18nConfig.cache)
+      translationsCache[locale] = {
+        translations,
+        loadedAt: Date.now(),
+        locale
+      };
+    return translations;
+  } catch (error) {
+    if (options.debug)
+      console.error(`Error loading translation file for locale "${locale}":`, error);
+    if (locale !== i18nConfig.defaultLocale)
+      return loadTranslationInternal(i18nConfig.defaultLocale, options);
+    return {};
+  }
+}
+async function loadTranslationFromFile(locale, i18nConfig, translationsDir) {
+  const translationFile = path.join(translationsDir, `${locale}${getFileExtension(i18nConfig.format)}`);
+  try {
+    const imported = await import(translationFile);
+    return imported.default || imported;
+  } catch (importError) {
+    try {
+      const fileContent = await Bun.file(translationFile).text();
+      if (i18nConfig.format === "yaml" || i18nConfig.format === "yml")
+        return parseSimpleYaml(fileContent);
+      if (i18nConfig.format === "json")
+        return JSON.parse(fileContent);
+      throw importError;
+    } catch {
+      return;
+    }
+  }
+}
+function getFileExtension(format) {
+  switch (format) {
+    case "yaml":
+      return ".yaml";
+    case "yml":
+      return ".yml";
+    case "js":
+      return ".js";
+    case "ts":
+      return ".ts";
+    case "json":
+    default:
+      return ".json";
+  }
+}
+function parseSimpleYaml(content) {
+  const result = {}, lines = content.split(`
+`), stack = [{ obj: result, indent: -1 }];
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/#.*$/, "").trimEnd();
+    if (!line.trim())
+      continue;
+    const indent = line.search(/\S/);
+    if (indent === -1)
+      continue;
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent)
+      stack.pop();
+    const currentObj = stack[stack.length - 1].obj, match = line.match(/^(\s*)(\S[^:]*):\s*(.*)$/);
+    if (match) {
+      const [, , key, rawValue] = match, trimmedKey = key.trim(), trimmedValue = rawValue.trim();
+      if (trimmedValue === "") {
+        currentObj[trimmedKey] = {};
+        stack.push({ obj: currentObj[trimmedKey], indent });
+      } else
+        currentObj[trimmedKey] = parseYamlValue(trimmedValue);
+    }
+  }
+  return result;
+}
+function parseYamlValue(value) {
+  if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"'))
+    return value.slice(1, -1);
+  const lowerValue = value.toLowerCase();
+  if (lowerValue === "true" || lowerValue === "yes")
+    return !0;
+  if (lowerValue === "false" || lowerValue === "no")
+    return !1;
+  if (lowerValue === "null" || lowerValue === "~")
+    return null;
+  const num = Number(value);
+  if (!Number.isNaN(num) && value !== "")
+    return num;
+  return value;
+}
+function formatToSources(format) {
+  switch (format) {
+    case "yaml":
+    case "yml":
+      return ["yaml"];
+    case "js":
+    case "ts":
+      return ["ts"];
+    case "json":
+    default:
+      return ["json"];
+  }
+}
+export async function loadTranslation(locale, options) {
+  return loadTranslationLazy(locale, options);
+}
+function selectPluralForm(forms, count) {
+  for (const form of forms) {
+    const trimmed = form.trim(), exactMatch = trimmed.match(/^\{(\d+)\}\s*(.*)$/);
+    if (exactMatch) {
+      const exactCount = Number.parseInt(exactMatch[1], 10);
+      if (count === exactCount)
+        return exactMatch[2];
+      continue;
+    }
+    const rangeMatch = trimmed.match(/^\[(\d+),(\d+|\*)\]\s*(.*)$/);
+    if (rangeMatch) {
+      const min = Number.parseInt(rangeMatch[1], 10), max = rangeMatch[2] === "*" ? Number.POSITIVE_INFINITY : Number.parseInt(rangeMatch[2], 10);
+      if (count >= min && count <= max)
+        return rangeMatch[3];
+      continue;
+    }
+  }
+  if (forms.length === 2)
+    return count === 1 ? forms[0].trim() : forms[1].trim();
+  if (count < forms.length)
+    return forms[count].trim();
+  return forms[forms.length - 1].trim();
+}
+export function formatICU(message, params = {}) {
+  return parseICUMessage(message, params);
+}
+function parseICUMessage(message, params) {
+  let result = "", i = 0;
+  while (i < message.length)
+    if (message[i] === "{") {
+      const endIndex = findMatchingBrace(message, i);
+      if (endIndex === -1) {
+        result += message[i];
+        i++;
+        continue;
+      }
+      const placeholder = message.slice(i + 1, endIndex);
+      result += formatICUPlaceholder(placeholder, params);
+      i = endIndex + 1;
+    } else if (message[i] === "'" && i + 1 < message.length)
+      if (message[i + 1] === "'") {
+        result += "'";
+        i += 2;
+      } else if (message[i + 1] === "{" || message[i + 1] === "}") {
+        result += message[i + 1];
+        i += 2;
+      } else {
+        result += message[i];
+        i++;
+      }
+    else {
+      result += message[i];
+      i++;
+    }
+  return result;
+}
+function findMatchingBrace(message, start) {
+  let depth = 0;
+  for (let i = start;i < message.length; i++)
+    if (message[i] === "{")
+      depth++;
+    else if (message[i] === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  return -1;
+}
+function formatICUPlaceholder(placeholder, params) {
+  const parts = splitICUParts(placeholder);
+  if (parts.length === 0)
+    return `{${placeholder}}`;
+  const varName = parts[0].trim(), value = params[varName];
+  if (parts.length === 1)
+    return value !== void 0 ? String(value) : `{${varName}}`;
+  switch (parts[1].trim().toLowerCase()) {
+    case "plural":
+      return formatICUPlural(value, parts.slice(2).join(","), params);
+    case "select":
+      return formatICUSelect(value, parts.slice(2).join(","));
+    case "selectordinal":
+      return formatICUSelectOrdinal(value, parts.slice(2).join(","));
+    case "number":
+      return formatICUNumber(value, parts[2]?.trim());
+    case "date":
+      return formatICUDate(value, parts[2]?.trim());
+    case "time":
+      return formatICUTime(value, parts[2]?.trim());
+    default:
+      return value !== void 0 ? String(value) : `{${placeholder}}`;
+  }
+}
+function splitICUParts(placeholder) {
+  const parts = [];
+  let current = "", depth = 0;
+  for (let i = 0;i < placeholder.length; i++) {
+    const char = placeholder[i];
+    if (char === "{") {
+      depth++;
+      current += char;
+    } else if (char === "}") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else
+      current += char;
+  }
+  if (current)
+    parts.push(current);
+  return parts;
+}
+function formatICUPlural(value, options, params) {
+  const count = Number(value) || 0, parsedOptions = parseICUOptions(options), exactKey = `=${count}`;
+  if (parsedOptions[exactKey])
+    return formatICUPluralContent(parsedOptions[exactKey], count, params);
+  const category = getPluralCategory(count);
+  if (parsedOptions[category])
+    return formatICUPluralContent(parsedOptions[category], count, params);
+  if (parsedOptions.other)
+    return formatICUPluralContent(parsedOptions.other, count, params);
+  return String(count);
+}
+function formatICUPluralContent(content, count, params) {
+  const replaced = content.replace(/#/g, String(count));
+  return parseICUMessage(replaced, params);
+}
+function getPluralCategory(n) {
+  const absN = Math.abs(n), i = Math.floor(absN), v = String(n).includes(".") ? String(n).split(".")[1].length : 0;
+  if (i === 1 && v === 0)
+    return "one";
+  return "other";
+}
+function formatICUSelect(value, options) {
+  const key = String(value || ""), parsedOptions = parseICUOptions(options);
+  if (parsedOptions[key])
+    return parsedOptions[key];
+  return parsedOptions.other || String(value);
+}
+function formatICUSelectOrdinal(value, options) {
+  const count = Number(value) || 0, parsedOptions = parseICUOptions(options), category = getOrdinalCategory(count);
+  if (parsedOptions[category])
+    return parsedOptions[category].replace(/#/g, String(count));
+  if (parsedOptions.other)
+    return parsedOptions.other.replace(/#/g, String(count));
+  return String(count);
+}
+function getOrdinalCategory(n) {
+  const absN = Math.abs(n), mod10 = absN % 10, mod100 = absN % 100;
+  if (mod10 === 1 && mod100 !== 11)
+    return "one";
+  if (mod10 === 2 && mod100 !== 12)
+    return "two";
+  if (mod10 === 3 && mod100 !== 13)
+    return "few";
+  return "other";
+}
+function parseICUOptions(options) {
+  const result = {}, regex = /(\w+|=\d+)\s*\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
+  let match = regex.exec(options);
+  while (match !== null) {
+    result[match[1]] = match[2];
+    match = regex.exec(options);
+  }
+  return result;
+}
+function formatICUNumber(value, style) {
+  const num = Number(value);
+  if (Number.isNaN(num))
+    return String(value);
+  switch (style) {
+    case "integer":
+      return Math.floor(num).toLocaleString();
+    case "percent":
+      return `${(num * 100).toFixed(0)}%`;
+    case "currency":
+      return num.toLocaleString(void 0, { style: "currency", currency: "USD" });
+    default:
+      return num.toLocaleString();
+  }
+}
+function formatICUDate(value, style) {
+  const date = value instanceof Date ? value : new Date(String(value));
+  if (Number.isNaN(date.getTime()))
+    return String(value);
+  const options = {};
+  switch (style) {
+    case "short":
+      options.dateStyle = "short";
+      break;
+    case "medium":
+      options.dateStyle = "medium";
+      break;
+    case "long":
+      options.dateStyle = "long";
+      break;
+    case "full":
+      options.dateStyle = "full";
+      break;
+    default:
+      options.dateStyle = "medium";
+  }
+  return date.toLocaleDateString(void 0, options);
+}
+function formatICUTime(value, style) {
+  const date = value instanceof Date ? value : new Date(String(value));
+  if (Number.isNaN(date.getTime()))
+    return String(value);
+  const options = {};
+  switch (style) {
+    case "short":
+      options.timeStyle = "short";
+      break;
+    case "medium":
+      options.timeStyle = "medium";
+      break;
+    case "long":
+      options.timeStyle = "long";
+      break;
+    case "full":
+      options.timeStyle = "full";
+      break;
+    default:
+      options.timeStyle = "short";
+  }
+  return date.toLocaleTimeString(void 0, options);
+}
+export function isICUFormat(message) {
+  return /\{[^}]+,\s*(?:plural|select|selectordinal|number|date|time)\s*,/.test(message);
+}
+export function getTranslation(key, translations, fallbackToKey = !0, params = {}) {
+  const parts = key.split(".");
+  let value = translations;
+  for (const part of parts) {
+    if (value === void 0 || value === null)
+      break;
+    value = value[part];
+  }
+  if (value === void 0 || value === null)
+    return fallbackToKey ? key : "";
+  let result = String(value);
+  if (isICUFormat(result))
+    return formatICU(result, params);
+  if (result.includes("|") && "count" in params) {
+    const count = Number(params.count), forms = result.split("|");
+    result = selectPluralForm(forms, count);
+  }
+  for (const [paramKey, paramValue] of Object.entries(params)) {
+    const escapedKey = paramKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(`:${escapedKey}`, "g"), String(paramValue));
+  }
+  return result;
+}
+const RTL_LANGUAGES = new Set([
+  "ar",
+  "arc",
+  "ckb",
+  "dv",
+  "fa",
+  "he",
+  "khw",
+  "ks",
+  "nqo",
+  "prs",
+  "ps",
+  "sd",
+  "syr",
+  "ug",
+  "ur",
+  "uz-af",
+  "yi"
+]), RTL_SCRIPTS = new Set([
+  "adlm",
+  "arab",
+  "aran",
+  "hebr",
+  "nkoo",
+  "rohg",
+  "syrc",
+  "thaa",
+  "yezi"
+]);
+export function getLocaleDirection(locale) {
+  if (!locale)
+    return "ltr";
+  const subtags = locale.trim().toLowerCase().replace(/_/g, "-").split("-"), language = subtags[0];
+  if (!language)
+    return "ltr";
+  const script = subtags[1]?.length === 4 ? subtags[1] : void 0;
+  if (script)
+    return RTL_SCRIPTS.has(script) ? "rtl" : "ltr";
+  if (subtags.length > 1 && RTL_LANGUAGES.has(`${language}-${subtags[1]}`))
+    return "rtl";
+  return RTL_LANGUAGES.has(language) ? "rtl" : "ltr";
+}
+export function isRtlLocale(locale) {
+  return getLocaleDirection(locale) === "rtl";
+}
+export async function processTranslateDirective(template, context, filePath, options) {
+  let output = template;
+  const fixedTranslateRegex = /@translate\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\{[^}]*\})\s*)?\)([\s\S]*?)@endtranslate/g, i18nConfig = {
+    ...defaultI18nConfig,
+    ...options.i18n
+  }, translations = await loadTranslation(i18nConfig.locale, options);
+  context.__translations = translations;
+  context.__locale = i18nConfig.locale;
+  context.__i18nConfig = i18nConfig;
+  output = await replaceAsync(output, fixedTranslateRegex, async (_match, key, paramsStr, content, _offset) => {
+    try {
+      let params = {};
+      if (paramsStr)
+        try {
+          const approaches = [
+            () => JSON.parse(paramsStr),
+            () => {
+              const jsonStr = `{"data":${paramsStr}}`, parsed = JSON.parse(jsonStr);
+              return typeof parsed.data === "object" ? parsed.data : {};
+            },
+            () => {
+              return safeEvaluateObject(paramsStr, context);
+            }
+          ];
+          for (const approach of approaches)
+            try {
+              params = approach();
+              if (Object.keys(params).length > 0)
+                break;
+            } catch {}
+        } catch (error) {
+          if (options.debug)
+            console.error("Error parsing parameters for @translate directive:", error);
+        }
+      return getTranslation(key, translations, i18nConfig.fallbackToKey, params) || content.trim();
+    } catch (error) {
+      if (options.debug)
+        console.error("Error processing @translate directive:", error);
+      return inlineError("Translate", `Error in @translate('${key}'): ${error instanceof Error ? error.message : String(error)}`, ErrorCodes.EVALUATION_ERROR);
+    }
+  });
+  const inlineTranslateRegex = /@translate\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\{[^}]+\})\s*)?\)/g;
+  if (options.debug) {
+    console.warn(`Processing translations in template. Sections: ${output.includes("<h2>Translation with Parameters</h2>") ? "Parameters section found" : "Parameters section missing"}`);
+    const matches = [...output.matchAll(inlineTranslateRegex)];
+    console.warn(`Found ${matches.length} @translate matches`);
+    matches.forEach((m, i) => console.warn(`Match ${i}: ${m[0]}, Key: ${m[1]}, Params: ${m[2] || "none"}`));
+  }
+  output = await replaceAsync(output, /@translate\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\{[^}]*\})\s*)?\)/g, async (_match, key, paramsStr, _offset) => {
+    try {
+      let params = {};
+      if (paramsStr)
+        try {
+          const approaches = [
+            () => JSON.parse(paramsStr),
+            () => {
+              const jsonStr = `{"data":${paramsStr}}`, parsed = JSON.parse(jsonStr);
+              return typeof parsed.data === "object" ? parsed.data : {};
+            },
+            () => {
+              return safeEvaluateObject(paramsStr, context);
+            }
+          ];
+          for (const approach of approaches)
+            try {
+              params = approach();
+              if (Object.keys(params).length > 0)
+                break;
+            } catch {}
+        } catch (error) {
+          if (options.debug)
+            console.error("Error parsing parameters for @translate directive:", error);
+        }
+      return getTranslation(key, translations, i18nConfig.fallbackToKey, params);
+    } catch (error) {
+      if (options.debug)
+        console.error("Error processing @translate directive:", error);
+      return inlineError("Translate", `Error in @translate('${key}'): ${error instanceof Error ? error.message : String(error)}`, ErrorCodes.EVALUATION_ERROR);
+    }
+  });
+  return output;
+}
+async function replaceAsync(str, regex, asyncFn) {
+  const promises = [];
+  str.replace(regex, (match, ...args) => {
+    const promise = asyncFn(match, ...args).then((replacement) => ({
+      match,
+      replacement
+    }));
+    promises.push(promise);
+    return match;
+  });
+  return (await Promise.all(promises)).reduce((str, { match, replacement }) => str.replace(match, replacement), str);
+}
+export function createTranslateFilter(translations, fallbackToKey = !0) {
+  return (value, params = {}) => {
+    return getTranslation(value, translations, fallbackToKey, params);
+  };
+}