@flightdev/i18n 0.1.5

package/dist/adapters/formatjs.js

@@ -0,0 +1,81 @@
+// src/adapters/formatjs.ts
+function formatjs(config) {
+  const { locales, defaultLocale, messages, timeZone, onError, onWarn } = config;
+  let currentLocale = defaultLocale;
+  let intl = null;
+  let createIntl = null;
+  let cache = null;
+  function createIntlInstance(locale) {
+    if (!createIntl) return null;
+    return createIntl(
+      {
+        locale,
+        defaultLocale,
+        messages: messages[locale] ?? {},
+        timeZone,
+        onError: onError ?? ((err) => console.error("[FormatJS]", err)),
+        onWarn: onWarn ?? ((warning) => console.warn("[FormatJS]", warning))
+      },
+      cache
+    );
+  }
+  const adapter = {
+    name: "formatjs",
+    get locale() {
+      return currentLocale;
+    },
+    get locales() {
+      return locales;
+    },
+    async init() {
+      try {
+        const formatjsModule = await import("@formatjs/intl");
+        createIntl = formatjsModule.createIntl;
+        const createIntlCache = formatjsModule.createIntlCache;
+        cache = createIntlCache();
+        intl = createIntlInstance(currentLocale);
+      } catch (error) {
+        throw new Error(
+          "@flightdev/i18n [formatjs]: @formatjs/intl not installed. Run: npm install @formatjs/intl"
+        );
+      }
+    },
+    async setLocale(locale) {
+      if (!locales.includes(locale)) {
+        throw new Error(
+          `@flightdev/i18n [formatjs]: Unsupported locale "${locale}". Supported: ${locales.join(", ")}`
+        );
+      }
+      currentLocale = locale;
+      intl = createIntlInstance(locale);
+    },
+    t(key, options) {
+      if (!intl) {
+        return options?.defaultValue ?? key;
+      }
+      try {
+        const { count, context: _context, defaultValue, ...values } = options ?? {};
+        if (count !== void 0) {
+          values.count = count;
+        }
+        return intl.formatMessage(
+          { id: key, defaultMessage: defaultValue },
+          values
+        );
+      } catch (error) {
+        return options?.defaultValue ?? key;
+      }
+    },
+    exists(key) {
+      return key in (messages[currentLocale] ?? {});
+    },
+    async loadNamespace(_namespace) {
+    }
+  };
+  return adapter;
+}
+var formatjs_default = formatjs;
+export {
+  formatjs_default as default,
+  formatjs
+};

package/dist/adapters/i18next.d.ts

@@ -0,0 +1,15 @@
+import { I18nAdapterFactory, Locale } from '../index.js';
+
+/**
+ * i18next Adapter for @flightdev/i18n
+ */
+
+interface I18nextConfig {
+    locales: Locale[];
+    defaultLocale: Locale;
+    resources?: Record<Locale, Record<string, Record<string, string>>>;
+    loadPath?: string;
+}
+declare const i18next: I18nAdapterFactory<I18nextConfig>;
+
+export { type I18nextConfig, i18next as default, i18next };

package/dist/adapters/i18next.js

@@ -0,0 +1,51 @@
+// src/adapters/i18next.ts
+var i18next = (config) => {
+  const { locales, defaultLocale, resources } = config;
+  let currentLocale = defaultLocale;
+  let i18nInstance = null;
+  const adapter = {
+    name: "i18next",
+    get locale() {
+      return currentLocale;
+    },
+    get locales() {
+      return locales;
+    },
+    async init() {
+      try {
+        const i18nextModule = await import("i18next");
+        await i18nextModule.default.init({
+          lng: currentLocale,
+          fallbackLng: defaultLocale,
+          resources,
+          interpolation: { escapeValue: false }
+        });
+        i18nInstance = i18nextModule.default;
+      } catch {
+        throw new Error("@flightdev/i18n: i18next not installed. Run: npm install i18next");
+      }
+    },
+    async setLocale(locale) {
+      if (!locales.includes(locale)) {
+        throw new Error(`Unsupported locale: ${locale}`);
+      }
+      currentLocale = locale;
+      await i18nInstance?.changeLanguage(locale);
+    },
+    t(key, options) {
+      if (!i18nInstance) return options?.defaultValue ?? key;
+      return i18nInstance.t(key, options);
+    },
+    exists(key) {
+      return i18nInstance?.exists(key) ?? false;
+    },
+    async loadNamespace(_namespace) {
+    }
+  };
+  return adapter;
+};
+var i18next_default = i18next;
+export {
+  i18next_default as default,
+  i18next
+};

