@zoyth/simple-site-framework 1.0.0

package/dist/lib/i18n/index.mjs

@@ -0,0 +1,621 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/i18n/config.ts
+var config_exports = {};
+__export(config_exports, {
+  __resetI18nConfig__: () => __resetI18nConfig__,
+  defaultLocale: () => defaultLocale,
+  getDefaultLocale: () => getDefaultLocale,
+  getI18nConfig: () => getI18nConfig,
+  getLocaleCookieConfig: () => getLocaleCookieConfig,
+  getLocaleLabel: () => getLocaleLabel,
+  getLocaleLabels: () => getLocaleLabels,
+  getLocaleName: () => getLocaleName,
+  getLocaleNames: () => getLocaleNames,
+  getLocalePrefix: () => getLocalePrefix,
+  getLocales: () => getLocales,
+  getRtlLocales: () => getRtlLocales,
+  isI18nConfigInitialized: () => isI18nConfigInitialized,
+  isLocaleDetectionEnabled: () => isLocaleDetectionEnabled,
+  isSupportedLocale: () => isSupportedLocale,
+  localeLabels: () => localeLabels,
+  localeNames: () => localeNames,
+  locales: () => locales,
+  setI18nConfig: () => setI18nConfig
+});
+function setI18nConfig(config) {
+  if (!config.locales || config.locales.length === 0) {
+    throw new Error("i18n config must define at least one locale");
+  }
+  if (!config.defaultLocale) {
+    throw new Error("i18n config must define a default locale");
+  }
+  if (!config.locales.includes(config.defaultLocale)) {
+    throw new Error(
+      `Default locale "${config.defaultLocale}" must be included in locales array: [${config.locales.join(", ")}]`
+    );
+  }
+  const configWithDefaults = {
+    ...config,
+    localePrefix: config.localePrefix || "as-needed",
+    localeDetection: config.localeDetection !== false,
+    // Default to true
+    localeNames: config.localeNames || {},
+    localeLabels: config.localeLabels || {},
+    rtlLocales: config.rtlLocales || [],
+    localeCookie: {
+      name: config.localeCookie?.name || "NEXT_LOCALE",
+      maxAge: config.localeCookie?.maxAge || 365 * 24 * 60 * 60,
+      // 1 year
+      sameSite: config.localeCookie?.sameSite || "lax"
+    },
+    slugTranslations: config.slugTranslations || {}
+  };
+  globalI18nConfig = configWithDefaults;
+}
+function getI18nConfig() {
+  if (!globalI18nConfig) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        "\u26A0\uFE0F  i18n configuration not initialized. Using legacy defaults.\nCall setI18nConfig() in your layout before using i18n features.\nSee docs/i18n/MIGRATION.md for setup instructions."
+      );
+    }
+    return {
+      locales: ["fr", "en"],
+      defaultLocale: "fr",
+      localePrefix: "as-needed",
+      localeDetection: true,
+      localeNames: { fr: "Fran\xE7ais", en: "English" },
+      localeLabels: { fr: "FR", en: "EN" },
+      rtlLocales: [],
+      localeCookie: {
+        name: "NEXT_LOCALE",
+        maxAge: 365 * 24 * 60 * 60,
+        sameSite: "lax"
+      },
+      slugTranslations: {}
+    };
+  }
+  return globalI18nConfig;
+}
+function isI18nConfigInitialized() {
+  return globalI18nConfig !== null;
+}
+function __resetI18nConfig__() {
+  globalI18nConfig = null;
+}
+function getLocales() {
+  return getI18nConfig().locales;
+}
+function getDefaultLocale() {
+  return getI18nConfig().defaultLocale;
+}
+function getLocalePrefix() {
+  return getI18nConfig().localePrefix || "as-needed";
+}
+function getLocaleNames() {
+  return getI18nConfig().localeNames || {};
+}
+function getLocaleLabels() {
+  return getI18nConfig().localeLabels || {};
+}
+function getRtlLocales() {
+  return getI18nConfig().rtlLocales || [];
+}
+function isLocaleDetectionEnabled() {
+  return getI18nConfig().localeDetection !== false;
+}
+function getLocaleCookieConfig() {
+  const config = getI18nConfig();
+  return {
+    name: config.localeCookie?.name || "NEXT_LOCALE",
+    maxAge: config.localeCookie?.maxAge || 365 * 24 * 60 * 60,
+    sameSite: config.localeCookie?.sameSite || "lax"
+  };
+}
+function isSupportedLocale(locale) {
+  return getLocales().includes(locale);
+}
+function getLocaleName(locale) {
+  const names = getLocaleNames();
+  return names[locale] || locale;
+}
+function getLocaleLabel(locale) {
+  const labels = getLocaleLabels();
+  return labels[locale] || locale.toUpperCase();
+}
+var globalI18nConfig, locales, defaultLocale, localeNames, localeLabels;
+var init_config = __esm({
+  "src/lib/i18n/config.ts"() {
+    "use strict";
+    globalI18nConfig = null;
+    locales = ["fr", "en"];
+    defaultLocale = "fr";
+    localeNames = {
+      fr: "Fran\xE7ais",
+      en: "English"
+    };
+    localeLabels = {
+      fr: "FR",
+      en: "EN"
+    };
+  }
+});
+
+// src/lib/i18n/index.ts
+init_config();
+init_config();
+
+// src/lib/i18n/locale-cookie.ts
+init_config();
+var LOCALE_COOKIE_NAME = "NEXT_LOCALE";
+function getLocaleFromCookie() {
+  if (typeof document === "undefined") return null;
+  try {
+    const cookieConfig = getLocaleCookieConfig();
+    const cookieName = cookieConfig.name;
+    const cookie = document.cookie.split("; ").find((row) => row.startsWith(`${cookieName}=`));
+    if (!cookie) return null;
+    const value = cookie.split("=")[1];
+    if (isSupportedLocale(value)) {
+      return value;
+    }
+    return null;
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("getLocaleFromCookie: i18n config not initialized");
+    }
+    return null;
+  }
+}
+function setLocaleCookie(locale) {
+  if (typeof document === "undefined") return;
+  try {
+    if (!isSupportedLocale(locale)) {
+      console.warn(`Attempted to set unsupported locale: ${locale}`);
+      return;
+    }
+    const cookieConfig = getLocaleCookieConfig();
+    document.cookie = `${cookieConfig.name}=${locale}; max-age=${cookieConfig.maxAge}; path=/; SameSite=${cookieConfig.sameSite}`;
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("setLocaleCookie: i18n config not initialized");
+    }
+  }
+}
+
+// src/lib/i18n/slug-translations.ts
+var defaultSlugTranslations = {
+  fr: {
+    "/marketing-par-courriel": "/email-marketing",
+    "/courriels-transactionnels": "/transactional-emails",
+    "/forfaits": "/pricing",
+    "/nous-contacter": "/contact",
+    "/a-propos": "/about",
+    "/politique-de-confidentialite": "/privacy-policy",
+    "/conditions-dutilisation": "/terms-of-service",
+    "/politique-anti-pourriel": "/anti-spam-policy"
+  },
+  en: {
+    "/email-marketing": "/marketing-par-courriel",
+    "/transactional-emails": "/courriels-transactionnels",
+    "/pricing": "/forfaits",
+    "/contact": "/nous-contacter",
+    "/about": "/a-propos",
+    "/privacy-policy": "/politique-de-confidentialite",
+    "/terms-of-service": "/conditions-dutilisation",
+    "/anti-spam-policy": "/politique-anti-pourriel"
+  }
+};
+function translateSlug(path, fromLocale, toLocale, customTranslations) {
+  let configTranslations = {};
+  try {
+    const { getI18nConfig: getI18nConfig2 } = (init_config(), __toCommonJS(config_exports));
+    const config = getI18nConfig2();
+    configTranslations = config.slugTranslations || {};
+  } catch {
+  }
+  const translations = mergeTranslations(
+    defaultSlugTranslations,
+    configTranslations,
+    customTranslations || {}
+  );
+  const translationMap = translations[fromLocale];
+  if (!translationMap) {
+    return path;
+  }
+  if (translationMap[path]) {
+    return translationMap[path];
+  }
+  for (const [fromSlug, toSlug] of Object.entries(translationMap)) {
+    if (path.startsWith(fromSlug + "/")) {
+      return path.replace(fromSlug, toSlug);
+    }
+  }
+  return path;
+}
+function mergeTranslations(...translations) {
+  const merged = {};
+  for (const trans of translations) {
+    for (const [locale, slugs] of Object.entries(trans)) {
+      if (!merged[locale]) {
+        merged[locale] = {};
+      }
+      Object.assign(merged[locale], slugs);
+    }
+  }
+  return merged;
+}
+
+// src/lib/i18n/formatters.ts
+function formatDate(date, locale, options) {
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+function formatNumber(value, locale, options) {
+  return new Intl.NumberFormat(locale, options).format(value);
+}
+function formatCurrency(amount, locale, currency, options) {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    ...options
+  }).format(amount);
+}
+function formatRelativeTime(value, unit, locale, options) {
+  return new Intl.RelativeTimeFormat(locale, options).format(value, unit);
+}
+function formatDateRange(startDate, endDate, locale, options) {
+  const formatter = new Intl.DateTimeFormat(locale, options);
+  if ("formatRange" in formatter) {
+    return formatter.formatRange(startDate, endDate);
+  }
+  return `${formatter.format(startDate)} \u2013 ${formatter.format(endDate)}`;
+}
+function formatList(items, locale) {
+  if (typeof Intl !== "undefined" && "ListFormat" in Intl) {
+    return new Intl.ListFormat(locale).format(items);
+  }
+  if (items.length === 0) return "";
+  if (items.length === 1) return items[0];
+  if (items.length === 2) {
+    const connector2 = locale === "fr" ? " et " : " and ";
+    return items.join(connector2);
+  }
+  const last = items[items.length - 1];
+  const rest = items.slice(0, -1);
+  const connector = locale === "fr" ? " et " : ", and ";
+  return rest.join(", ") + connector + last;
+}
+function formatFileSize(bytes, locale, decimals = 2) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const value = bytes / Math.pow(k, i);
+  return `${formatNumber(value, locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  })} ${sizes[i]}`;
+}
+function getRelativeTime(date, locale, options) {
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = date.getTime() - now.getTime();
+  const diffSecs = Math.round(diffMs / 1e3);
+  const diffMins = Math.round(diffSecs / 60);
+  const diffHours = Math.round(diffMins / 60);
+  const diffDays = Math.round(diffHours / 24);
+  const diffWeeks = Math.round(diffDays / 7);
+  const diffMonths = Math.round(diffDays / 30);
+  const diffYears = Math.round(diffDays / 365);
+  if (Math.abs(diffSecs) < 60) {
+    return formatRelativeTime(diffSecs, "second", locale, options);
+  } else if (Math.abs(diffMins) < 60) {
+    return formatRelativeTime(diffMins, "minute", locale, options);
+  } else if (Math.abs(diffHours) < 24) {
+    return formatRelativeTime(diffHours, "hour", locale, options);
+  } else if (Math.abs(diffDays) < 7) {
+    return formatRelativeTime(diffDays, "day", locale, options);
+  } else if (Math.abs(diffWeeks) < 4) {
+    return formatRelativeTime(diffWeeks, "week", locale, options);
+  } else if (Math.abs(diffMonths) < 12) {
+    return formatRelativeTime(diffMonths, "month", locale, options);
+  } else {
+    return formatRelativeTime(diffYears, "year", locale, options);
+  }
+}
+
+// src/lib/i18n/middleware.ts
+import { NextResponse } from "next/server";
+function createI18nMiddleware(config) {
+  return function middleware(request) {
+    const { pathname } = request.nextUrl;
+    const pathnameLocale = getLocaleFromPathname(pathname, config);
+    if (pathnameLocale) {
+      if (!config.locales.includes(pathnameLocale)) {
+        return redirectToLocale(request, config.defaultLocale, pathname, config);
+      }
+      const response = NextResponse.next();
+      setLocaleCookie2(response, pathnameLocale, config);
+      return response;
+    }
+    const detectedLocale = detectLocale(request, config);
+    const prefixMode = config.localePrefix || "as-needed";
+    if (prefixMode === "always") {
+      return redirectToLocale(request, detectedLocale, pathname, config);
+    } else if (prefixMode === "as-needed") {
+      if (detectedLocale !== config.defaultLocale) {
+        return redirectToLocale(request, detectedLocale, pathname, config);
+      }
+      const response = NextResponse.next();
+      setLocaleCookie2(response, config.defaultLocale, config);
+      return response;
+    } else {
+      const response = NextResponse.next();
+      setLocaleCookie2(response, detectedLocale, config);
+      return response;
+    }
+  };
+}
+function getLocaleFromPathname(pathname, config) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return null;
+  }
+  const firstSegment = segments[0];
+  if (config.locales.includes(firstSegment)) {
+    return firstSegment;
+  }
+  return null;
+}
+function detectLocale(request, config) {
+  const cookieName = config.localeCookie?.name || "NEXT_LOCALE";
+  const cookieLocale = request.cookies.get(cookieName)?.value;
+  if (cookieLocale && config.locales.includes(cookieLocale)) {
+    return cookieLocale;
+  }
+  if (config.localeDetection !== false) {
+    const acceptLanguage = request.headers.get("accept-language");
+    const browserLocale = negotiateLanguage(acceptLanguage, config.locales);
+    if (browserLocale) {
+      return browserLocale;
+    }
+  }
+  return config.defaultLocale;
+}
+function negotiateLanguage(acceptLanguage, supportedLocales) {
+  if (!acceptLanguage) {
+    return null;
+  }
+  const preferences = parseAcceptLanguage(acceptLanguage);
+  for (const pref of preferences) {
+    if (supportedLocales.includes(pref.locale)) {
+      return pref.locale;
+    }
+    const languageCode = pref.locale.split("-")[0];
+    if (supportedLocales.includes(languageCode)) {
+      return languageCode;
+    }
+    const match = supportedLocales.find(
+      (locale) => locale.startsWith(languageCode + "-") || locale === languageCode
+    );
+    if (match) {
+      return match;
+    }
+  }
+  return null;
+}
+function parseAcceptLanguage(header) {
+  const preferences = [];
+  const parts = header.split(",").map((p) => p.trim());
+  for (const part of parts) {
+    const [locale, ...rest] = part.split(";").map((p) => p.trim());
+    let quality = 1;
+    const qParam = rest.find((p) => p.startsWith("q="));
+    if (qParam) {
+      const qValue = parseFloat(qParam.substring(2));
+      if (!isNaN(qValue)) {
+        quality = qValue;
+      }
+    }
+    preferences.push({
+      locale: locale.toLowerCase(),
+      quality
+    });
+  }
+  preferences.sort((a, b) => b.quality - a.quality);
+  return preferences;
+}
+function redirectToLocale(request, locale, pathname, config) {
+  const url = request.nextUrl.clone();
+  const pathWithoutLocale = removeLocalePrefix(pathname, config);
+  url.pathname = `/${locale}${pathWithoutLocale}`;
+  const response = NextResponse.redirect(url);
+  setLocaleCookie2(response, locale, config);
+  return response;
+}
+function removeLocalePrefix(pathname, config) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return "/";
+  }
+  const firstSegment = segments[0];
+  if (config.locales.includes(firstSegment)) {
+    const remaining = segments.slice(1);
+    return remaining.length > 0 ? `/${remaining.join("/")}` : "/";
+  }
+  return pathname;
+}
+function setLocaleCookie2(response, locale, config) {
+  const cookieConfig = config.localeCookie || {};
+  response.cookies.set({
+    name: cookieConfig.name || "NEXT_LOCALE",
+    value: locale,
+    maxAge: cookieConfig.maxAge || 365 * 24 * 60 * 60,
+    // 1 year
+    path: "/",
+    sameSite: cookieConfig.sameSite || "lax"
+  });
+}
+
+// src/lib/i18n/utils.ts
+init_config();
+function isRtlLocale(locale) {
+  const rtlLocales = getRtlLocales();
+  return rtlLocales.includes(locale);
+}
+function getTextDirection(locale) {
+  return isRtlLocale(locale) ? "rtl" : "ltr";
+}
+function validateLocale(locale) {
+  return isSupportedLocale(locale);
+}
+function getAlternateLocales(currentLocale) {
+  try {
+    const config = getI18nConfig();
+    return config.locales.filter((l) => l !== currentLocale);
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("getAlternateLocales: i18n config not initialized, returning []");
+    }
+    return [];
+  }
+}
+function normalizeLocale(locale) {
+  return locale.toLowerCase().split("-")[0];
+}
+function matchLocale(locale) {
+  try {
+    const config = getI18nConfig();
+    const normalized = normalizeLocale(locale);
+    if (config.locales.includes(locale)) {
+      return locale;
+    }
+    if (config.locales.includes(normalized)) {
+      return normalized;
+    }
+    const match = config.locales.find((l) => l.startsWith(normalized));
+    if (match) {
+      return match;
+    }
+    return null;
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("matchLocale: i18n config not initialized, returning null");
+    }
+    return null;
+  }
+}
+function getLocaleAutonym(locale) {
+  const autonyms = {
+    en: "English",
+    fr: "Fran\xE7ais",
+    es: "Espa\xF1ol",
+    de: "Deutsch",
+    it: "Italiano",
+    pt: "Portugu\xEAs",
+    ru: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
+    ja: "\u65E5\u672C\u8A9E",
+    ko: "\uD55C\uAD6D\uC5B4",
+    zh: "\u4E2D\u6587",
+    ar: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
+    he: "\u05E2\u05D1\u05E8\u05D9\u05EA",
+    hi: "\u0939\u093F\u0928\u094D\u0926\u0940",
+    tr: "T\xFCrk\xE7e",
+    pl: "Polski",
+    nl: "Nederlands",
+    sv: "Svenska",
+    da: "Dansk",
+    no: "Norsk",
+    fi: "Suomi",
+    cs: "\u010Ce\u0161tina",
+    el: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC",
+    th: "\u0E44\u0E17\u0E22",
+    vi: "Ti\u1EBFng Vi\u1EC7t",
+    id: "Bahasa Indonesia",
+    ms: "Bahasa Melayu",
+    uk: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430"
+  };
+  try {
+    const { getLocaleNames: getLocaleNames2 } = (init_config(), __toCommonJS(config_exports));
+    const names = getLocaleNames2();
+    if (names[locale]) {
+      return names[locale];
+    }
+  } catch {
+  }
+  return autonyms[locale] || locale.toUpperCase();
+}
+function formatLocaleDisplay(locale, format = "name") {
+  if (format === "code") {
+    return locale;
+  }
+  if (format === "label") {
+    try {
+      const { getLocaleLabel: getLocaleLabel2 } = (init_config(), __toCommonJS(config_exports));
+      return getLocaleLabel2(locale);
+    } catch {
+      return locale.toUpperCase();
+    }
+  }
+  return getLocaleAutonym(locale);
+}
+export {
+  LOCALE_COOKIE_NAME,
+  createI18nMiddleware,
+  defaultLocale,
+  defaultSlugTranslations,
+  formatCurrency,
+  formatDate,
+  formatDateRange,
+  formatFileSize,
+  formatList,
+  formatLocaleDisplay,
+  formatNumber,
+  formatRelativeTime,
+  getAlternateLocales,
+  getDefaultLocale,
+  getI18nConfig,
+  getLocaleAutonym,
+  getLocaleCookieConfig,
+  getLocaleFromCookie,
+  getLocaleLabel,
+  getLocaleLabels,
+  getLocaleName,
+  getLocaleNames,
+  getLocalePrefix,
+  getLocales,
+  getRelativeTime,
+  getRtlLocales,
+  getTextDirection,
+  isI18nConfigInitialized,
+  isLocaleDetectionEnabled,
+  isRtlLocale,
+  isSupportedLocale,
+  locales,
+  matchLocale,
+  normalizeLocale,
+  setI18nConfig,
+  setLocaleCookie,
+  translateSlug,
+  validateLocale
+};
+//# sourceMappingURL=index.mjs.map