@coherent.js/i18n 1.0.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Thomas Drouvin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# @coherent.js/i18n
+
+[![npm version](https://img.shields.io/npm/v/@coherent.js/i18n.svg)](https://www.npmjs.com/package/@coherent.js/i18n)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](../../LICENSE)
+[![Node >= 20](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
+
+Internationalization utilities for Coherent.js applications.
+
+- ESM-only, Node 20+
+- Translator + locale management
+- Date/number/currency/list formatters
+
+For a high-level overview and repository-wide instructions, see the root README: ../../README.md
+
+## Installation
+
+```bash
+pnpm add @coherent.js/i18n
+```
+
+## Quick start
+
+JavaScript (ESM):
+```js
+import { createTranslator } from '@coherent.js/i18n/translator';
+
+const t = createTranslator({
+  en: { hello: 'Hello, {name}!' },
+  fr: { hello: 'Bonjour, {name} !' }
+}, { locale: 'en' });
+
+console.log(t('hello', { name: 'Coherent' }));
+```
+
+TypeScript:
+```ts
+import { createTranslator } from '@coherent.js/i18n/translator';
+
+type Messages = {
+  hello: string;
+};
+
+const t = createTranslator<{ en: Messages; fr: Messages }>({
+  en: { hello: 'Hello, {name}!' },
+  fr: { hello: 'Bonjour, {name} !' }
+}, { locale: 'en' });
+
+console.log(t('hello', { name: 'TS' }));
+```
+
+### Formatters and locale
+
+```js
+import { createFormatters } from '@coherent.js/i18n/formatters';
+import { createLocaleManager } from '@coherent.js/i18n/locale';
+
+const locale = createLocaleManager('en-US');
+const fmt = createFormatters(locale.current());
+
+fmt.date(new Date());
+fmt.number(12345.678);
+fmt.currency(1999.99, 'USD');
+```
+
+## Exports
+
+- `@coherent.js/i18n` (index)
+- `@coherent.js/i18n/translator`
+- `@coherent.js/i18n/formatters`
+- `@coherent.js/i18n/locale`
+
+## Development
+
+```bash
+pnpm --filter @coherent.js/i18n run test
+pnpm --filter @coherent.js/i18n run test:watch
+pnpm --filter @coherent.js/i18n run typecheck
+```
+
+## License
+
+MIT © Coherent.js Team

package/dist/index.js

@@ -0,0 +1,725 @@
+// src/translator.js
+var Translator = class {
+  constructor(options = {}) {
+    this.options = {
+      defaultLocale: "en",
+      fallbackLocale: "en",
+      missingKeyHandler: null,
+      interpolation: {
+        prefix: "{{",
+        suffix: "}}"
+      },
+      ...options
+    };
+    this.translations = /* @__PURE__ */ new Map();
+    this.currentLocale = this.options.defaultLocale;
+    this.loadedLocales = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Add translations for a locale
+   * 
+   * @param {string} locale - Locale code (e.g., 'en', 'fr', 'es')
+   * @param {Object} translations - Translation object
+   */
+  addTranslations(locale, translations) {
+    if (!this.translations.has(locale)) {
+      this.translations.set(locale, {});
+    }
+    const existing = this.translations.get(locale);
+    this.translations.set(locale, this.deepMerge(existing, translations));
+    this.loadedLocales.add(locale);
+  }
+  /**
+   * Deep merge objects
+   */
+  deepMerge(target, source) {
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = this.deepMerge(result[key] || {}, value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Set current locale
+   * 
+   * @param {string} locale - Locale code
+   */
+  setLocale(locale) {
+    if (!this.loadedLocales.has(locale)) {
+      console.warn(`Locale ${locale} not loaded, using fallback`);
+      this.currentLocale = this.options.fallbackLocale;
+    } else {
+      this.currentLocale = locale;
+    }
+  }
+  /**
+   * Get current locale
+   * 
+   * @returns {string} Current locale code
+   */
+  getLocale() {
+    return this.currentLocale;
+  }
+  /**
+   * Translate a key
+   * 
+   * @param {string} key - Translation key (supports dot notation)
+   * @param {Object} [params] - Interpolation parameters
+   * @param {string} [locale] - Override locale
+   * @returns {string} Translated string
+   */
+  t(key, params = {}, locale = null) {
+    const targetLocale = locale || this.currentLocale;
+    let translation = this.getTranslation(key, targetLocale);
+    if (translation === null && targetLocale !== this.options.fallbackLocale) {
+      translation = this.getTranslation(key, this.options.fallbackLocale);
+    }
+    if (translation === null) {
+      if (this.options.missingKeyHandler) {
+        return this.options.missingKeyHandler(key, targetLocale);
+      }
+      return key;
+    }
+    if (typeof translation === "object" && params.count !== void 0) {
+      translation = this.selectPlural(translation, params.count, targetLocale);
+    }
+    if (typeof translation === "string") {
+      return this.interpolate(translation, params);
+    }
+    return String(translation);
+  }
+  /**
+   * Get translation from nested object
+   */
+  getTranslation(key, locale) {
+    const translations = this.translations.get(locale);
+    if (!translations) return null;
+    const keys = key.split(".");
+    let value = translations;
+    for (const k of keys) {
+      if (value && typeof value === "object" && k in value) {
+        value = value[k];
+      } else {
+        return null;
+      }
+    }
+    return value;
+  }
+  /**
+   * Select plural form
+   */
+  selectPlural(pluralObject, count, locale) {
+    if (count === 0 && pluralObject.zero) {
+      return pluralObject.zero;
+    }
+    if (typeof Intl !== "undefined" && Intl.PluralRules) {
+      const rules = new Intl.PluralRules(locale);
+      const rule = rules.select(count);
+      if (pluralObject[rule]) {
+        return pluralObject[rule];
+      }
+    }
+    if (count === 1 && pluralObject.one) {
+      return pluralObject.one;
+    } else if (pluralObject.other) {
+      return pluralObject.other;
+    }
+    return pluralObject.one || pluralObject.other || "";
+  }
+  /**
+   * Interpolate parameters into string
+   */
+  interpolate(str, params) {
+    const { prefix, suffix } = this.options.interpolation;
+    let result = str;
+    for (const [key, value] of Object.entries(params)) {
+      const placeholder = `${prefix}${key}${suffix}`;
+      result = result.replace(new RegExp(placeholder, "g"), String(value));
+    }
+    return result;
+  }
+  /**
+   * Check if translation exists
+   * 
+   * @param {string} key - Translation key
+   * @param {string} [locale] - Locale to check
+   * @returns {boolean} True if translation exists
+   */
+  has(key, locale = null) {
+    const targetLocale = locale || this.currentLocale;
+    return this.getTranslation(key, targetLocale) !== null;
+  }
+  /**
+   * Get all translations for current locale
+   * 
+   * @returns {Object} All translations
+   */
+  getTranslations(locale = null) {
+    const targetLocale = locale || this.currentLocale;
+    return this.translations.get(targetLocale) || {};
+  }
+  /**
+   * Get all loaded locales
+   * 
+   * @returns {Array<string>} Array of locale codes
+   */
+  getLoadedLocales() {
+    return Array.from(this.loadedLocales);
+  }
+  /**
+   * Remove translations for a locale
+   * 
+   * @param {string} locale - Locale code
+   */
+  removeLocale(locale) {
+    this.translations.delete(locale);
+    this.loadedLocales.delete(locale);
+    if (this.currentLocale === locale) {
+      this.currentLocale = this.options.defaultLocale;
+    }
+  }
+  /**
+   * Clear all translations
+   */
+  clear() {
+    this.translations.clear();
+    this.loadedLocales.clear();
+    this.currentLocale = this.options.defaultLocale;
+  }
+};
+function createTranslator(options = {}) {
+  return new Translator(options);
+}
+function createScopedTranslator(translator, namespace) {
+  return {
+    t: (key, params, locale) => {
+      return translator.t(`${namespace}.${key}`, params, locale);
+    },
+    has: (key, locale) => {
+      return translator.has(`${namespace}.${key}`, locale);
+    },
+    getLocale: () => translator.getLocale(),
+    setLocale: (locale) => translator.setLocale(locale)
+  };
+}
+
+// src/formatters.js
+var DateFormatter = class {
+  constructor(locale = "en") {
+    this.locale = locale;
+  }
+  /**
+   * Format a date
+   * 
+   * @param {Date|string|number} date - Date to format
+   * @param {Object} [options] - Intl.DateTimeFormat options
+   * @returns {string} Formatted date
+   */
+  format(date, options = {}) {
+    const dateObj = date instanceof Date ? date : new Date(date);
+    if (typeof Intl !== "undefined" && Intl.DateTimeFormat) {
+      const formatter = new Intl.DateTimeFormat(this.locale, options);
+      return formatter.format(dateObj);
+    }
+    return dateObj.toLocaleDateString();
+  }
+  /**
+   * Format date as short (e.g., 1/1/2024)
+   */
+  short(date) {
+    return this.format(date, {
+      year: "numeric",
+      month: "numeric",
+      day: "numeric"
+    });
+  }
+  /**
+   * Format date as medium (e.g., Jan 1, 2024)
+   */
+  medium(date) {
+    return this.format(date, {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+  }
+  /**
+   * Format date as long (e.g., January 1, 2024)
+   */
+  long(date) {
+    return this.format(date, {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+  }
+  /**
+   * Format date as full (e.g., Monday, January 1, 2024)
+   */
+  full(date) {
+    return this.format(date, {
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+  }
+  /**
+   * Format time
+   */
+  time(date, options = {}) {
+    return this.format(date, {
+      hour: "numeric",
+      minute: "numeric",
+      ...options
+    });
+  }
+  /**
+   * Format date and time
+   */
+  dateTime(date, options = {}) {
+    return this.format(date, {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      ...options
+    });
+  }
+  /**
+   * Format relative time (e.g., "2 days ago")
+   */
+  relative(date) {
+    const dateObj = date instanceof Date ? date : new Date(date);
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now - dateObj;
+    const diffSec = Math.floor(diffMs / 1e3);
+    const diffMin = Math.floor(diffSec / 60);
+    const diffHour = Math.floor(diffMin / 60);
+    const diffDay = Math.floor(diffHour / 24);
+    if (typeof Intl !== "undefined" && Intl.RelativeTimeFormat) {
+      const rtf = new Intl.RelativeTimeFormat(this.locale, { numeric: "auto" });
+      if (diffDay > 0) {
+        return rtf.format(-diffDay, "day");
+      } else if (diffHour > 0) {
+        return rtf.format(-diffHour, "hour");
+      } else if (diffMin > 0) {
+        return rtf.format(-diffMin, "minute");
+      } else {
+        return rtf.format(-diffSec, "second");
+      }
+    }
+    if (diffDay > 0) {
+      return `${diffDay} day${diffDay > 1 ? "s" : ""} ago`;
+    } else if (diffHour > 0) {
+      return `${diffHour} hour${diffHour > 1 ? "s" : ""} ago`;
+    } else if (diffMin > 0) {
+      return `${diffMin} minute${diffMin > 1 ? "s" : ""} ago`;
+    } else {
+      return "just now";
+    }
+  }
+};
+var NumberFormatter = class {
+  constructor(locale = "en") {
+    this.locale = locale;
+  }
+  /**
+   * Format a number
+   * 
+   * @param {number} value - Number to format
+   * @param {Object} [options] - Intl.NumberFormat options
+   * @returns {string} Formatted number
+   */
+  format(value, options = {}) {
+    if (typeof Intl !== "undefined" && Intl.NumberFormat) {
+      const formatter = new Intl.NumberFormat(this.locale, options);
+      return formatter.format(value);
+    }
+    return value.toLocaleString();
+  }
+  /**
+   * Format as decimal
+   */
+  decimal(value, decimals = 2) {
+    return this.format(value, {
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    });
+  }
+  /**
+   * Format as percentage
+   */
+  percent(value, decimals = 0) {
+    return this.format(value, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    });
+  }
+  /**
+   * Format as compact (e.g., 1.2K, 3.4M)
+   */
+  compact(value) {
+    if (typeof Intl !== "undefined" && Intl.NumberFormat) {
+      try {
+        const formatter = new Intl.NumberFormat(this.locale, {
+          notation: "compact",
+          compactDisplay: "short"
+        });
+        return formatter.format(value);
+      } catch {
+      }
+    }
+    if (value >= 1e9) {
+      return `${(value / 1e9).toFixed(1)}B`;
+    } else if (value >= 1e6) {
+      return `${(value / 1e6).toFixed(1)}M`;
+    } else if (value >= 1e3) {
+      return `${(value / 1e3).toFixed(1)}K`;
+    }
+    return String(value);
+  }
+  /**
+   * Format with units
+   */
+  unit(value, unit, options = {}) {
+    if (typeof Intl !== "undefined" && Intl.NumberFormat) {
+      try {
+        const formatter = new Intl.NumberFormat(this.locale, {
+          style: "unit",
+          unit,
+          ...options
+        });
+        return formatter.format(value);
+      } catch {
+      }
+    }
+    return `${value} ${unit}`;
+  }
+};
+var CurrencyFormatter = class {
+  constructor(locale = "en", defaultCurrency = "USD") {
+    this.locale = locale;
+    this.defaultCurrency = defaultCurrency;
+  }
+  /**
+   * Format a currency value
+   * 
+   * @param {number} value - Amount to format
+   * @param {string} [currency] - Currency code (e.g., 'USD', 'EUR')
+   * @param {Object} [options] - Additional options
+   * @returns {string} Formatted currency
+   */
+  format(value, currency = null, options = {}) {
+    const currencyCode = currency || this.defaultCurrency;
+    if (typeof Intl !== "undefined" && Intl.NumberFormat) {
+      const formatter = new Intl.NumberFormat(this.locale, {
+        style: "currency",
+        currency: currencyCode,
+        ...options
+      });
+      return formatter.format(value);
+    }
+    return `${currencyCode} ${value.toFixed(2)}`;
+  }
+  /**
+   * Format without decimal places
+   */
+  whole(value, currency = null) {
+    return this.format(value, currency, {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 0
+    });
+  }
+  /**
+   * Format with symbol only (no code)
+   */
+  symbol(value, currency = null) {
+    return this.format(value, currency, {
+      currencyDisplay: "symbol"
+    });
+  }
+  /**
+   * Format with narrow symbol
+   */
+  narrowSymbol(value, currency = null) {
+    return this.format(value, currency, {
+      currencyDisplay: "narrowSymbol"
+    });
+  }
+  /**
+   * Format with code (e.g., USD 100.00)
+   */
+  code(value, currency = null) {
+    return this.format(value, currency, {
+      currencyDisplay: "code"
+    });
+  }
+};
+var ListFormatter = class {
+  constructor(locale = "en") {
+    this.locale = locale;
+  }
+  /**
+   * Format a list
+   * 
+   * @param {Array} items - Items to format
+   * @param {Object} [options] - Formatting options
+   * @returns {string} Formatted list
+   */
+  format(items, options = {}) {
+    if (typeof Intl !== "undefined" && Intl.ListFormat) {
+      const formatter = new Intl.ListFormat(this.locale, options);
+      return formatter.format(items);
+    }
+    if (items.length === 0) return "";
+    if (items.length === 1) return items[0];
+    if (items.length === 2) return `${items[0]} and ${items[1]}`;
+    const last = items[items.length - 1];
+    const rest = items.slice(0, -1);
+    return `${rest.join(", ")}, and ${last}`;
+  }
+  /**
+   * Format as conjunction (and)
+   */
+  and(items) {
+    return this.format(items, { type: "conjunction" });
+  }
+  /**
+   * Format as disjunction (or)
+   */
+  or(items) {
+    return this.format(items, { type: "disjunction" });
+  }
+  /**
+   * Format as unit list
+   */
+  unit(items) {
+    return this.format(items, { type: "unit" });
+  }
+};
+function createFormatters(locale = "en", options = {}) {
+  return {
+    date: new DateFormatter(locale),
+    number: new NumberFormatter(locale),
+    currency: new CurrencyFormatter(locale, options.defaultCurrency),
+    list: new ListFormatter(locale)
+  };
+}
+
+// src/locale.js
+function detectLocale() {
+  if (typeof navigator !== "undefined") {
+    if (navigator.language) {
+      return normalizeLocale(navigator.language);
+    }
+    if (navigator.languages && navigator.languages.length > 0) {
+      return normalizeLocale(navigator.languages[0]);
+    }
+    if (navigator.userLanguage) {
+      return normalizeLocale(navigator.userLanguage);
+    }
+  }
+  return "en";
+}
+function normalizeLocale(locale, keepRegion = false) {
+  if (!locale) return "en";
+  let normalized = locale.toLowerCase().replace("_", "-");
+  if (!keepRegion && normalized.includes("-")) {
+    normalized = normalized.split("-")[0];
+  }
+  return normalized;
+}
+function parseLocale(locale) {
+  const normalized = locale.replace("_", "-");
+  const parts = normalized.split("-");
+  return {
+    language: parts[0]?.toLowerCase() || "en",
+    region: parts[1]?.toUpperCase() || null,
+    script: parts.length > 2 ? parts[1] : null,
+    full: normalized
+  };
+}
+function getLocaleDirection(locale) {
+  const rtlLocales = ["ar", "he", "fa", "ur", "yi"];
+  const language = parseLocale(locale).language;
+  return rtlLocales.includes(language) ? "rtl" : "ltr";
+}
+function isRTL(locale) {
+  return getLocaleDirection(locale) === "rtl";
+}
+function getLocaleDisplayName(locale, displayLocale = "en") {
+  if (typeof Intl !== "undefined" && Intl.DisplayNames) {
+    try {
+      const displayNames = new Intl.DisplayNames([displayLocale], { type: "language" });
+      return displayNames.of(locale);
+    } catch {
+    }
+  }
+  return locale;
+}
+function matchLocale(requestedLocale, availableLocales, defaultLocale = "en") {
+  const normalized = normalizeLocale(requestedLocale);
+  if (availableLocales.includes(normalized)) {
+    return normalized;
+  }
+  const withRegion = normalizeLocale(requestedLocale, true);
+  if (availableLocales.includes(withRegion)) {
+    return withRegion;
+  }
+  const language = parseLocale(requestedLocale).language;
+  const languageMatch = availableLocales.find(
+    (locale) => parseLocale(locale).language === language
+  );
+  if (languageMatch) {
+    return languageMatch;
+  }
+  return availableLocales.includes(defaultLocale) ? defaultLocale : availableLocales[0];
+}
+function getSupportedLocales() {
+  if (typeof navigator !== "undefined" && navigator.languages) {
+    return navigator.languages.map((locale) => normalizeLocale(locale));
+  }
+  return [detectLocale()];
+}
+var LocaleManager = class {
+  constructor(options = {}) {
+    this.options = {
+      defaultLocale: "en",
+      availableLocales: ["en"],
+      storageKey: "coherent-locale",
+      autoDetect: true,
+      ...options
+    };
+    this.currentLocale = this.options.defaultLocale;
+    this.listeners = [];
+    if (this.options.autoDetect) {
+      this.currentLocale = this.detectAndMatch();
+    }
+    this.loadFromStorage();
+  }
+  /**
+   * Detect and match best locale
+   */
+  detectAndMatch() {
+    const detected = detectLocale();
+    return matchLocale(
+      detected,
+      this.options.availableLocales,
+      this.options.defaultLocale
+    );
+  }
+  /**
+   * Get current locale
+   */
+  getLocale() {
+    return this.currentLocale;
+  }
+  /**
+   * Set locale
+   */
+  setLocale(locale) {
+    const matched = matchLocale(
+      locale,
+      this.options.availableLocales,
+      this.options.defaultLocale
+    );
+    if (matched !== this.currentLocale) {
+      const oldLocale = this.currentLocale;
+      this.currentLocale = matched;
+      this.saveToStorage();
+      this.notifyListeners(oldLocale, matched);
+    }
+  }
+  /**
+   * Add locale change listener
+   */
+  onChange(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Notify listeners of locale change
+   */
+  notifyListeners(oldLocale, newLocale) {
+    this.listeners.forEach((listener) => {
+      try {
+        listener(newLocale, oldLocale);
+      } catch (error) {
+        console.error("Error in locale change listener:", error);
+      }
+    });
+  }
+  /**
+   * Save locale to storage
+   */
+  saveToStorage() {
+    if (typeof localStorage !== "undefined") {
+      try {
+        localStorage.setItem(this.options.storageKey, this.currentLocale);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Load locale from storage
+   */
+  loadFromStorage() {
+    if (typeof localStorage !== "undefined") {
+      try {
+        const stored = localStorage.getItem(this.options.storageKey);
+        if (stored) {
+          this.setLocale(stored);
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Get available locales
+   */
+  getAvailableLocales() {
+    return [...this.options.availableLocales];
+  }
+  /**
+   * Check if locale is available
+   */
+  isAvailable(locale) {
+    return this.options.availableLocales.includes(locale);
+  }
+};
+function createLocaleManager(options = {}) {
+  return new LocaleManager(options);
+}
+export {
+  CurrencyFormatter,
+  DateFormatter,
+  ListFormatter,
+  LocaleManager,
+  NumberFormatter,
+  Translator,
+  createFormatters,
+  createLocaleManager,
+  createScopedTranslator,
+  createTranslator,
+  detectLocale,
+  getLocaleDirection,
+  getLocaleDisplayName,
+  getSupportedLocales,
+  isRTL,
+  matchLocale,
+  normalizeLocale,
+  parseLocale
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@coherent.js/i18n",
+  "version": "1.0.0-beta.2",
+  "description": "Internationalization support for Coherent.js applications",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./translator": "./dist/translator.js",
+    "./formatters": "./dist/formatters.js",
+    "./locale": "./dist/locale.js"
+  },
+  "keywords": [
+    "coherent",
+    "i18n",
+    "internationalization",
+    "localization",
+    "translation"
+  ],
+  "author": "Coherent.js Team",
+  "license": "MIT",
+  "peerDependencies": {
+    "@coherent.js/core": "1.0.0-beta.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Tomdrouv1/coherent.js.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "./types/index.d.ts",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "types/"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "clean": "rm -rf dist"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Coherent.js I18n TypeScript Definitions
+ * @module @coherent.js/i18n
+ */
+
+// ===== Translator Types =====
+
+export interface TranslationMessages {
+  [key: string]: string | TranslationMessages;
+}
+
+export interface TranslatorOptions {
+  locale: string;
+  messages: TranslationMessages;
+  fallbackLocale?: string;
+  fallbackMessages?: TranslationMessages;
+  interpolation?: {
+    prefix?: string;
+    suffix?: string;
+  };
+  pluralization?: boolean;
+  contextSeparator?: string;
+}
+
+export class Translator {
+  constructor(options: TranslatorOptions);
+  t(key: string, params?: Record<string, any>): string;
+  translate(key: string, params?: Record<string, any>): string;
+  has(key: string): boolean;
+  setLocale(locale: string): void;
+  getLocale(): string;
+  addMessages(messages: TranslationMessages, locale?: string): void;
+  removeMessages(keys: string[], locale?: string): void;
+}
+
+export function createTranslator(options: TranslatorOptions): Translator;
+export function createScopedTranslator(translator: Translator, scope: string): Translator;
+
+// ===== Formatters Types =====
+
+export interface DateFormatterOptions {
+  locale?: string;
+  timeZone?: string;
+  dateStyle?: 'full' | 'long' | 'medium' | 'short';
+  timeStyle?: 'full' | 'long' | 'medium' | 'short';
+  format?: string;
+}
+
+export class DateFormatter {
+  constructor(locale?: string, options?: DateFormatterOptions);
+  format(date: Date | number | string): string;
+  formatRelative(date: Date | number | string): string;
+  formatDistance(date: Date | number | string, baseDate?: Date | number): string;
+}
+
+export interface NumberFormatterOptions {
+  locale?: string;
+  style?: 'decimal' | 'currency' | 'percent' | 'unit';
+  currency?: string;
+  minimumFractionDigits?: number;
+  maximumFractionDigits?: number;
+  useGrouping?: boolean;
+}
+
+export class NumberFormatter {
+  constructor(locale?: string, options?: NumberFormatterOptions);
+  format(value: number): string;
+  formatCompact(value: number): string;
+  formatPercent(value: number): string;
+}
+
+export interface CurrencyFormatterOptions {
+  locale?: string;
+  currency: string;
+  display?: 'symbol' | 'code' | 'name';
+}
+
+export class CurrencyFormatter {
+  constructor(locale?: string, options?: CurrencyFormatterOptions);
+  format(value: number): string;
+}
+
+export interface ListFormatterOptions {
+  locale?: string;
+  type?: 'conjunction' | 'disjunction' | 'unit';
+  style?: 'long' | 'short' | 'narrow';
+}
+
+export class ListFormatter {
+  constructor(locale?: string, options?: ListFormatterOptions);
+  format(list: string[]): string;
+}
+
+export interface Formatters {
+  date: DateFormatter;
+  number: NumberFormatter;
+  currency: CurrencyFormatter;
+  list: ListFormatter;
+}
+
+export function createFormatters(locale: string): Formatters;
+
+// ===== Locale Manager Types =====
+
+export interface LocaleConfig {
+  code: string;
+  name: string;
+  nativeName: string;
+  direction?: 'ltr' | 'rtl';
+  dateFormat?: string;
+  timeFormat?: string;
+  firstDayOfWeek?: number;
+}
+
+export class LocaleManager {
+  constructor(locales: LocaleConfig[]);
+  addLocale(locale: LocaleConfig): void;
+  removeLocale(code: string): void;
+  getLocale(code: string): LocaleConfig | undefined;
+  getAllLocales(): LocaleConfig[];
+  setCurrentLocale(code: string): void;
+  getCurrentLocale(): LocaleConfig;
+}
+
+export function createLocaleManager(locales: LocaleConfig[]): LocaleManager;
+export function detectLocale(): string;
+export function normalizeLocale(locale: string): string;
+export function isRTL(locale: string): boolean;