package/dist/adapters/lingui.d.ts

@@ -0,0 +1,82 @@
+import { Locale, I18nAdapter } from '../index.js';
+
+/**
+ * Lingui Adapter for @flightdev/i18n
+ *
+ * Lingui provides:
+ * - Macro-based message extraction (`t`, `Trans`)
+ * - Compile-time optimization (3kb runtime)
+ * - ICU MessageFormat compatibility
+ * - First-class React support with hooks
+ * - Automatic extraction of translatable strings
+ *
+ * @example
+ * ```typescript
+ * import { createI18n } from '@flightdev/i18n';
+ * import { lingui } from '@flightdev/i18n/lingui';
+ * import { messages as enMessages } from './locales/en/messages.js';
+ * import { messages as esMessages } from './locales/es/messages.js';
+ *
+ * const i18n = createI18n(lingui({
+ *   locales: ['en', 'es'],
+ *   defaultLocale: 'en',
+ *   catalogs: {
+ *     en: enMessages,
+ *     es: esMessages,
+ *   },
+ * }));
+ *
+ * await i18n.init();
+ * console.log(i18n.t('Hello, {name}!', { name: 'World' })); // "Hello, World!"
+ * ```
+ *
+ * @see https://lingui.dev/
+ */
+
+interface LinguiCatalog {
+    [messageId: string]: string | string[];
+}
+interface LinguiConfig {
+    /** Supported locales */
+    locales: Locale[];
+    /** Default locale */
+    defaultLocale: Locale;
+    /** Message catalogs for each locale (generated by Lingui CLI) */
+    catalogs: Record<Locale, LinguiCatalog>;
+    /** Pre-configured Lingui i18n instance (optional) */
+    instance?: LinguiI18n;
+}
+/** Lingui i18n interface (subset of full API) */
+interface LinguiI18n {
+    load: (catalogs: Record<string, LinguiCatalog>) => void;
+    loadAndActivate: (options: {
+        locale: string;
+        messages: LinguiCatalog;
+    }) => void;
+    activate: (locale: string) => void;
+    _: (id: string | {
+        id: string;
+        message?: string;
+    }, values?: Record<string, unknown>, options?: {
+        message?: string;
+    }) => string;
+    t: (id: string | {
+        id: string;
+        message?: string;
+    }, values?: Record<string, unknown>) => string;
+    locale: string;
+}
+/**
+ * Creates a Lingui adapter for Flight's i18n service.
+ *
+ * Lingui is ideal when you need:
+ * 1. Macro-based extraction (no manual key management)
+ * 2. Smallest possible runtime (~3kb)
+ * 3. ICU MessageFormat with React integration
+ *
+ * @param config - Lingui configuration
+ * @returns I18nAdapter instance
+ */
+declare function lingui(config: LinguiConfig): I18nAdapter;
+
+export { type LinguiCatalog, type LinguiConfig, lingui as default, lingui };

package/dist/adapters/lingui.js

