@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/i18n/index.js

@@ -0,0 +1,597 @@
+// src/i18n/pluralization.ts
+var pluralizationRules = {
+  /**
+   * English, German, Spanish, Italian, Portuguese, etc.
+   * 1 = singular, everything else = plural
+   */
+  en: (count) => count === 1 ? 0 : 1,
+  de: (count) => count === 1 ? 0 : 1,
+  es: (count) => count === 1 ? 0 : 1,
+  it: (count) => count === 1 ? 0 : 1,
+  pt: (count) => count === 1 ? 0 : 1,
+  nl: (count) => count === 1 ? 0 : 1,
+  /**
+   * French, Brazilian Portuguese
+   * 0 and 1 = singular, everything else = plural
+   */
+  fr: (count) => count <= 1 ? 0 : 1,
+  "pt-BR": (count) => count <= 1 ? 0 : 1,
+  /**
+   * Japanese, Chinese, Korean, Vietnamese, Thai
+   * No plural forms
+   */
+  ja: () => 0,
+  zh: () => 0,
+  ko: () => 0,
+  vi: () => 0,
+  th: () => 0,
+  /**
+   * Russian, Ukrainian, Serbian, Croatian, Bosnian
+   * Three forms: one, few (2-4), many (5+)
+   */
+  ru: (count) => {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (mod10 === 1 && mod100 !== 11) return 0;
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 10 || mod100 >= 20)) return 1;
+    return 2;
+  },
+  uk: (count) => {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (mod10 === 1 && mod100 !== 11) return 0;
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 10 || mod100 >= 20)) return 1;
+    return 2;
+  },
+  /**
+   * Polish
+   * Three forms with different rules
+   */
+  pl: (count) => {
+    if (count === 1) return 0;
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 10 || mod100 >= 20)) return 1;
+    return 2;
+  },
+  /**
+   * Czech, Slovak
+   * Three forms: 1, 2-4, 5+
+   */
+  cs: (count) => {
+    if (count === 1) return 0;
+    if (count >= 2 && count <= 4) return 1;
+    return 2;
+  },
+  sk: (count) => {
+    if (count === 1) return 0;
+    if (count >= 2 && count <= 4) return 1;
+    return 2;
+  },
+  /**
+   * Arabic
+   * Six forms
+   */
+  ar: (count) => {
+    if (count === 0) return 0;
+    if (count === 1) return 1;
+    if (count === 2) return 2;
+    const mod100 = count % 100;
+    if (mod100 >= 3 && mod100 <= 10) return 3;
+    if (mod100 >= 11) return 4;
+    return 5;
+  }
+};
+function getPluralizationRule(locale) {
+  if (pluralizationRules[locale]) {
+    return pluralizationRules[locale];
+  }
+  const langCode = locale.split("-")[0];
+  if (pluralizationRules[langCode]) {
+    return pluralizationRules[langCode];
+  }
+  return pluralizationRules.en;
+}
+function selectPluralForm(translation, count, rule) {
+  const forms = translation.split("|");
+  const index = rule(Math.abs(count));
+  return forms[index] ?? forms[forms.length - 1];
+}
+
+// src/i18n/Translator.ts
+var Translator = class {
+  locale;
+  fallbackLocale;
+  messages;
+  pluralizationRules;
+  onMissingKey;
+  constructor(options) {
+    this.locale = options.locale;
+    this.fallbackLocale = options.fallbackLocale;
+    this.messages = options.messages ?? {};
+    this.pluralizationRules = options.pluralizationRules ?? {};
+    this.onMissingKey = options.onMissingKey;
+  }
+  /**
+   * Translate a key.
+   */
+  t(key, replacements) {
+    return this.translate(key, replacements);
+  }
+  /**
+   * Translate a key with count for pluralization.
+   */
+  tc(key, count, replacements) {
+    const translation = this.getRawTranslation(key, this.locale) ?? this.getRawTranslation(key, this.fallbackLocale);
+    if (!translation) {
+      return this.handleMissingKey(key);
+    }
+    const rule = this.pluralizationRules[this.locale] ?? getPluralizationRule(this.locale);
+    const pluralized = selectPluralForm(translation, count, rule);
+    return this.applyReplacements(pluralized, { count, ...replacements });
+  }
+  /**
+   * Check if a translation exists.
+   */
+  has(key, locale) {
+    const targetLocale = locale ?? this.locale;
+    return this.getRawTranslation(key, targetLocale) !== void 0;
+  }
+  /**
+   * Get the current locale.
+   */
+  getLocale() {
+    return this.locale;
+  }
+  /**
+   * Set the current locale.
+   */
+  setLocale(locale) {
+    this.locale = locale;
+  }
+  /**
+   * Get the fallback locale.
+   */
+  getFallbackLocale() {
+    return this.fallbackLocale;
+  }
+  /**
+   * Set the fallback locale.
+   */
+  setFallbackLocale(locale) {
+    this.fallbackLocale = locale;
+  }
+  /**
+   * Add messages for a locale.
+   */
+  addMessages(locale, messages) {
+    this.messages[locale] = this.mergeMessages(
+      this.messages[locale] ?? {},
+      messages
+    );
+  }
+  /**
+   * Set messages for a locale (replaces existing).
+   */
+  setMessages(locale, messages) {
+    this.messages[locale] = messages;
+  }
+  /**
+   * Get all messages for a locale.
+   */
+  getMessages(locale) {
+    return this.messages[locale ?? this.locale] ?? {};
+  }
+  /**
+   * Get available locales.
+   */
+  getAvailableLocales() {
+    return Object.keys(this.messages);
+  }
+  /**
+   * Set a custom pluralization rule.
+   */
+  setPluralizationRule(locale, rule) {
+    this.pluralizationRules[locale] = rule;
+  }
+  /**
+   * Internal translate method.
+   */
+  translate(key, replacements) {
+    let translation = this.getRawTranslation(key, this.locale);
+    if (translation === void 0 && this.fallbackLocale) {
+      translation = this.getRawTranslation(key, this.fallbackLocale);
+    }
+    if (translation === void 0) {
+      return this.handleMissingKey(key);
+    }
+    return this.applyReplacements(translation, replacements);
+  }
+  /**
+   * Get raw translation without replacements.
+   */
+  getRawTranslation(key, locale) {
+    if (!locale) return void 0;
+    const messages = this.messages[locale];
+    if (!messages) return void 0;
+    const parts = key.split(".");
+    let result = messages;
+    for (const part of parts) {
+      if (result === void 0 || typeof result === "string") {
+        return void 0;
+      }
+      result = result[part];
+    }
+    return typeof result === "string" ? result : void 0;
+  }
+  /**
+   * Apply replacements to a translation string.
+   */
+  applyReplacements(translation, replacements) {
+    if (!replacements) return translation;
+    let result = translation;
+    for (const [key, value] of Object.entries(replacements)) {
+      result = result.replace(new RegExp(`:${key}`, "g"), String(value)).replace(new RegExp(`\\{${key}\\}`, "g"), String(value));
+    }
+    return result;
+  }
+  /**
+   * Handle missing translation key.
+   */
+  handleMissingKey(key) {
+    if (this.onMissingKey) {
+      const result = this.onMissingKey(key, this.locale);
+      if (result !== void 0) {
+        return result;
+      }
+    }
+    return key;
+  }
+  /**
+   * Deep merge messages.
+   */
+  mergeMessages(target, source) {
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      if (typeof value === "object" && value !== null && typeof result[key] === "object" && result[key] !== null) {
+        result[key] = this.mergeMessages(
+          result[key],
+          value
+        );
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+};
+
+// src/i18n/loaders/JsonLoader.ts
+import { readdir, readFile } from "fs/promises";
+import { join, basename, extname } from "path";
+var JsonLoader = class {
+  basePath;
+  cache = /* @__PURE__ */ new Map();
+  useCache;
+  constructor(basePath, options = {}) {
+    this.basePath = basePath;
+    this.useCache = options.cache ?? true;
+  }
+  /**
+   * Load all translations for a locale.
+   */
+  async load(locale) {
+    const cacheKey = locale;
+    if (this.useCache && this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const localePath = join(this.basePath, locale);
+    const messages = {};
+    try {
+      const files = await readdir(localePath);
+      for (const file of files) {
+        if (extname(file) !== ".json") continue;
+        const namespace = basename(file, ".json");
+        const filePath = join(localePath, file);
+        const content = await readFile(filePath, "utf-8");
+        try {
+          messages[namespace] = JSON.parse(content);
+        } catch {
+          console.warn(`Failed to parse translation file: ${filePath}`);
+        }
+      }
+    } catch {
+    }
+    if (this.useCache) {
+      this.cache.set(cacheKey, messages);
+    }
+    return messages;
+  }
+  /**
+   * Load translations for a specific namespace.
+   */
+  async loadNamespace(locale, namespace) {
+    const cacheKey = `${locale}:${namespace}`;
+    if (this.useCache && this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const filePath = join(this.basePath, locale, `${namespace}.json`);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const messages = JSON.parse(content);
+      if (this.useCache) {
+        this.cache.set(cacheKey, messages);
+      }
+      return messages;
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Get available locales.
+   */
+  async getAvailableLocales() {
+    try {
+      const entries = await readdir(this.basePath, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Clear the cache.
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Enable or disable caching.
+   */
+  setCaching(enabled) {
+    this.useCache = enabled;
+    if (!enabled) {
+      this.clearCache();
+    }
+  }
+};
+
+// src/i18n/I18nManager.ts
+var I18nManager = class {
+  config;
+  translator;
+  loader;
+  loadedLocales = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = config;
+    this.loader = config.path ? new JsonLoader(config.path) : null;
+    this.translator = new Translator({
+      locale: config.locale,
+      fallbackLocale: config.fallbackLocale,
+      messages: config.messages ?? {}
+    });
+    if (config.messages) {
+      for (const locale of Object.keys(config.messages)) {
+        this.loadedLocales.add(locale);
+      }
+    }
+  }
+  /**
+   * Translate a key.
+   */
+  t(key, replacements) {
+    return this.translator.t(key, replacements);
+  }
+  /**
+   * Translate a key with count for pluralization.
+   */
+  tc(key, count, replacements) {
+    return this.translator.tc(key, count, replacements);
+  }
+  /**
+   * Check if a translation exists.
+   */
+  has(key, locale) {
+    return this.translator.has(key, locale);
+  }
+  /**
+   * Get the current locale.
+   */
+  getLocale() {
+    return this.translator.getLocale();
+  }
+  /**
+   * Set the current locale.
+   */
+  setLocale(locale) {
+    this.translator.setLocale(locale);
+  }
+  /**
+   * Get the fallback locale.
+   */
+  getFallbackLocale() {
+    return this.translator.getFallbackLocale();
+  }
+  /**
+   * Set the fallback locale.
+   */
+  setFallbackLocale(locale) {
+    this.translator.setFallbackLocale(locale);
+  }
+  /**
+   * Load translations for a locale.
+   */
+  async loadLocale(locale) {
+    if (this.loadedLocales.has(locale)) return;
+    if (!this.loader) return;
+    const messages = await this.loader.load(locale);
+    this.translator.addMessages(locale, messages);
+    this.loadedLocales.add(locale);
+  }
+  /**
+   * Load translations for multiple locales.
+   */
+  async loadLocales(locales) {
+    await Promise.all(locales.map((locale) => this.loadLocale(locale)));
+  }
+  /**
+   * Load a specific namespace for a locale.
+   */
+  async loadNamespace(locale, namespace) {
+    if (!this.loader?.loadNamespace) return;
+    const messages = await this.loader.loadNamespace(locale, namespace);
+    const currentMessages = this.translator.getMessages(locale);
+    this.translator.setMessages(locale, {
+      ...currentMessages,
+      [namespace]: messages
+    });
+  }
+  /**
+   * Add messages for a locale.
+   */
+  addMessages(locale, messages) {
+    this.translator.addMessages(locale, messages);
+    this.loadedLocales.add(locale);
+  }
+  /**
+   * Get all messages for a locale.
+   */
+  getMessages(locale) {
+    return this.translator.getMessages(locale);
+  }
+  /**
+   * Get available locales.
+   */
+  getAvailableLocales() {
+    return this.translator.getAvailableLocales();
+  }
+  /**
+   * Get available locales from loader.
+   */
+  async getLoaderLocales() {
+    if (!this.loader?.getAvailableLocales) return [];
+    return this.loader.getAvailableLocales();
+  }
+  /**
+   * Check if a locale is loaded.
+   */
+  isLocaleLoaded(locale) {
+    return this.loadedLocales.has(locale);
+  }
+  /**
+   * Get the underlying translator.
+   */
+  getTranslator() {
+    return this.translator;
+  }
+  /**
+   * Set a custom loader.
+   */
+  setLoader(loader) {
+    this.loader = loader;
+  }
+  /**
+   * Create a scoped translator for a specific locale.
+   */
+  forLocale(locale) {
+    return new Translator({
+      locale,
+      fallbackLocale: this.config.fallbackLocale,
+      messages: {
+        [locale]: this.translator.getMessages(locale),
+        ...this.config.fallbackLocale ? { [this.config.fallbackLocale]: this.translator.getMessages(this.config.fallbackLocale) } : {}
+      }
+    });
+  }
+};
+var globalI18n = null;
+function createI18n(config) {
+  return new I18nManager(config);
+}
+function setI18n(i18n) {
+  globalI18n = i18n;
+}
+function getI18n() {
+  if (!globalI18n) {
+    throw new Error("I18n manager not initialized. Call setI18n() first.");
+  }
+  return globalI18n;
+}
+function t(key, replacements) {
+  return getI18n().t(key, replacements);
+}
+function tc(key, count, replacements) {
+  return getI18n().tc(key, count, replacements);
+}
+
+// src/i18n/loaders/MemoryLoader.ts
+var MemoryLoader = class {
+  messages;
+  constructor(messages = {}) {
+    this.messages = messages;
+  }
+  /**
+   * Load all translations for a locale.
+   */
+  async load(locale) {
+    return this.messages[locale] ?? {};
+  }
+  /**
+   * Load translations for a specific namespace.
+   */
+  async loadNamespace(locale, namespace) {
+    const localeMessages = this.messages[locale];
+    if (!localeMessages) return {};
+    const namespaceMessages = localeMessages[namespace];
+    if (typeof namespaceMessages === "object" && namespaceMessages !== null) {
+      return namespaceMessages;
+    }
+    return {};
+  }
+  /**
+   * Get available locales.
+   */
+  async getAvailableLocales() {
+    return Object.keys(this.messages);
+  }
+  /**
+   * Add messages for a locale.
+   */
+  addMessages(locale, messages) {
+    this.messages[locale] = {
+      ...this.messages[locale],
+      ...messages
+    };
+  }
+  /**
+   * Set messages for a locale (replaces existing).
+   */
+  setMessages(locale, messages) {
+    this.messages[locale] = messages;
+  }
+  /**
+   * Remove messages for a locale.
+   */
+  removeLocale(locale) {
+    delete this.messages[locale];
+  }
+  /**
+   * Clear all messages.
+   */
+  clear() {
+    this.messages = {};
+  }
+};
+export {
+  I18nManager,
+  JsonLoader,
+  MemoryLoader,
+  Translator,
+  createI18n,
+  getI18n,
+  getPluralizationRule,
+  pluralizationRules,
+  selectPluralForm,
+  setI18n,
+  t,
+  tc
+};

package/dist/index-9_Jzj5jo.d.ts

@@ -0,0 +1,7 @@
+import { MiddlewareHandler } from 'hono';
+
+type Middleware = MiddlewareHandler;
+declare function defineMiddleware(handler: MiddlewareHandler): MiddlewareHandler;
+declare function jsonResponse(data: unknown, status?: number): Response;
+
+export { type Middleware as M, defineMiddleware as d, jsonResponse as j };