intor 1.0.39 → 2.0.0

package/dist/next/middleware/index.cjs

@@ -3,9 +3,9 @@
 var server = require('next/server');
 var headers = require('next/headers');
 
-// src/adapters/next-client/routing/utils/create-response.ts
+// src/adapters/next/middleware/utils/create-response.ts
 
-// src/adapters/next-client/routing/utils/set-locale-cookie-edge.ts
+// src/adapters/next/middleware/utils/set-locale-cookie-edge.ts
 function setLocaleCookieEdge({
   request,
   response,
@@ -14,13 +14,9 @@ function setLocaleCookieEdge({
   override = false
   // Default to not override existed cookie
 }) {
-  if (cookie.disabled || !cookie.autoSetCookie) {
-    return;
-  }
+  if (cookie.disabled || !cookie.autoSetCookie) return;
   const isCookieExists = request.cookies.has(cookie.name);
-  if (isCookieExists && !override) {
-    return;
-  }
+  if (isCookieExists && !override) return;
   response.cookies.set(cookie.name, locale, {
     maxAge: cookie.maxAge,
     path: cookie.path,
@@ -31,49 +27,98 @@ function setLocaleCookieEdge({
   });
 }
 
-// src/adapters/next-client/constants/header-key-constants.ts
-var DEFAULT_PATHNAME_HEADER_NAME = "x-intor-pathname";
+// src/adapters/next/shared/constants/pathname-header-name.ts
+var PATHNAME_HEADER_NAME = "x-intor-pathname";
 
-// src/adapters/next-client/routing/utils/set-pathname-header.ts
+// src/adapters/next/middleware/utils/set-pathname-header.ts
 var setPathnameHeader = ({
   request,
   response,
-  key = DEFAULT_PATHNAME_HEADER_NAME
+  key = PATHNAME_HEADER_NAME
 }) => {
   const pathname = request.nextUrl.pathname;
   response.headers.set(key, pathname);
   return response;
 };
 
-// src/adapters/next-client/utils/locale-prefix-pathname.ts
+// src/shared/constants/prefix-placeholder.ts
+var PREFIX_PLACEHOLDER = "{locale}";
+
+// src/adapters/next/shared/utils/locale-prefix-pathname.ts
 var localePrefixPathname = ({
   config,
   pathname: standardizedPathname,
   locale
 }) => {
-  const { routing, prefixPlaceHolder } = config;
+  const { routing } = config;
   const { prefix } = routing;
   if (prefix !== "none" && !locale) {
     throw new Error('No locale when using prefix "all", "except-default"');
   }
   if (prefix === "all") {
-    return standardizedPathname.replace(prefixPlaceHolder, locale);
+    return standardizedPathname.replace(PREFIX_PLACEHOLDER, locale);
   }
   if (prefix === "except-default") {
     if (locale === config.defaultLocale) {
-      return standardizedPathname.replace(`/${prefixPlaceHolder}`, "");
+      return standardizedPathname.replace(`/${PREFIX_PLACEHOLDER}`, "");
     } else {
-      return standardizedPathname.replace(prefixPlaceHolder, locale);
+      return standardizedPathname.replace(PREFIX_PLACEHOLDER, locale);
+    }
+  }
+  return standardizedPathname.replace(`/${PREFIX_PLACEHOLDER}`, "");
+};
+
+// src/shared/utils/locale/normalize-locale.ts
+var normalizeLocale = (locale = "", supportedLocales = []) => {
+  if (!locale || supportedLocales.length === 0) return;
+  const toCanonical = (input) => {
+    try {
+      return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
+    } catch {
+      return;
+    }
+  };
+  const canonicalLocale = toCanonical(locale);
+  if (!canonicalLocale) return;
+  const supportedCanonicalMap = /* @__PURE__ */ new Map();
+  for (const l of supportedLocales) {
+    const normalized = toCanonical(l);
+    if (normalized) {
+      supportedCanonicalMap.set(normalized, l);
+    }
+  }
+  if (supportedCanonicalMap.has(canonicalLocale)) {
+    return supportedCanonicalMap.get(canonicalLocale);
+  }
+  const baseLang = canonicalLocale.split("-")[0];
+  for (const [key, original] of supportedCanonicalMap) {
+    const supportedBase = key.split("-")[0];
+    if (supportedBase === baseLang) {
+      return original;
     }
   }
-  return standardizedPathname.replace(`/${prefixPlaceHolder}`, "");
+  return;
+};
+
+// src/shared/utils/locale/resolve-preferred-locale.ts
+var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
+  if (!acceptLanguageHeader || !supportedLocales || supportedLocales.length === 0) {
+    return;
+  }
+  const supportedLocalesSet = new Set(supportedLocales);
+  const preferred = acceptLanguageHeader.split(",").map((part) => {
+    const [lang, qValue] = part.split(";");
+    const q = qValue ? parseFloat(qValue.split("=")[1]) : 1;
+    if (isNaN(q)) {
+      return { lang: lang.trim(), q: 0 };
+    }
+    return { lang: lang.trim(), q };
+  }).sort((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
+  return preferred;
 };
 
 // src/shared/utils/pathname/normalize-pathname.ts
 var normalizePathname = (rawPathname, options = {}) => {
-  if (typeof rawPathname !== "string") {
-    throw new TypeError("Expected rawPathname to be a string");
-  }
   const length = rawPathname.length;
   let start = 0;
   let end = length - 1;
@@ -144,18 +189,18 @@ var standardizePathname = ({
   config,
   pathname
 }) => {
-  const { routing, prefixPlaceHolder } = config;
+  const { routing } = config;
   const { basePath } = routing;
   const parts = [
     normalizePathname(basePath),
-    normalizePathname(prefixPlaceHolder),
+    PREFIX_PLACEHOLDER,
     normalizePathname(pathname)
   ];
   const standardizedPathname = parts.join("/").replace(/\/{2,}/g, "/");
   return normalizePathname(standardizedPathname);
 };
 
-// src/adapters/next-client/utils/localize-pathname.ts
+// src/adapters/next/shared/utils/localize-pathname.ts
 var localizePathname = ({
   config,
   pathname: rawPathname,
@@ -181,7 +226,7 @@ var localizePathname = ({
   };
 };
 
-// src/adapters/next-client/routing/utils/create-response.ts
+// src/adapters/next/middleware/utils/create-response.ts
 var createResponse = ({
   request,
   config,
@@ -199,18 +244,10 @@ var createResponse = ({
   });
   url.pathname = localePrefixedPathname;
   let response;
-  switch (responseType) {
-    case "next": {
-      response = server.NextResponse.next();
-      break;
-    }
-    case "redirect": {
-      response = server.NextResponse.redirect(url);
-      break;
-    }
-    default: {
-      throw new Error(`Unsupported responseType: ${responseType}`);
-    }
+  if (responseType === "redirect") {
+    response = server.NextResponse.redirect(url);
+  } else {
+    response = server.NextResponse.next();
   }
   if (locale) {
     setLocaleCookieEdge({
@@ -224,57 +261,6 @@ var createResponse = ({
   const finalResponse = setPathnameHeader({ request, response });
   return finalResponse;
 };
-
-// src/shared/utils/locale/normalize-locale.ts
-var normalizeLocale = (locale = "", supportedLocales = []) => {
-  if (!locale || supportedLocales.length === 0) return void 0;
-  const toCanonical = (input) => {
-    try {
-      return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
-    } catch {
-      return void 0;
-    }
-  };
-  const canonicalLocale = toCanonical(locale);
-  if (!canonicalLocale) return void 0;
-  const supportedCanonicalMap = /* @__PURE__ */ new Map();
-  for (const l of supportedLocales) {
-    const normalized = toCanonical(l);
-    if (normalized) {
-      supportedCanonicalMap.set(normalized, l);
-    }
-  }
-  if (supportedCanonicalMap.has(canonicalLocale)) {
-    return supportedCanonicalMap.get(canonicalLocale);
-  }
-  const baseLang = canonicalLocale.split("-")[0];
-  for (const [key, original] of supportedCanonicalMap) {
-    const supportedBase = key.split("-")[0];
-    if (supportedBase === baseLang) {
-      return original;
-    }
-  }
-  return void 0;
-};
-
-// src/shared/utils/locale/resolve-preferred-locale.ts
-var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
-  if (!acceptLanguageHeader || !supportedLocales || supportedLocales.length === 0) {
-    return;
-  }
-  const supportedLocalesSet = new Set(supportedLocales);
-  const preferred = acceptLanguageHeader.split(",").map((part) => {
-    const [lang, qValue] = part.split(";");
-    const q = qValue ? parseFloat(qValue.split("=")[1]) : 1;
-    if (isNaN(q)) {
-      return { lang: lang.trim(), q: 0 };
-    }
-    return { lang: lang.trim(), q };
-  }).sort((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
-  return preferred;
-};
-
-// src/adapters/next-client/routing/utils/determine-initial-locale.ts
 var determineInitialLocale = async (config) => {
   const { defaultLocale, supportedLocales, routing } = config;
   let initialLocale = defaultLocale;
@@ -289,7 +275,7 @@ var determineInitialLocale = async (config) => {
   return initialLocale;
 };
 
-// src/adapters/next-client/routing/handle-prefix/handle-prefix-all.ts
+// src/adapters/next/middleware/handle-prefix/handle-prefix-all.ts
 var handlePrefixAll = async ({
   request,
   config
@@ -330,7 +316,7 @@ var handlePrefixAll = async ({
   });
 };
 
-// src/adapters/next-client/routing/handle-prefix/handle-prefix-except-default.ts
+// src/adapters/next/middleware/handle-prefix/handle-prefix-except-default.ts
 var handlePrefixExceptDefault = async ({
   request,
   config
@@ -383,7 +369,7 @@ var handlePrefixExceptDefault = async ({
   });
 };
 
-// src/adapters/next-client/routing/handle-prefix/handle-prefix-none.ts
+// src/adapters/next/middleware/handle-prefix/handle-prefix-none.ts
 var handlePrefixNone = async ({
   request,
   config
@@ -395,7 +381,7 @@ var handlePrefixNone = async ({
   return createResponse({ request, config, locale });
 };
 
-// src/adapters/next-client/routing/intor-middleware.ts
+// src/adapters/next/middleware/intor-middleware.ts
 async function intorMiddleware({
   request,
   config
@@ -410,5 +396,5 @@ async function intorMiddleware({
   return await handlePrefixAll({ request, config });
 }
 
-exports.PATHNAME_HEADER_NAME = DEFAULT_PATHNAME_HEADER_NAME;
+exports.PATHNAME_HEADER_NAME = PATHNAME_HEADER_NAME;
 exports.intorMiddleware = intorMiddleware;

package/dist/next/middleware/index.d.cts

@@ -2,30 +2,51 @@ import { NextRequest } from 'next/server';
 import { Level, NormalizerConfig, FormatterConfig, LoggerPreset } from 'logry/edge';
 import { Locale, LocaleNamespaceMessages, FallbackLocalesMap } from 'intor-translator';
 
-type InitCookieOptions = {
+type CookieRawOptions = {
+    /** Completely disable cookie usage (no read, no write, no lookup by name) - default: false */
     disabled?: boolean;
+    /** Allow the system to automatically set cookies - default: true */
     autoSetCookie?: boolean;
+    /** default: "intor.i18n.locale" */
     name?: string;
-    maxAge?: number;
-    path?: string;
+    /** default: null */
     domain?: string | null;
-    secure?: boolean;
+    /** default: "/" */
+    path?: string;
+    /** default: 60 * 60 * 24 * 365 (365 days) */
+    maxAge?: number;
+    /** default: false */
     httpOnly?: boolean;
+    /** default: process.env.NODE_ENV !== "development" */
+    secure?: boolean;
+    /** default: lax */
     sameSite?: "lax" | "strict" | "none";
 };
-type ResolvedCookieOptions = Required<Omit<InitCookieOptions, "domain">> & {
+type CookieResolvedOptions = Required<Omit<CookieRawOptions, "domain">> & {
     domain: string | null;
 };
 
-declare const intorAdapters: readonly ["next-client", "next-server"];
-type IntorAdapter = (typeof intorAdapters)[number];
-
+/**
+ * ```ts
+ * {
+ *  default: ["ui", "meta"],
+ *  "/auth": ["auth", "admin"],
+ * }
+ * // When pathname is "/" => namespaces: ["ui", "meta"]
+ * // When pathname is "/auth" => namespaces: ["ui", "meta", "auth", "admin"]
+ * ```
+ */
 type RouteNamespaces = {
     [key: string]: string[];
 } | {
     [key: string]: string[];
     default: string[];
 };
+interface ApiHeaders {
+    authorization?: string;
+    "x-api-key"?: string;
+    [key: string]: string | undefined;
+}
 type BaseLoaderOptions = {
     basePath?: string;
     namespaces?: string[];
@@ -39,65 +60,75 @@ type ImportLoader = BaseLoaderOptions & {
 type ApiLoader = BaseLoaderOptions & {
     type: "api";
     apiUrl: string;
+    apiHeaders?: ApiHeaders;
     fullReload?: boolean;
 };
 type LoaderOptions = ImportLoader | ApiLoader;
 
-type InitLoggerOptions = {
+type LoggerOptions = {
     level?: Level;
     normalizerConfig?: NormalizerConfig;
     formatterConfig?: FormatterConfig;
     preset?: LoggerPreset;
 };
-type ResolvedLoggerOptions = InitLoggerOptions;
 
 declare const routingPrefix: readonly ["none", "all", "except-default"];
 declare const routingFirstVisitLocaleSource: readonly ["default", "browser"];
-type InitRoutingOptions = {
+type RoutingRawOptions = {
+    /** default: "none" */
     prefix?: (typeof routingPrefix)[number];
     firstVisit?: {
+        /** default: "browser" */
         localeSource?: (typeof routingFirstVisitLocaleSource)[number];
+        /** default: true */
         redirect?: boolean;
     };
+    /** default: "" */
     basePath?: string;
 };
-type ResolvedRoutingOptions = Required<InitRoutingOptions>;
+type RoutingResolvedOptions = Required<RoutingRawOptions>;
 
-type InitTranslatorOptions = {
+type CacheRawOptions = {
+    enabled?: boolean;
+    /** default: 60\*60\*1000 (1 hour) */
+    ttl?: number;
+};
+type CacheResolvedOptions = Required<CacheRawOptions>;
+
+type TranslatorOptions = {
     loadingMessage?: string;
     placeholder?: string;
 };
 
-type WithStaticMessages = {
-    loaderOptions?: undefined;
+type WithoutLoader = {
+    loader?: undefined;
     supportedLocales?: readonly Locale[];
 };
-type WithDynamicMessages = {
-    loaderOptions: LoaderOptions;
+type WithLoader = {
+    loader: LoaderOptions;
     supportedLocales: readonly Locale[];
 };
-type IntorResolvedConfig = (WithDynamicMessages | WithStaticMessages) & {
+type IntorResolvedConfig = (WithLoader | WithoutLoader) & {
     readonly id: string;
     readonly messages?: LocaleNamespaceMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales: FallbackLocalesMap;
-    readonly translator?: InitTranslatorOptions;
-    readonly cookie: ResolvedCookieOptions;
-    readonly routing: ResolvedRoutingOptions;
-    readonly adapter: IntorAdapter;
-    readonly logger?: ResolvedLoggerOptions;
-    readonly prefixPlaceHolder: string;
+    readonly translator?: TranslatorOptions;
+    readonly cookie: CookieResolvedOptions;
+    readonly routing: RoutingResolvedOptions;
+    readonly logger?: LoggerOptions;
+    readonly cache: CacheResolvedOptions;
 };
 
-type IntorMiddlewareParams = {
+interface IntorMiddlewareParams {
     request: NextRequest;
     config: IntorResolvedConfig;
-};
+}
 /**
  * Handle locale routing based on prefix config
  */
 declare function intorMiddleware({ request, config, }: IntorMiddlewareParams): Promise<Response>;
 
-declare const DEFAULT_PATHNAME_HEADER_NAME = "x-intor-pathname";
+declare const PATHNAME_HEADER_NAME = "x-intor-pathname";
 
-export { DEFAULT_PATHNAME_HEADER_NAME as PATHNAME_HEADER_NAME, intorMiddleware };
+export { PATHNAME_HEADER_NAME, intorMiddleware };

package/dist/next/middleware/index.d.ts

@@ -2,30 +2,51 @@ import { NextRequest } from 'next/server';
 import { Level, NormalizerConfig, FormatterConfig, LoggerPreset } from 'logry/edge';
 import { Locale, LocaleNamespaceMessages, FallbackLocalesMap } from 'intor-translator';
 
-type InitCookieOptions = {
+type CookieRawOptions = {
+    /** Completely disable cookie usage (no read, no write, no lookup by name) - default: false */
     disabled?: boolean;
+    /** Allow the system to automatically set cookies - default: true */
     autoSetCookie?: boolean;
+    /** default: "intor.i18n.locale" */
     name?: string;
-    maxAge?: number;
-    path?: string;
+    /** default: null */
     domain?: string | null;
-    secure?: boolean;
+    /** default: "/" */
+    path?: string;
+    /** default: 60 * 60 * 24 * 365 (365 days) */
+    maxAge?: number;
+    /** default: false */
     httpOnly?: boolean;
+    /** default: process.env.NODE_ENV !== "development" */
+    secure?: boolean;
+    /** default: lax */
     sameSite?: "lax" | "strict" | "none";
 };
-type ResolvedCookieOptions = Required<Omit<InitCookieOptions, "domain">> & {
+type CookieResolvedOptions = Required<Omit<CookieRawOptions, "domain">> & {
     domain: string | null;
 };
 
-declare const intorAdapters: readonly ["next-client", "next-server"];
-type IntorAdapter = (typeof intorAdapters)[number];
-
+/**
+ * ```ts
+ * {
+ *  default: ["ui", "meta"],
+ *  "/auth": ["auth", "admin"],
+ * }
+ * // When pathname is "/" => namespaces: ["ui", "meta"]
+ * // When pathname is "/auth" => namespaces: ["ui", "meta", "auth", "admin"]
+ * ```
+ */
 type RouteNamespaces = {
     [key: string]: string[];
 } | {
     [key: string]: string[];
     default: string[];
 };
+interface ApiHeaders {
+    authorization?: string;
+    "x-api-key"?: string;
+    [key: string]: string | undefined;
+}
 type BaseLoaderOptions = {
     basePath?: string;
     namespaces?: string[];
@@ -39,65 +60,75 @@ type ImportLoader = BaseLoaderOptions & {
 type ApiLoader = BaseLoaderOptions & {
     type: "api";
     apiUrl: string;
+    apiHeaders?: ApiHeaders;
     fullReload?: boolean;
 };
 type LoaderOptions = ImportLoader | ApiLoader;
 
-type InitLoggerOptions = {
+type LoggerOptions = {
     level?: Level;
     normalizerConfig?: NormalizerConfig;
     formatterConfig?: FormatterConfig;
     preset?: LoggerPreset;
 };
-type ResolvedLoggerOptions = InitLoggerOptions;
 
 declare const routingPrefix: readonly ["none", "all", "except-default"];
 declare const routingFirstVisitLocaleSource: readonly ["default", "browser"];
-type InitRoutingOptions = {
+type RoutingRawOptions = {
+    /** default: "none" */
     prefix?: (typeof routingPrefix)[number];
     firstVisit?: {
+        /** default: "browser" */
         localeSource?: (typeof routingFirstVisitLocaleSource)[number];
+        /** default: true */
         redirect?: boolean;
     };
+    /** default: "" */
     basePath?: string;
 };
-type ResolvedRoutingOptions = Required<InitRoutingOptions>;
+type RoutingResolvedOptions = Required<RoutingRawOptions>;
 
-type InitTranslatorOptions = {
+type CacheRawOptions = {
+    enabled?: boolean;
+    /** default: 60\*60\*1000 (1 hour) */
+    ttl?: number;
+};
+type CacheResolvedOptions = Required<CacheRawOptions>;
+
+type TranslatorOptions = {
     loadingMessage?: string;
     placeholder?: string;
 };
 
-type WithStaticMessages = {
-    loaderOptions?: undefined;
+type WithoutLoader = {
+    loader?: undefined;
     supportedLocales?: readonly Locale[];
 };
-type WithDynamicMessages = {
-    loaderOptions: LoaderOptions;
+type WithLoader = {
+    loader: LoaderOptions;
     supportedLocales: readonly Locale[];
 };
-type IntorResolvedConfig = (WithDynamicMessages | WithStaticMessages) & {
+type IntorResolvedConfig = (WithLoader | WithoutLoader) & {
     readonly id: string;
     readonly messages?: LocaleNamespaceMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales: FallbackLocalesMap;
-    readonly translator?: InitTranslatorOptions;
-    readonly cookie: ResolvedCookieOptions;
-    readonly routing: ResolvedRoutingOptions;
-    readonly adapter: IntorAdapter;
-    readonly logger?: ResolvedLoggerOptions;
-    readonly prefixPlaceHolder: string;
+    readonly translator?: TranslatorOptions;
+    readonly cookie: CookieResolvedOptions;
+    readonly routing: RoutingResolvedOptions;
+    readonly logger?: LoggerOptions;
+    readonly cache: CacheResolvedOptions;
 };
 
-type IntorMiddlewareParams = {
+interface IntorMiddlewareParams {
     request: NextRequest;
     config: IntorResolvedConfig;
-};
+}
 /**
  * Handle locale routing based on prefix config
  */
 declare function intorMiddleware({ request, config, }: IntorMiddlewareParams): Promise<Response>;
 
-declare const DEFAULT_PATHNAME_HEADER_NAME = "x-intor-pathname";
+declare const PATHNAME_HEADER_NAME = "x-intor-pathname";
 
-export { DEFAULT_PATHNAME_HEADER_NAME as PATHNAME_HEADER_NAME, intorMiddleware };
+export { PATHNAME_HEADER_NAME, intorMiddleware };