@@ -0,0 +1,73 @@
+// src/adapters/lingui.ts
+function lingui(config) {
+  const { locales, defaultLocale, catalogs } = config;
+  let currentLocale = defaultLocale;
+  let i18nInstance = null;
+  const adapter = {
+    name: "lingui",
+    get locale() {
+      return currentLocale;
+    },
+    get locales() {
+      return locales;
+    },
+    async init() {
+      try {
+        if (config.instance) {
+          i18nInstance = config.instance;
+        } else {
+          const linguiCore = await import("@lingui/core");
+          i18nInstance = linguiCore.i18n;
+        }
+        const catalogsToLoad = {};
+        for (const [locale, messages] of Object.entries(catalogs)) {
+          catalogsToLoad[locale] = messages;
+        }
+        i18nInstance.load(catalogsToLoad);
+        i18nInstance.activate(currentLocale);
+      } catch (error) {
+        throw new Error(
+          "@flightdev/i18n [lingui]: @lingui/core not installed. Run: npm install @lingui/core"
+        );
+      }
+    },
+    async setLocale(locale) {
+      if (!locales.includes(locale)) {
+        throw new Error(
+          `@flightdev/i18n [lingui]: Unsupported locale "${locale}". Supported: ${locales.join(", ")}`
+        );
+      }
+      currentLocale = locale;
+      i18nInstance?.activate(locale);
+    },
+    t(key, options) {
+      if (!i18nInstance) {
+        return options?.defaultValue ?? key;
+      }
+      try {
+        const { count, context: _context, defaultValue, ...values } = options ?? {};
+        if (count !== void 0) {
+          values.count = count;
+        }
+        if (defaultValue) {
+          return i18nInstance._({ id: key, message: defaultValue }, values);
+        }
+        return i18nInstance._(key, values);
+      } catch (error) {
+        return options?.defaultValue ?? key;
+      }
+    },
+    exists(key) {
+      const catalog = catalogs[currentLocale];
+      return catalog ? key in catalog : false;
+    },
+    async loadNamespace(_namespace) {
+    }
+  };
+  return adapter;
+}
+var lingui_default = lingui;
+export {
+  lingui_default as default,
+  lingui
+};

package/dist/adapters/paraglide.d.ts

@@ -0,0 +1,65 @@
+import { Locale, I18nAdapter } from '../index.js';
+
+/**
+ * Paraglide JS Adapter for @flightdev/i18n
+ *
+ * Paraglide is a compiler-based i18n library that:
+ * - Generates type-safe message functions at build time
+ * - Produces tree-shakable output (only used messages in bundle)
+ * - Provides full TypeScript autocompletion
+ * - Zero runtime overhead for unused translations
+ *
+ * @example
+ * ```typescript
+ * import { createI18n } from '@flightdev/i18n';
+ * import { paraglide } from '@flightdev/i18n/paraglide';
+ * import * as m from './paraglide/messages.js';
+ * import { getLocale, setLocale } from './paraglide/runtime.js';
+ *
+ * const i18n = createI18n(paraglide({
+ *   messages: m,
+ *   runtime: { getLocale, setLocale },
+ *   locales: ['en', 'es', 'fr'],
+ *   defaultLocale: 'en',
+ * }));
+ *
+ * await i18n.init();
+ * console.log(i18n.t('greeting', { name: 'World' })); // Uses m.greeting({ name: 'World' })
+ * ```
+ *
+ * @see https://inlang.com/m/gerre34r/library-inlang-paraglideJs
+ */
+
+interface ParaglideMessageFunctions {
+    [key: string]: (params?: Record<string, unknown>) => string;
+}
+interface ParaglideRuntime {
+    getLocale: () => Locale;
+    setLocale: (locale: Locale, options?: {
+        reload?: boolean;
+    }) => void;
+}
+interface ParaglideConfig {
+    /** Message functions generated by Paraglide compiler */
+    messages: ParaglideMessageFunctions;
+    /** Runtime functions from Paraglide */
+    runtime: ParaglideRuntime;
+    /** Supported locales */
+    locales: Locale[];
+    /** Default locale */
+    defaultLocale: Locale;
+}
+/**
+ * Creates a Paraglide adapter for Flight's i18n service.
+ *
+ * Paraglide is unique because:
+ * 1. Messages are compiled to functions at build time
+ * 2. Only imported messages are bundled (tree-shaking)
+ * 3. Full type safety for message keys and parameters
+ *
+ * @param config - Paraglide configuration
+ * @returns I18nAdapter instance
+ */
+declare function paraglide(config: ParaglideConfig): I18nAdapter;
+
+export { type ParaglideConfig, type ParaglideMessageFunctions, type ParaglideRuntime, paraglide as default, paraglide };

package/dist/adapters/paraglide.js

@@ -0,0 +1,43 @@
+// src/adapters/paraglide.ts
+function paraglide(config) {
+  const { messages, runtime, locales, defaultLocale } = config;
+  const adapter = {
+    name: "paraglide",
+    get locale() {
+      return runtime.getLocale();
+    },
+    get locales() {
+      return locales;
+    },
+    async init() {
+    },
+    async setLocale(locale) {
+      if (!locales.includes(locale)) {
+        throw new Error(`@flightdev/i18n [paraglide]: Unsupported locale "${locale}". Supported: ${locales.join(", ")}`);
+      }
+      runtime.setLocale(locale, { reload: false });
+    },
+    t(key, options) {
+      const messageFn = messages[key];
+      if (!messageFn) {
+        if (options?.defaultValue !== void 0) {
+          return options.defaultValue;
+        }
+        return key;
+      }
+      const { count: _count, context: _context, defaultValue: _defaultValue, ...params } = options ?? {};
+      return messageFn(params);
+    },
+    exists(key) {
+      return key in messages;
+    },
+    async loadNamespace(_namespace) {
+    }
+  };
+  return adapter;
+}
+var paraglide_default = paraglide;
+export {
+  paraglide_default as default,
+  paraglide
+};

package/dist/chunk-F5CV7JNA.js

@@ -0,0 +1,76 @@
+// src/index.ts
+function createI18n(adapter, _options = {}) {
+  return {
+    adapter,
+    get locale() {
+      return adapter.locale;
+    },
+    get locales() {
+      return adapter.locales;
+    },
+    init: () => adapter.init(),
+    setLocale: (locale) => adapter.setLocale(locale),
+    t: (key, opts) => adapter.t(key, opts),
+    exists: (key) => adapter.exists(key)
+  };
+}
+function getLocaleFromRequest(request, supportedLocales, defaultLocale) {
+  const acceptLanguage = request.headers.get("accept-language");
+  if (!acceptLanguage) return defaultLocale;
+  const preferred = acceptLanguage.split(",").map((l) => l.split(";")[0]?.trim().split("-")[0] ?? "");
+  return preferred.find((l) => l && supportedLocales.includes(l)) ?? defaultLocale;
+}
+function formatNumber(value, locale, options) {
+  return new Intl.NumberFormat(locale, options).format(value);
+}
+function formatDate(date, locale, options) {
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+function formatRelativeTime(date, locale) {
+  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+  const diff = date.getTime() - Date.now();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (Math.abs(days) > 0) return rtf.format(days, "day");
+  if (Math.abs(hours) > 0) return rtf.format(hours, "hour");
+  if (Math.abs(minutes) > 0) return rtf.format(minutes, "minute");
+  return rtf.format(seconds, "second");
+}
+function createTypedI18n(adapter, _options = {}) {
+  return {
+    adapter,
+    get locale() {
+      return adapter.locale;
+    },
+    get locales() {
+      return adapter.locales;
+    },
+    init: () => adapter.init(),
+    setLocale: (locale) => adapter.setLocale(locale),
+    t: (key, opts) => adapter.t(key, opts),
+    exists: (key) => adapter.exists(key),
+    loadNamespace: (ns) => adapter.loadNamespace(ns)
+  };
+}
+function parseNamespacedKey(key) {
+  const colonIndex = key.indexOf(":");
+  if (colonIndex === -1) {
+    return { namespace: null, key };
+  }
+  return {
+    namespace: key.slice(0, colonIndex),
+    key: key.slice(colonIndex + 1)
+  };
+}
+
+export {
+  createI18n,
+  getLocaleFromRequest,
+  formatNumber,
+  formatDate,
+  formatRelativeTime,
+  createTypedI18n,
+  parseNamespacedKey
+};

package/dist/chunk-O3FQ7FPU.js

@@ -0,0 +1,150 @@
+// src/routing.ts
+var DEFAULT_CONFIG = {
+  routing: "none",
+  prefixDefault: false,
+  cookieName: "FLIGHT_LOCALE",
+  cookieMaxAge: 365 * 24 * 60 * 60,
+  // 1 year
+  ignorePaths: [
+    "/api",
+    "/_flight",
+    "/_next",
+    "/static",
+    "/public",
+    "/favicon.ico",
+    "/robots.txt",
+    "/sitemap.xml"
+  ]
+};
+function matchLocaleFromPath(pathname, config) {
+  const { locales, defaultLocale, prefixDefault = false } = config;
+  for (const locale of locales) {
+    const prefix = `/${locale}`;
+    if (pathname === prefix) {
+      return {
+        locale,
+        pathname: "/",
+        isDefault: locale === defaultLocale,
+        hasLocalePrefix: true
+      };
+    }
+    if (pathname.startsWith(`${prefix}/`)) {
+      return {
+        locale,
+        pathname: pathname.slice(prefix.length) || "/",
+        isDefault: locale === defaultLocale,
+        hasLocalePrefix: true
+      };
+    }
+  }
+  return {
+    locale: defaultLocale,
+    pathname,
+    isDefault: true,
+    hasLocalePrefix: false
+  };
+}
+function matchLocaleFromDomain(hostname, config) {
+  const { domains, defaultLocale } = config;
+  if (!domains) {
+    return defaultLocale;
+  }
+  for (const [locale, domain] of Object.entries(domains)) {
+    if (hostname === domain) {
+      return locale;
+    }
+  }
+  for (const [locale, domain] of Object.entries(domains)) {
+    if (hostname.endsWith(`.${domain}`)) {
+      return locale;
+    }
+  }
+  return defaultLocale;
+}
+function matchLocaleFromCookie(cookieHeader, config) {
+  if (!cookieHeader) {
+    return null;
+  }
+  const { locales, cookieName = DEFAULT_CONFIG.cookieName } = config;
+  const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${cookieName}=([^;]+)`));
+  if (match && match[1]) {
+    const cookieLocale = match[1].trim();
+    if (locales.includes(cookieLocale)) {
+      return cookieLocale;
+    }
+  }
+  return null;
+}
+function buildLocalizedUrl(pathname, locale, config) {
+  const { defaultLocale, prefixDefault = false, routing = "none", domains } = config;
+  switch (routing) {
+    case "domain": {
+      if (domains && domains[locale]) {
+        const domain = domains[locale];
+        return `https://${domain}${pathname}`;
+      }
+      return pathname;
+    }
+    case "prefix": {
+      if (locale === defaultLocale && !prefixDefault) {
+        return pathname;
+      }
+      if (pathname === "/") {
+        return `/${locale}`;
+      }
+      return `/${locale}${pathname}`;
+    }
+    case "cookie":
+    case "none":
+    default:
+      return pathname;
+  }
+}
+function removeLocalePrefix(pathname, config) {
+  const match = matchLocaleFromPath(pathname, config);
+  return match.pathname;
+}
+function getAlternateUrls(pathname, config) {
+  const { locales } = config;
+  const alternates = {};
+  for (const locale of locales) {
+    alternates[locale] = buildLocalizedUrl(pathname, locale, config);
+  }
+  return alternates;
+}
+function shouldIgnorePath(pathname, config) {
+  const { ignorePaths = DEFAULT_CONFIG.ignorePaths } = config;
+  for (const ignore of ignorePaths) {
+    if (typeof ignore === "string") {
+      if (pathname.startsWith(ignore)) {
+        return true;
+      }
+    } else if (ignore instanceof RegExp) {
+      if (ignore.test(pathname)) {
+        return true;
+      }
+    }
+  }
+  const hasExtension = /\.[a-zA-Z0-9]+$/.test(pathname);
+  const isHtml = pathname.endsWith(".html");
+  if (hasExtension && !isHtml) {
+    return true;
+  }
+  return false;
+}
+function generateLocaleCookie(locale, config) {
+  const { cookieName = DEFAULT_CONFIG.cookieName, cookieMaxAge = DEFAULT_CONFIG.cookieMaxAge } = config;
+  return `${cookieName}=${locale}; Path=/; Max-Age=${cookieMaxAge}; SameSite=Lax`;
+}
+
+export {
+  DEFAULT_CONFIG,
+  matchLocaleFromPath,
+  matchLocaleFromDomain,
+  matchLocaleFromCookie,
+  buildLocalizedUrl,
+  removeLocalePrefix,
+  getAlternateUrls,
+  shouldIgnorePath,
+  generateLocaleCookie
+};