next-intlayer 8.4.3 → 8.4.5

package/dist/esm/proxy/localeDetector.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"localeDetector.mjs","names":["localeDetectorCore"],"sources":["../../../src/proxy/localeDetector.ts"],"sourcesContent":["import { localeDetector as localeDetectorCore } from '@intlayer/core/localization';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { NextRequest } from 'next/server.js';\n\n/**\n * Detects the locale from the request headers\n *\n * Headers are provided by the browser and can be used to determine the user's preferred language\n */\nexport const localeDetector = (request: NextRequest): LocalesValues => {\n  const negotiatorHeaders: Record<string, string> = {};\n\n  request.headers.forEach((value, key) => {\n    negotiatorHeaders[key] = value;\n  });\n\n  const locale = localeDetectorCore(negotiatorHeaders);\n\n  return locale;\n};\n"],"mappings":"6DASA,MAAa,EAAkB,GAAwC,CACrE,IAAM,EAA4C,EAAE,CAQpD,OANA,EAAQ,QAAQ,SAAS,EAAO,IAAQ,CACtC,EAAkB,GAAO,GACzB,CAEaA,EAAmB,EAAkB"}
+{"version":3,"file":"localeDetector.mjs","names":["localeDetectorCore"],"sources":["../../../src/proxy/localeDetector.ts"],"sourcesContent":["import { localeDetector as localeDetectorCore } from '@intlayer/core/localization';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { NextRequest } from 'next/server.js';\n\n/**\n * Detects the locale from the request headers\n *\n * Headers are provided by the browser and can be used to determine the user's preferred language\n */\nexport const localeDetector = (request: NextRequest): LocalesValues => {\n  const negotiatorHeaders: Record<string, string> = {};\n\n  request.headers.forEach((value, key) => {\n    negotiatorHeaders[key] = value;\n  });\n\n  const locale = localeDetectorCore(negotiatorHeaders);\n\n  return locale;\n};\n"],"mappings":";;;;;;;;AASA,MAAa,kBAAkB,YAAwC;CACrE,MAAM,oBAA4C,EAAE;AAEpD,SAAQ,QAAQ,SAAS,OAAO,QAAQ;AACtC,oBAAkB,OAAO;GACzB;AAIF,QAFeA,iBAAmB,kBAAkB"}

package/dist/esm/proxy/middleware.mjs

@@ -1,2 +1,36 @@
-import{intlayerProxy as e}from"./intlayerProxy.mjs";import{multipleProxies as t}from"./multipleProxies.mjs";const n=e,r=t;export{n as intlayerMiddleware,r as multipleMiddlewares};
+import { intlayerProxy } from "./intlayerProxy.mjs";
+import { multipleProxies } from "./multipleProxies.mjs";
+
+//#region src/proxy/middleware.ts
+/**
+* Reexport for nextjs <=15
+*/
+/**
+* Middleware that handles the internationalization layer
+*
+* Usage:
+*
+* ```ts
+* // ./src/middleware.ts
+*
+* export { intlayerMiddleware as middleware } from '@intlayer/next/middleware';
+*
+* // applies this middleware only to files in the app directory
+* export const config = {
+*   matcher: '/((?!api|static|.*\\..*|_next).*)',
+* };
+* ```
+*
+* Main middleware function for handling internationalization.
+*
+* @param request - The incoming Next.js request object.
+* @param event - The Next.js fetch event (optional).
+* @param response - The Next.js response object (optional).
+* @returns - The response to be returned to the client.
+*/
+const intlayerMiddleware = intlayerProxy;
+const multipleMiddlewares = multipleProxies;
+
+//#endregion
+export { intlayerMiddleware, multipleMiddlewares };
 //# sourceMappingURL=middleware.mjs.map

package/dist/esm/proxy/middleware.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.mjs","names":[],"sources":["../../../src/proxy/middleware.ts"],"sourcesContent":["import { intlayerProxy } from './intlayerProxy';\nimport { multipleProxies } from './multipleProxies';\n\n/**\n * Reexport for nextjs <=15\n */\n\n/**\n * Middleware that handles the internationalization layer\n *\n * Usage:\n *\n * ```ts\n * // ./src/middleware.ts\n *\n * export { intlayerMiddleware as middleware } from '@intlayer/next/middleware';\n *\n * // applies this middleware only to files in the app directory\n * export const config = {\n *   matcher: '/((?!api|static|.*\\\\..*|_next).*)',\n * };\n * ```\n *\n * Main middleware function for handling internationalization.\n *\n * @param request - The incoming Next.js request object.\n * @param event - The Next.js fetch event (optional).\n * @param response - The Next.js response object (optional).\n * @returns - The response to be returned to the client.\n */\nexport const intlayerMiddleware = intlayerProxy;\n\nexport const multipleMiddlewares = multipleProxies;\n"],"mappings":"4GA8BA,MAAa,EAAqB,EAErB,EAAsB"}
+{"version":3,"file":"middleware.mjs","names":[],"sources":["../../../src/proxy/middleware.ts"],"sourcesContent":["import { intlayerProxy } from './intlayerProxy';\nimport { multipleProxies } from './multipleProxies';\n\n/**\n * Reexport for nextjs <=15\n */\n\n/**\n * Middleware that handles the internationalization layer\n *\n * Usage:\n *\n * ```ts\n * // ./src/middleware.ts\n *\n * export { intlayerMiddleware as middleware } from '@intlayer/next/middleware';\n *\n * // applies this middleware only to files in the app directory\n * export const config = {\n *   matcher: '/((?!api|static|.*\\\\..*|_next).*)',\n * };\n * ```\n *\n * Main middleware function for handling internationalization.\n *\n * @param request - The incoming Next.js request object.\n * @param event - The Next.js fetch event (optional).\n * @param response - The Next.js response object (optional).\n * @returns - The response to be returned to the client.\n */\nexport const intlayerMiddleware = intlayerProxy;\n\nexport const multipleMiddlewares = multipleProxies;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,qBAAqB;AAElC,MAAa,sBAAsB"}

package/dist/esm/proxy/multipleProxies.mjs

@@ -1,2 +1,56 @@
-import{NextResponse as e}from"next/server";const t=t=>async(n,r,i)=>{let a=[];for(let e of t){let t=await e(n,r,i);if(!t.ok)return t;a.push(t.headers)}let o=new Headers,s=new Headers(n.headers);a.forEach(e=>{for(let[t,n]of e.entries())if(o.append(t,n),t.startsWith(`x-middleware-request-`)){let e=t.replace(`x-middleware-request-`,``);s.append(e,n)}});let c=o.get(`x-middleware-request-redirect`);if(c)return e.redirect(new URL(c,n.url),{status:307});let l=o.get(`x-middleware-rewrite`);return l?e.rewrite(new URL(l,n.url),{request:{headers:s}}):e.next({request:{headers:s}})};export{t as multipleProxies};
+import { NextResponse } from "next/server";
+
+//#region src/proxy/multipleProxies.ts
+/**
+* Utility to combine multiple Next.js proxies into one.
+*
+* It executes proxies in order, merges headers, and correctly handles
+* redirects and rewrites.
+*
+* @example
+* import { multipleProxies, intlayerProxy } from "next-intlayer/proxy";
+* import { NextResponse } from "next/server";
+*
+* const authMiddleware = (req: NextRequest) => {
+*   if (!req.cookies.get("token")) {
+*     return NextResponse.redirect(new URL("/login", req.url));
+*   }
+*   return NextResponse.next();
+* };
+*
+* export default multipleProxies([
+*   intlayerProxy,
+*   authMiddleware,
+* ]);
+*
+* @param proxies - An array of proxy functions to execute in order.
+* @returns A single proxy function that runs all provided proxies.
+*/
+const multipleProxies = (proxies) => async (req, event, response) => {
+	const proxyHeader = [];
+	for (const proxy of proxies) {
+		const result = await proxy(req, event, response);
+		if (!result.ok) return result;
+		proxyHeader.push(result.headers);
+	}
+	const mergedHeaders = new Headers();
+	const transmittedHeaders = new Headers(req.headers);
+	proxyHeader.forEach((header) => {
+		for (const [key, value] of header.entries()) {
+			mergedHeaders.append(key, value);
+			if (key.startsWith("x-middleware-request-")) {
+				const fixedKey = key.replace("x-middleware-request-", "");
+				transmittedHeaders.append(fixedKey, value);
+			}
+		}
+	});
+	const redirect = mergedHeaders.get("x-middleware-request-redirect");
+	if (redirect) return NextResponse.redirect(new URL(redirect, req.url), { status: 307 });
+	const rewrite = mergedHeaders.get("x-middleware-rewrite");
+	if (rewrite) return NextResponse.rewrite(new URL(rewrite, req.url), { request: { headers: transmittedHeaders } });
+	return NextResponse.next({ request: { headers: transmittedHeaders } });
+};
+
+//#endregion
+export { multipleProxies };
 //# sourceMappingURL=multipleProxies.mjs.map

package/dist/esm/proxy/multipleProxies.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"multipleProxies.mjs","names":[],"sources":["../../../src/proxy/multipleProxies.ts"],"sourcesContent":["import {\n  type NextFetchEvent,\n  type NextRequest,\n  NextResponse,\n} from 'next/server';\n\n/**\n * Utility to combine multiple Next.js proxies into one.\n *\n * It executes proxies in order, merges headers, and correctly handles\n * redirects and rewrites.\n *\n * @example\n * import { multipleProxies, intlayerProxy } from \"next-intlayer/proxy\";\n * import { NextResponse } from \"next/server\";\n *\n * const authMiddleware = (req: NextRequest) => {\n *   if (!req.cookies.get(\"token\")) {\n *     return NextResponse.redirect(new URL(\"/login\", req.url));\n *   }\n *   return NextResponse.next();\n * };\n *\n * export default multipleProxies([\n *   intlayerProxy,\n *   authMiddleware,\n * ]);\n *\n * @param proxies - An array of proxy functions to execute in order.\n * @returns A single proxy function that runs all provided proxies.\n */\nexport const multipleProxies =\n  (\n    proxies: ((\n      req: NextRequest,\n      event?: NextFetchEvent,\n      response?: NextResponse\n    ) => NextResponse | Promise<NextResponse>)[]\n  ) =>\n  async (req: NextRequest, event?: NextFetchEvent, response?: NextResponse) => {\n    // Array to store proxy headers\n    const proxyHeader: Headers[] = [];\n\n    // Loop through proxy functions\n    for (const proxy of proxies) {\n      // Execute proxy function and await the result\n      const result = await proxy(req, event, response);\n\n      // Check if the result is not okay and return it\n      if (!result.ok) {\n        return result;\n      }\n\n      // Push proxy headers to the array\n      proxyHeader.push(result.headers);\n    }\n\n    // Merge all the headers to check if there is a redirection or rewrite\n    const mergedHeaders = new Headers();\n\n    // Merge all the custom headers added by the proxies\n    const transmittedHeaders = new Headers(req.headers);\n\n    // Merge headers\n    proxyHeader.forEach((header) => {\n      for (const [key, value] of header.entries()) {\n        mergedHeaders.append(key, value);\n\n        // check if it's a custom header added by one of the proxies\n        if (key.startsWith('x-middleware-request-')) {\n          // remove the prefix to get the original key\n          const fixedKey = key.replace('x-middleware-request-', '');\n\n          // add the original key to the transmitted headers\n          transmittedHeaders.append(fixedKey, value);\n        }\n      }\n    });\n\n    // Look for the 'x-middleware-request-redirect' header\n    const redirect = mergedHeaders.get('x-middleware-request-redirect');\n\n    // If a redirection is required based on the proxy headers\n    if (redirect) {\n      // Perform the redirection\n      return NextResponse.redirect(new URL(redirect, req.url), {\n        status: 307, // Temporary redirect\n      });\n    }\n\n    // Look for the 'x-middleware-rewrite' header\n    const rewrite = mergedHeaders.get('x-middleware-rewrite');\n    if (rewrite) {\n      // Perform the rewrite\n      return NextResponse.rewrite(new URL(rewrite, req.url), {\n        request: {\n          headers: transmittedHeaders,\n        },\n      });\n    }\n\n    // Default: continue to next proxy\n    return NextResponse.next({\n      request: {\n        headers: transmittedHeaders,\n      },\n    });\n  };\n"],"mappings":"2CA+BA,MAAa,EAET,GAMF,MAAO,EAAkB,EAAwB,IAA4B,CAE3E,IAAM,EAAyB,EAAE,CAGjC,IAAK,IAAM,KAAS,EAAS,CAE3B,IAAM,EAAS,MAAM,EAAM,EAAK,EAAO,EAAS,CAGhD,GAAI,CAAC,EAAO,GACV,OAAO,EAIT,EAAY,KAAK,EAAO,QAAQ,CAIlC,IAAM,EAAgB,IAAI,QAGpB,EAAqB,IAAI,QAAQ,EAAI,QAAQ,CAGnD,EAAY,QAAS,GAAW,CAC9B,IAAK,GAAM,CAAC,EAAK,KAAU,EAAO,SAAS,CAIzC,GAHA,EAAc,OAAO,EAAK,EAAM,CAG5B,EAAI,WAAW,wBAAwB,CAAE,CAE3C,IAAM,EAAW,EAAI,QAAQ,wBAAyB,GAAG,CAGzD,EAAmB,OAAO,EAAU,EAAM,GAG9C,CAGF,IAAM,EAAW,EAAc,IAAI,gCAAgC,CAGnE,GAAI,EAEF,OAAO,EAAa,SAAS,IAAI,IAAI,EAAU,EAAI,IAAI,CAAE,CACvD,OAAQ,IACT,CAAC,CAIJ,IAAM,EAAU,EAAc,IAAI,uBAAuB,CAWzD,OAVI,EAEK,EAAa,QAAQ,IAAI,IAAI,EAAS,EAAI,IAAI,CAAE,CACrD,QAAS,CACP,QAAS,EACV,CACF,CAAC,CAIG,EAAa,KAAK,CACvB,QAAS,CACP,QAAS,EACV,CACF,CAAC"}
+{"version":3,"file":"multipleProxies.mjs","names":[],"sources":["../../../src/proxy/multipleProxies.ts"],"sourcesContent":["import {\n  type NextFetchEvent,\n  type NextRequest,\n  NextResponse,\n} from 'next/server';\n\n/**\n * Utility to combine multiple Next.js proxies into one.\n *\n * It executes proxies in order, merges headers, and correctly handles\n * redirects and rewrites.\n *\n * @example\n * import { multipleProxies, intlayerProxy } from \"next-intlayer/proxy\";\n * import { NextResponse } from \"next/server\";\n *\n * const authMiddleware = (req: NextRequest) => {\n *   if (!req.cookies.get(\"token\")) {\n *     return NextResponse.redirect(new URL(\"/login\", req.url));\n *   }\n *   return NextResponse.next();\n * };\n *\n * export default multipleProxies([\n *   intlayerProxy,\n *   authMiddleware,\n * ]);\n *\n * @param proxies - An array of proxy functions to execute in order.\n * @returns A single proxy function that runs all provided proxies.\n */\nexport const multipleProxies =\n  (\n    proxies: ((\n      req: NextRequest,\n      event?: NextFetchEvent,\n      response?: NextResponse\n    ) => NextResponse | Promise<NextResponse>)[]\n  ) =>\n  async (req: NextRequest, event?: NextFetchEvent, response?: NextResponse) => {\n    // Array to store proxy headers\n    const proxyHeader: Headers[] = [];\n\n    // Loop through proxy functions\n    for (const proxy of proxies) {\n      // Execute proxy function and await the result\n      const result = await proxy(req, event, response);\n\n      // Check if the result is not okay and return it\n      if (!result.ok) {\n        return result;\n      }\n\n      // Push proxy headers to the array\n      proxyHeader.push(result.headers);\n    }\n\n    // Merge all the headers to check if there is a redirection or rewrite\n    const mergedHeaders = new Headers();\n\n    // Merge all the custom headers added by the proxies\n    const transmittedHeaders = new Headers(req.headers);\n\n    // Merge headers\n    proxyHeader.forEach((header) => {\n      for (const [key, value] of header.entries()) {\n        mergedHeaders.append(key, value);\n\n        // check if it's a custom header added by one of the proxies\n        if (key.startsWith('x-middleware-request-')) {\n          // remove the prefix to get the original key\n          const fixedKey = key.replace('x-middleware-request-', '');\n\n          // add the original key to the transmitted headers\n          transmittedHeaders.append(fixedKey, value);\n        }\n      }\n    });\n\n    // Look for the 'x-middleware-request-redirect' header\n    const redirect = mergedHeaders.get('x-middleware-request-redirect');\n\n    // If a redirection is required based on the proxy headers\n    if (redirect) {\n      // Perform the redirection\n      return NextResponse.redirect(new URL(redirect, req.url), {\n        status: 307, // Temporary redirect\n      });\n    }\n\n    // Look for the 'x-middleware-rewrite' header\n    const rewrite = mergedHeaders.get('x-middleware-rewrite');\n    if (rewrite) {\n      // Perform the rewrite\n      return NextResponse.rewrite(new URL(rewrite, req.url), {\n        request: {\n          headers: transmittedHeaders,\n        },\n      });\n    }\n\n    // Default: continue to next proxy\n    return NextResponse.next({\n      request: {\n        headers: transmittedHeaders,\n      },\n    });\n  };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,mBAET,YAMF,OAAO,KAAkB,OAAwB,aAA4B;CAE3E,MAAM,cAAyB,EAAE;AAGjC,MAAK,MAAM,SAAS,SAAS;EAE3B,MAAM,SAAS,MAAM,MAAM,KAAK,OAAO,SAAS;AAGhD,MAAI,CAAC,OAAO,GACV,QAAO;AAIT,cAAY,KAAK,OAAO,QAAQ;;CAIlC,MAAM,gBAAgB,IAAI,SAAS;CAGnC,MAAM,qBAAqB,IAAI,QAAQ,IAAI,QAAQ;AAGnD,aAAY,SAAS,WAAW;AAC9B,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,SAAS,EAAE;AAC3C,iBAAc,OAAO,KAAK,MAAM;AAGhC,OAAI,IAAI,WAAW,wBAAwB,EAAE;IAE3C,MAAM,WAAW,IAAI,QAAQ,yBAAyB,GAAG;AAGzD,uBAAmB,OAAO,UAAU,MAAM;;;GAG9C;CAGF,MAAM,WAAW,cAAc,IAAI,gCAAgC;AAGnE,KAAI,SAEF,QAAO,aAAa,SAAS,IAAI,IAAI,UAAU,IAAI,IAAI,EAAE,EACvD,QAAQ,KACT,CAAC;CAIJ,MAAM,UAAU,cAAc,IAAI,uBAAuB;AACzD,KAAI,QAEF,QAAO,aAAa,QAAQ,IAAI,IAAI,SAAS,IAAI,IAAI,EAAE,EACrD,SAAS,EACP,SAAS,oBACV,EACF,CAAC;AAIJ,QAAO,aAAa,KAAK,EACvB,SAAS,EACP,SAAS,oBACV,EACF,CAAC"}

package/dist/esm/server/format/index.mjs

@@ -1 +1 @@
-export*from"react-intlayer/server/format";
+export * from "react-intlayer/server/format"

package/dist/esm/server/getLocale.mjs

@@ -1,2 +1,46 @@
-import{localeDetector as e}from"@intlayer/core/localization";import t from"@intlayer/config/built";import{DEFAULT_LOCALE as n}from"@intlayer/config/defaultValues";import{getLocaleFromStorage as r}from"@intlayer/core/utils";import{cookies as i,headers as a}from"next/headers.js";const o=async()=>{let o=t?.internationalization?.defaultLocale??n,s=await a(),c=await i(),l=r({getCookie:e=>c.get(e)?.value??null,getHeader:e=>s.get(e)??null});if(l)return l;let u={};return s.forEach((e,t)=>{u[t]=e}),e(u)||o};export{o as getLocale};
+import { localeDetector } from "@intlayer/core/localization";
+import configuration from "@intlayer/config/built";
+import { DEFAULT_LOCALE } from "@intlayer/config/defaultValues";
+import { getLocaleFromStorage } from "@intlayer/core/utils";
+import { cookies, headers } from "next/headers.js";
+
+//#region src/server/getLocale.ts
+/**
+* Helper function to extract the current locale from Next.js headers and cookies.
+*
+* This function is designed to be used in Server Components, Server Actions, or Route Handlers
+* to determine the locale preferred by the user or stored in their preferences.
+*
+* @returns A promise that resolves to the detected `Locale`.
+*
+* @example
+* ```tsx
+* import { getLocale } from 'next-intlayer/server';
+*
+* export default async function MyServerComponent() {
+*   const locale = await getLocale();
+*   // ...
+* }
+* ```
+*/
+const getLocale = async () => {
+	const defaultLocale = configuration?.internationalization?.defaultLocale ?? DEFAULT_LOCALE;
+	const headersList = await headers();
+	const cookiesList = await cookies();
+	const storedLocale = getLocaleFromStorage({
+		getCookie: (name) => cookiesList.get(name)?.value ?? null,
+		getHeader: (name) => headersList.get(name) ?? null
+	});
+	if (storedLocale) return storedLocale;
+	const negotiatorHeaders = {};
+	headersList.forEach((value, key) => {
+		negotiatorHeaders[key] = value;
+	});
+	const userFallbackLocale = localeDetector(negotiatorHeaders);
+	if (userFallbackLocale) return userFallbackLocale;
+	return defaultLocale;
+};
+
+//#endregion
+export { getLocale };
 //# sourceMappingURL=getLocale.mjs.map

package/dist/esm/server/getLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocale.mjs","names":[],"sources":["../../../src/server/getLocale.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { DEFAULT_LOCALE } from '@intlayer/config/defaultValues';\nimport { localeDetector } from '@intlayer/core/localization';\nimport { getLocaleFromStorage } from '@intlayer/core/utils';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { cookies, headers } from 'next/headers.js';\n\n// Helper function to extract locale from headers/cookies\n/**\n * Helper function to extract the current locale from Next.js headers and cookies.\n *\n * This function is designed to be used in Server Components, Server Actions, or Route Handlers\n * to determine the locale preferred by the user or stored in their preferences.\n *\n * @returns A promise that resolves to the detected `Locale`.\n *\n * @example\n * ```tsx\n * import { getLocale } from 'next-intlayer/server';\n *\n * export default async function MyServerComponent() {\n *   const locale = await getLocale();\n *   // ...\n * }\n * ```\n */\nexport const getLocale = async (): Promise<Locale> => {\n  const defaultLocale =\n    configuration?.internationalization?.defaultLocale ?? DEFAULT_LOCALE;\n\n  // Try locale from header\n  const headersList = await headers();\n  const cookiesList = await cookies();\n\n  const storedLocale = getLocaleFromStorage({\n    getCookie: (name: string) => cookiesList.get(name)?.value ?? null,\n    getHeader: (name: string) => headersList.get(name) ?? null,\n  });\n\n  if (storedLocale) return storedLocale as Locale;\n\n  // Fallback to Accept-Language negotiation\n  const negotiatorHeaders: Record<string, string> = {};\n  headersList.forEach((value, key) => {\n    negotiatorHeaders[key] = value;\n  });\n\n  const userFallbackLocale = localeDetector(negotiatorHeaders);\n  if (userFallbackLocale) return userFallbackLocale as Locale;\n\n  // Default locale\n  return defaultLocale;\n};\n"],"mappings":"sRA0BA,MAAa,EAAY,SAA6B,CACpD,IAAM,EACJ,GAAe,sBAAsB,eAAiB,EAGlD,EAAc,MAAM,GAAS,CAC7B,EAAc,MAAM,GAAS,CAE7B,EAAe,EAAqB,CACxC,UAAY,GAAiB,EAAY,IAAI,EAAK,EAAE,OAAS,KAC7D,UAAY,GAAiB,EAAY,IAAI,EAAK,EAAI,KACvD,CAAC,CAEF,GAAI,EAAc,OAAO,EAGzB,IAAM,EAA4C,EAAE,CASpD,OARA,EAAY,SAAS,EAAO,IAAQ,CAClC,EAAkB,GAAO,GACzB,CAEyB,EAAe,EAAkB,EAIrD"}
+{"version":3,"file":"getLocale.mjs","names":[],"sources":["../../../src/server/getLocale.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { DEFAULT_LOCALE } from '@intlayer/config/defaultValues';\nimport { localeDetector } from '@intlayer/core/localization';\nimport { getLocaleFromStorage } from '@intlayer/core/utils';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { cookies, headers } from 'next/headers.js';\n\n// Helper function to extract locale from headers/cookies\n/**\n * Helper function to extract the current locale from Next.js headers and cookies.\n *\n * This function is designed to be used in Server Components, Server Actions, or Route Handlers\n * to determine the locale preferred by the user or stored in their preferences.\n *\n * @returns A promise that resolves to the detected `Locale`.\n *\n * @example\n * ```tsx\n * import { getLocale } from 'next-intlayer/server';\n *\n * export default async function MyServerComponent() {\n *   const locale = await getLocale();\n *   // ...\n * }\n * ```\n */\nexport const getLocale = async (): Promise<Locale> => {\n  const defaultLocale =\n    configuration?.internationalization?.defaultLocale ?? DEFAULT_LOCALE;\n\n  // Try locale from header\n  const headersList = await headers();\n  const cookiesList = await cookies();\n\n  const storedLocale = getLocaleFromStorage({\n    getCookie: (name: string) => cookiesList.get(name)?.value ?? null,\n    getHeader: (name: string) => headersList.get(name) ?? null,\n  });\n\n  if (storedLocale) return storedLocale as Locale;\n\n  // Fallback to Accept-Language negotiation\n  const negotiatorHeaders: Record<string, string> = {};\n  headersList.forEach((value, key) => {\n    negotiatorHeaders[key] = value;\n  });\n\n  const userFallbackLocale = localeDetector(negotiatorHeaders);\n  if (userFallbackLocale) return userFallbackLocale as Locale;\n\n  // Default locale\n  return defaultLocale;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,YAAY,YAA6B;CACpD,MAAM,gBACJ,eAAe,sBAAsB,iBAAiB;CAGxD,MAAM,cAAc,MAAM,SAAS;CACnC,MAAM,cAAc,MAAM,SAAS;CAEnC,MAAM,eAAe,qBAAqB;EACxC,YAAY,SAAiB,YAAY,IAAI,KAAK,EAAE,SAAS;EAC7D,YAAY,SAAiB,YAAY,IAAI,KAAK,IAAI;EACvD,CAAC;AAEF,KAAI,aAAc,QAAO;CAGzB,MAAM,oBAA4C,EAAE;AACpD,aAAY,SAAS,OAAO,QAAQ;AAClC,oBAAkB,OAAO;GACzB;CAEF,MAAM,qBAAqB,eAAe,kBAAkB;AAC5D,KAAI,mBAAoB,QAAO;AAG/B,QAAO"}

package/dist/esm/server/index.mjs

@@ -1 +1,5 @@
-import{getLocale as e}from"./getLocale.mjs";import{withIntlayer as t,withIntlayerSync as n}from"./withIntlayer.mjs";import{IntlayerServerProvider as r,locale as i,t as a,useDictionary as o,useDictionaryAsync as s,useDictionaryDynamic as c,useI18n as l,useIntl as u,useIntlayer as d,useLoadDynamic as f,useLocale as p}from"react-intlayer/server";export{r as IntlayerServerProvider,e as getLocale,i as locale,a as t,o as useDictionary,s as useDictionaryAsync,c as useDictionaryDynamic,l as useI18n,u as useIntl,d as useIntlayer,f as useLoadDynamic,p as useLocale,t as withIntlayer,n as withIntlayerSync};
+import { getLocale } from "./getLocale.mjs";
+import { withIntlayer, withIntlayerSync } from "./withIntlayer.mjs";
+import { IntlayerServerProvider, locale, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale } from "react-intlayer/server";
+
+export { IntlayerServerProvider, getLocale, locale, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale, withIntlayer, withIntlayerSync };

package/dist/esm/server/useDictionary.mjs

@@ -1,2 +1,16 @@
-import{safeUseLocale as e}from"./useIntlayer.mjs";import{useDictionary as t}from"react-intlayer/server";const n=(n,r)=>t(n,r,e());export{n as useDictionary};
+import { safeUseLocale } from "./useIntlayer.mjs";
+import { useDictionary as useDictionary$1 } from "react-intlayer/server";
+
+//#region src/server/useDictionary.ts
+/**
+* On the server side, Hook that transform a dictionary and return the content
+*
+* If the locale is not provided, it will use the locale from the server context
+*/
+const useDictionary = (dictionary, locale) => {
+	return useDictionary$1(dictionary, locale, safeUseLocale());
+};
+
+//#endregion
+export { useDictionary };
 //# sourceMappingURL=useDictionary.mjs.map

package/dist/esm/server/useDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.mjs","names":["useDictionaryBase"],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionary as useDictionaryBase } from 'react-intlayer/server';\nimport { safeUseLocale } from './useIntlayer';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useDictionary = <\n  T extends Dictionary,\n  L extends DeclaredLocales = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n): ReturnType<typeof useDictionaryBase<T, L>> => {\n  const storedLocale = safeUseLocale();\n\n  return useDictionaryBase<T, L>(dictionary, locale, storedLocale);\n};\n"],"mappings":"wGAUA,MAAa,GAIX,EACA,IAIOA,EAAwB,EAAY,EAFtB,GAAe,CAE4B"}
+{"version":3,"file":"useDictionary.mjs","names":["useDictionaryBase"],"sources":["../../../src/server/useDictionary.ts"],"sourcesContent":["import type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionary as useDictionaryBase } from 'react-intlayer/server';\nimport { safeUseLocale } from './useIntlayer';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useDictionary = <\n  T extends Dictionary,\n  L extends DeclaredLocales = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n): ReturnType<typeof useDictionaryBase<T, L>> => {\n  const storedLocale = safeUseLocale();\n\n  return useDictionaryBase<T, L>(dictionary, locale, storedLocale);\n};\n"],"mappings":";;;;;;;;;AAUA,MAAa,iBAIX,YACA,WAC+C;AAG/C,QAAOA,gBAAwB,YAAY,QAFtB,eAAe,CAE4B"}

package/dist/esm/server/useDictionaryAsync.mjs

@@ -1,2 +1,16 @@
-import{getLocale as e}from"./getLocale.mjs";import{useDictionaryAsync as t}from"react-intlayer/server";const n=async(n,r)=>t(n,r,await e());export{n as useDictionaryAsync};
+import { getLocale } from "./getLocale.mjs";
+import { useDictionaryAsync as useDictionaryAsync$1 } from "react-intlayer/server";
+
+//#region src/server/useDictionaryAsync.ts
+/**
+* On the server side, Hook that transform a dictionary and return the content
+*
+* If the locale is not provided, it will use the locale from the server context
+*/
+const useDictionaryAsync = async (dictionaryPromise, locale) => {
+	return useDictionaryAsync$1(dictionaryPromise, locale, await getLocale());
+};
+
+//#endregion
+export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.mjs.map

package/dist/esm/server/useDictionaryAsync.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.mjs","names":["useDictionaryAsyncBase"],"sources":["../../../src/server/useDictionaryAsync.ts"],"sourcesContent":["import type { DeclaredLocales, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionaryAsync as useDictionaryAsyncBase } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useDictionaryAsync = async <\n  T extends Dictionary,\n  L extends DeclaredLocales = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: L\n): ReturnType<typeof useDictionaryAsyncBase<T, L>> => {\n  const storedLocale = await getLocale();\n\n  return useDictionaryAsyncBase<T, L>(dictionaryPromise, locale, storedLocale);\n};\n"],"mappings":"uGAUA,MAAa,EAAqB,MAIhC,EACA,IAIOA,EAA6B,EAAmB,EAFlC,MAAM,GAAW,CAEsC"}
+{"version":3,"file":"useDictionaryAsync.mjs","names":["useDictionaryAsyncBase"],"sources":["../../../src/server/useDictionaryAsync.ts"],"sourcesContent":["import type { DeclaredLocales, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionaryAsync as useDictionaryAsyncBase } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useDictionaryAsync = async <\n  T extends Dictionary,\n  L extends DeclaredLocales = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: L\n): ReturnType<typeof useDictionaryAsyncBase<T, L>> => {\n  const storedLocale = await getLocale();\n\n  return useDictionaryAsyncBase<T, L>(dictionaryPromise, locale, storedLocale);\n};\n"],"mappings":";;;;;;;;;AAUA,MAAa,qBAAqB,OAIhC,mBACA,WACoD;AAGpD,QAAOA,qBAA6B,mBAAmB,QAFlC,MAAM,WAAW,CAEsC"}

package/dist/esm/server/useDictionaryDynamic.mjs

@@ -1,2 +1,16 @@
-import{safeUseLocale as e}from"./useIntlayer.mjs";import{useDictionaryDynamic as t}from"react-intlayer/server";const n=(n,r,i)=>t(n,r,i,e());export{n as useDictionaryDynamic};
+import { safeUseLocale } from "./useIntlayer.mjs";
+import { useDictionaryDynamic as useDictionaryDynamic$1 } from "react-intlayer/server";
+
+//#region src/server/useDictionaryDynamic.ts
+/**
+* On the server side, Hook that transform a dictionary and return the content
+*
+* If the locale is not provided, it will use the locale from the server context
+*/
+const useDictionaryDynamic = (dictionaryPromise, key, locale) => {
+	return useDictionaryDynamic$1(dictionaryPromise, key, locale, safeUseLocale());
+};
+
+//#endregion
+export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.mjs.map

package/dist/esm/server/useDictionaryDynamic.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.mjs","names":["useDictionaryDynamicBase"],"sources":["../../../src/server/useDictionaryDynamic.ts"],"sourcesContent":["import type { DeclaredLocales, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionaryDynamic as useDictionaryDynamicBase } from 'react-intlayer/server';\nimport { safeUseLocale } from './useIntlayer';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  L extends DeclaredLocales = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: string,\n  locale?: L\n): ReturnType<typeof useDictionaryDynamicBase<T, L>> => {\n  const storedLocale = safeUseLocale();\n\n  return useDictionaryDynamicBase<T, L>(\n    dictionaryPromise,\n    key,\n    locale,\n    storedLocale\n  );\n};\n"],"mappings":"+GAUA,MAAa,GAIX,EACA,EACA,IAIOA,EACL,EACA,EACA,EALmB,GAAe,CAOnC"}
+{"version":3,"file":"useDictionaryDynamic.mjs","names":["useDictionaryDynamicBase"],"sources":["../../../src/server/useDictionaryDynamic.ts"],"sourcesContent":["import type { DeclaredLocales, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionaryDynamic as useDictionaryDynamicBase } from 'react-intlayer/server';\nimport { safeUseLocale } from './useIntlayer';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  L extends DeclaredLocales = DeclaredLocales,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: string,\n  locale?: L\n): ReturnType<typeof useDictionaryDynamicBase<T, L>> => {\n  const storedLocale = safeUseLocale();\n\n  return useDictionaryDynamicBase<T, L>(\n    dictionaryPromise,\n    key,\n    locale,\n    storedLocale\n  );\n};\n"],"mappings":";;;;;;;;;AAUA,MAAa,wBAIX,mBACA,KACA,WACsD;AAGtD,QAAOA,uBACL,mBACA,KACA,QALmB,eAAe,CAOnC"}

package/dist/esm/server/useIntlayer.mjs

@@ -1,2 +1,26 @@
-import{getLocale as e}from"./getLocale.mjs";import t from"react";import{useIntlayer as n}from"react-intlayer/server";const r=typeof t.cache==`function`?t.cache(e):e,i=()=>{let e=r();return e instanceof Promise?typeof t.use==`function`?t.use(e):void 0:e},a=(e,t)=>n(e,t,i());export{i as safeUseLocale,a as useIntlayer};
+import { getLocale } from "./getLocale.mjs";
+import React from "react";
+import { useIntlayer as useIntlayer$1 } from "react-intlayer/server";
+
+//#region src/server/useIntlayer.ts
+const getCachedLocale = typeof React.cache === "function" ? React.cache(getLocale) : getLocale;
+const safeUseLocale = () => {
+	const localeData = getCachedLocale();
+	if (localeData instanceof Promise) {
+		if (typeof React.use === "function") return React.use(localeData);
+		return;
+	}
+	return localeData;
+};
+/**
+* On the server side, Hook that picking one dictionary by its key and return the content
+*
+* If the locale is not provided, it will use the locale from the server context
+*/
+const useIntlayer = (key, locale) => {
+	return useIntlayer$1(key, locale, safeUseLocale());
+};
+
+//#endregion
+export { safeUseLocale, useIntlayer };
 //# sourceMappingURL=useIntlayer.mjs.map

package/dist/esm/server/useIntlayer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.mjs","names":["useIntlayerBase"],"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import type { DeclaredLocales, DictionaryKeys } from '@intlayer/types/module_augmentation';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport React from 'react';\nimport { useIntlayer as useIntlayerBase } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\n\nconst getCachedLocale =\n  typeof React.cache === 'function' ? React.cache(getLocale) : getLocale;\n\nexport const safeUseLocale = (): Locale | undefined => {\n  // getLocale returns a Promise based on your TS error\n  const localeData = getCachedLocale() as Promise<Locale> | Locale;\n\n  if (localeData instanceof Promise) {\n    if (typeof React.use === 'function') {\n      return React.use(localeData); // Safely unwraps in React 19+\n    }\n\n    // React < 19 cannot synchronously unwrap Promises in hooks.\n    // Return undefined to trigger the localeTarget fallback.\n    return undefined;\n  }\n\n  return localeData;\n};\n\n/**\n * On the server side, Hook that picking one dictionary by its key and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useIntlayer = <\n  T extends DictionaryKeys,\n  L extends DeclaredLocales = DeclaredLocales,\n>(\n  key: T,\n  locale?: L\n): ReturnType<typeof useIntlayerBase<T, L>> => {\n  const storedLocale = safeUseLocale();\n\n  return useIntlayerBase<T, L>(key, locale, storedLocale);\n};\n"],"mappings":"qHAMA,MAAM,EACJ,OAAO,EAAM,OAAU,WAAa,EAAM,MAAM,EAAU,CAAG,EAElD,MAA0C,CAErD,IAAM,EAAa,GAAiB,CAYpC,OAVI,aAAsB,QACpB,OAAO,EAAM,KAAQ,WAChB,EAAM,IAAI,EAAW,CAK9B,OAGK,GAQI,GAIX,EACA,IAIOA,EAAsB,EAAK,EAFb,GAAe,CAEmB"}
+{"version":3,"file":"useIntlayer.mjs","names":["useIntlayerBase"],"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import type { DeclaredLocales, DictionaryKeys } from '@intlayer/types/module_augmentation';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport React from 'react';\nimport { useIntlayer as useIntlayerBase } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\n\nconst getCachedLocale =\n  typeof React.cache === 'function' ? React.cache(getLocale) : getLocale;\n\nexport const safeUseLocale = (): Locale | undefined => {\n  // getLocale returns a Promise based on your TS error\n  const localeData = getCachedLocale() as Promise<Locale> | Locale;\n\n  if (localeData instanceof Promise) {\n    if (typeof React.use === 'function') {\n      return React.use(localeData); // Safely unwraps in React 19+\n    }\n\n    // React < 19 cannot synchronously unwrap Promises in hooks.\n    // Return undefined to trigger the localeTarget fallback.\n    return undefined;\n  }\n\n  return localeData;\n};\n\n/**\n * On the server side, Hook that picking one dictionary by its key and return the content\n *\n * If the locale is not provided, it will use the locale from the server context\n */\nexport const useIntlayer = <\n  T extends DictionaryKeys,\n  L extends DeclaredLocales = DeclaredLocales,\n>(\n  key: T,\n  locale?: L\n): ReturnType<typeof useIntlayerBase<T, L>> => {\n  const storedLocale = safeUseLocale();\n\n  return useIntlayerBase<T, L>(key, locale, storedLocale);\n};\n"],"mappings":";;;;;AAMA,MAAM,kBACJ,OAAO,MAAM,UAAU,aAAa,MAAM,MAAM,UAAU,GAAG;AAE/D,MAAa,sBAA0C;CAErD,MAAM,aAAa,iBAAiB;AAEpC,KAAI,sBAAsB,SAAS;AACjC,MAAI,OAAO,MAAM,QAAQ,WACvB,QAAO,MAAM,IAAI,WAAW;AAK9B;;AAGF,QAAO;;;;;;;AAQT,MAAa,eAIX,KACA,WAC6C;AAG7C,QAAOA,cAAsB,KAAK,QAFb,eAAe,CAEmB"}

package/dist/esm/server/withIntlayer.mjs

@@ -1,2 +1,254 @@
-import{IMPORT_MODE as e}from"@intlayer/config/defaultValues";import{join as t,relative as n,resolve as r}from"node:path";import{prepareIntlayer as i}from"@intlayer/chokidar/build";import{logConfigDetails as a}from"@intlayer/chokidar/cli";import{buildComponentFilesList as o,runOnce as s}from"@intlayer/chokidar/utils";import*as c from"@intlayer/config/colors";import{colorize as l,getAppLogger as u}from"@intlayer/config/logger";import{getConfiguration as d}from"@intlayer/config/node";import{compareVersions as f,getAlias as p,getProjectRequire as m,normalizePath as h}from"@intlayer/config/utils";import{getDictionaries as g}from"@intlayer/dictionaries-entry";import{IntlayerPlugin as _}from"@intlayer/webpack";import{defu as v}from"defu";import y from"next/package.json"with{type:"json"};const b=e=>{let t=y.version;try{t=(e.build?.require??m())(`next/package.json`).version}catch{}return{isGteNext13:f(t,`≥`,`13.0.0`),isGteNext15:f(t,`≥`,`15.0.0`),isGteNext16:f(t,`≥`,`16.0.0`),isTurbopackStable:f(t,`≥`,`15.3.0`)}},x=e=>{try{return(e.build?.require??m()).resolve(`@intlayer/swc`),!0}catch{return!1}},S=e=>{try{return(e.build?.require??m()).resolve(`@intlayer/babel`),!0}catch{return!1}},C=(e,t,r)=>{let i=(t.build?.require??m())?.resolve(e);return r?h(`./${n(process.cwd(),i)}`):i},w=(n,r,i,a,d)=>{let{optimize:f}=n.build,p=n.build.importMode??n.dictionary?.importMode,{dictionariesDir:m,unmergedDictionariesDir:h,dynamicDictionariesDir:_,fetchDictionariesDir:v,mainDir:y}=n.system,{baseDir:b}=n.system,w=u(n);if(f===!1||f===void 0&&!r||!d)return{};let T=x(n);if(s(t(b,`.intlayer`,`cache`,`intlayer-prune-plugin-enabled.lock`),()=>{w(T?`Build optimization enabled`:[l(`Recommended: Install`,c.GREY),l(`@intlayer/swc`,c.GREY_LIGHT),l(`package to enable build optimization. See documentation:`,c.GREY),l(`https://intlayer.org/docs/bundle-optimization`,c.GREY_LIGHT)])},{cacheTimeoutMs:1e3*30}),s(t(b,`.intlayer`,`cache`,`intlayer-compiler-plugin-enabled.lock`),()=>{if(S(n)){let e=n.compiler?.enabled??!0;e===`build-only`&&(e=!a),w(e?`Intlayer compiler enabled`:`Intlayer compiler disabled`)}},{cacheTimeoutMs:1e3*30}),!T)return{};let E=t(y,`dictionaries.mjs`),D=t(y,`dynamic_dictionaries.mjs`),O=t(y,`unmerged_dictionaries.mjs`),k=t(y,`fetch_dictionaries.mjs`),A=[...o(n),E,O],j=g(n),M={};return Object.values(j).forEach(t=>{M[t.key]=t.importMode??p??e}),{experimental:{swcPlugins:[[C(`@intlayer/swc`,n,i),{dictionariesDir:m,dictionariesEntryPath:E,unmergedDictionariesEntryPath:O,unmergedDictionariesDir:h,dynamicDictionariesDir:_,dynamicDictionariesEntryPath:D,fetchDictionariesDir:v,fetchDictionariesEntryPath:k,importMode:p,filesList:A,replaceDictionaryEntry:!0,dictionaryModeMap:M}]]}}},T=()=>{let e=process.env.npm_lifecycle_event,t=process.env.npm_lifecycle_script??``;return{isDevCommand:e===`dev`||process.argv.some(e=>e===`dev`)||/(^|\s)(next\s+)?dev(\s|$)/.test(t),isBuildCommand:e===`build`||process.argv.some(e=>e===`build`)||/(^|\s)(next\s+)?build(\s|$)/.test(t),isStartCommand:e===`start`||process.argv.some(e=>e===`start`)||/(^|\s)(next\s+)?start(\s|$)/.test(t)}},E=(e={},t)=>{typeof e!=`object`&&(e={});let n=d(t);a(t);let i=u(n),{isGteNext13:o,isGteNext15:s,isGteNext16:c,isTurbopackStable:l}=b(n),f=c?!process.env.npm_lifecycle_script?.includes(`--webpack`):process.env.npm_lifecycle_script?.includes(`--turbo`),m=t?.enableTurbopack??f;m&&e.webpack!==void 0&&i(`Turbopack is enabled but a custom webpack config is present. It will be ignored.`);let{isBuildCommand:h,isDevCommand:g}=T(),y={resolveAlias:p({configuration:n,formatter:e=>`./${e}`}),rules:{"*.node":{as:`*.node`,loaders:[`node-loader`]}}},x=[`esbuild`,`module`,`fs`,`chokidar`,`fsevents`,`recast`,`@intlayer/chokidar`,`@intlayer/webpack`],S=()=>{let t={env:{INTLAYER_EDITOR_ENABLED:n.editor?.enabled===!1?`false`:`true`}};return s&&(t={...t,serverExternalPackages:x}),o&&!s&&(t={...t,experimental:{...t?.experimental??{},serverComponentsExternalPackages:x}}),t=m?s&&l?{...t,turbopack:y}:{...t,experimental:{...t?.experimental??{},turbo:y}}:{...t,webpack:(t,i)=>{let{isServer:a,nextRuntime:o}=i;typeof e.webpack==`function`&&(t=e.webpack(t,i)),t.externals===!1&&(t.externals=[]);let s=new Set([`esbuild`,`module`,`fs`,`chokidar`,`fsevents`,`recast`]),c=[`@intlayer/chokidar`,`@intlayer/webpack`];return t.externals.push(({request:e},t)=>{if(e&&(s.has(e)||c.some(t=>e===t||e.startsWith(`${t}/`))))return t(null,`commonjs ${e}`);t(null)}),t.module.rules.push({test:/\.node$/,loader:`node-loader`}),t.resolve.alias={...t.resolve.alias,...p({configuration:n,formatter:e=>r(e)})},g&&a&&o===`nodejs`&&t.plugins.push(new _(n)),t}},t},C=w(n,h,m??!1,g,o);return v(v(S(),C),e)},D=async(e={},t)=>{let{isBuildCommand:n,isDevCommand:r,isStartCommand:a}=T();process.env.INTLAYER_IS_DEV_COMMAND=r?`true`:`false`;let o=d(t),{mode:s}=o.build;return!a&&(r||n||s===`auto`)&&await i(o,{clean:n,cacheTimeoutMs:n?1e3*30:1e3*60*60,env:n?`prod`:`dev`}),E(await e,t)};export{D as withIntlayer,E as withIntlayerSync};
+import { IMPORT_MODE } from "@intlayer/config/defaultValues";
+import { join, relative, resolve } from "node:path";
+import { prepareIntlayer } from "@intlayer/chokidar/build";
+import { logConfigDetails } from "@intlayer/chokidar/cli";
+import { buildComponentFilesList, runOnce } from "@intlayer/chokidar/utils";
+import * as ANSIColors from "@intlayer/config/colors";
+import { colorize, getAppLogger } from "@intlayer/config/logger";
+import { getConfiguration } from "@intlayer/config/node";
+import { compareVersions, getAlias, getProjectRequire, normalizePath } from "@intlayer/config/utils";
+import { getDictionaries } from "@intlayer/dictionaries-entry";
+import { IntlayerPlugin } from "@intlayer/webpack";
+import { defu } from "defu";
+import nextPackageJSON from "next/package.json" with { type: "json" };
+
+//#region src/server/withIntlayer.ts
+/**
+* Resolve the Next.js version from the *user's* project at runtime.
+* A static `import from 'next/package.json'` would resolve relative to
+* next-intlayer's own node_modules, which may differ in a monorepo.
+*/
+const getNextVersionFlags = (intlayerConfig) => {
+	let nextVersion = nextPackageJSON.version;
+	try {
+		nextVersion = (intlayerConfig.build?.require ?? getProjectRequire())("next/package.json").version;
+	} catch {}
+	return {
+		isGteNext13: compareVersions(nextVersion, "≥", "13.0.0"),
+		isGteNext15: compareVersions(nextVersion, "≥", "15.0.0"),
+		isGteNext16: compareVersions(nextVersion, "≥", "16.0.0"),
+		isTurbopackStable: compareVersions(nextVersion, "≥", "15.3.0")
+	};
+};
+const getIsSwcPluginAvailable = (intlayerConfig) => {
+	try {
+		(intlayerConfig.build?.require ?? getProjectRequire()).resolve("@intlayer/swc");
+		return true;
+	} catch (_e) {
+		return false;
+	}
+};
+const getIsBabelExtractPluginAvailable = (intlayerConfig) => {
+	try {
+		(intlayerConfig.build?.require ?? getProjectRequire()).resolve("@intlayer/babel");
+		return true;
+	} catch (_e) {
+		return false;
+	}
+};
+const resolvePluginPath = (pluginPath, intlayerConfig, isTurbopackEnabled) => {
+	const pluginPathResolved = (intlayerConfig.build?.require ?? getProjectRequire())?.resolve(pluginPath);
+	if (isTurbopackEnabled) return normalizePath(`./${relative(process.cwd(), pluginPathResolved)}`);
+	return pluginPathResolved;
+};
+const getPruneConfig = (intlayerConfig, isBuildCommand, isTurbopackEnabled, isDevCommand, isGteNext13) => {
+	const { optimize } = intlayerConfig.build;
+	const importMode = intlayerConfig.build.importMode ?? intlayerConfig.dictionary?.importMode;
+	const { dictionariesDir, unmergedDictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, mainDir } = intlayerConfig.system;
+	const { baseDir } = intlayerConfig.system;
+	const logger = getAppLogger(intlayerConfig);
+	if (optimize === false) return {};
+	if (optimize === void 0 && !isBuildCommand) return {};
+	if (!isGteNext13) return {};
+	const isSwcPluginAvailable = getIsSwcPluginAvailable(intlayerConfig);
+	runOnce(join(baseDir, ".intlayer", "cache", "intlayer-prune-plugin-enabled.lock"), () => {
+		if (isSwcPluginAvailable) logger("Build optimization enabled");
+		else logger([
+			colorize("Recommended: Install", ANSIColors.GREY),
+			colorize("@intlayer/swc", ANSIColors.GREY_LIGHT),
+			colorize("package to enable build optimization. See documentation:", ANSIColors.GREY),
+			colorize("https://intlayer.org/docs/bundle-optimization", ANSIColors.GREY_LIGHT)
+		]);
+	}, { cacheTimeoutMs: 1e3 * 30 });
+	runOnce(join(baseDir, ".intlayer", "cache", "intlayer-compiler-plugin-enabled.lock"), () => {
+		if (getIsBabelExtractPluginAvailable(intlayerConfig)) {
+			let isEnabled = intlayerConfig.compiler?.enabled ?? true;
+			if (isEnabled === "build-only") isEnabled = !isDevCommand;
+			if (isEnabled) logger("Intlayer compiler enabled");
+			else logger("Intlayer compiler disabled");
+		}
+	}, { cacheTimeoutMs: 1e3 * 30 });
+	if (!isSwcPluginAvailable) return {};
+	const dictionariesEntryPath = join(mainDir, "dictionaries.mjs");
+	const dynamicDictionariesEntryPath = join(mainDir, "dynamic_dictionaries.mjs");
+	const unmergedDictionariesEntryPath = join(mainDir, "unmerged_dictionaries.mjs");
+	const fetchDictionariesEntryPath = join(mainDir, "fetch_dictionaries.mjs");
+	const filesList = [
+		...buildComponentFilesList(intlayerConfig),
+		dictionariesEntryPath,
+		unmergedDictionariesEntryPath
+	];
+	const dictionaries = getDictionaries(intlayerConfig);
+	const dictionaryModeMap = {};
+	Object.values(dictionaries).forEach((dictionary) => {
+		dictionaryModeMap[dictionary.key] = dictionary.importMode ?? importMode ?? IMPORT_MODE;
+	});
+	return { experimental: { swcPlugins: [[resolvePluginPath("@intlayer/swc", intlayerConfig, isTurbopackEnabled), {
+		dictionariesDir,
+		dictionariesEntryPath,
+		unmergedDictionariesEntryPath,
+		unmergedDictionariesDir,
+		dynamicDictionariesDir,
+		dynamicDictionariesEntryPath,
+		fetchDictionariesDir,
+		fetchDictionariesEntryPath,
+		importMode,
+		filesList,
+		replaceDictionaryEntry: true,
+		dictionaryModeMap
+	}]] } };
+};
+const getCommandsEvent = () => {
+	const lifecycleEvent = process.env.npm_lifecycle_event;
+	const lifecycleScript = process.env.npm_lifecycle_script ?? "";
+	return {
+		isDevCommand: lifecycleEvent === "dev" || process.argv.some((arg) => arg === "dev") || /(^|\s)(next\s+)?dev(\s|$)/.test(lifecycleScript),
+		isBuildCommand: lifecycleEvent === "build" || process.argv.some((arg) => arg === "build") || /(^|\s)(next\s+)?build(\s|$)/.test(lifecycleScript),
+		isStartCommand: lifecycleEvent === "start" || process.argv.some((arg) => arg === "start") || /(^|\s)(next\s+)?start(\s|$)/.test(lifecycleScript)
+	};
+};
+/**
+* A Next.js plugin that adds the intlayer configuration to the webpack configuration
+* and sets the environment variables
+*
+* Usage:
+*
+* ```ts
+* // next.config.js
+* export default withIntlayerSync(nextConfig)
+* ```
+*/
+const withIntlayerSync = (nextConfig = {}, configOptions) => {
+	if (typeof nextConfig !== "object") nextConfig = {};
+	const intlayerConfig = getConfiguration(configOptions);
+	logConfigDetails(configOptions);
+	const logger = getAppLogger(intlayerConfig);
+	const { isGteNext13, isGteNext15, isGteNext16, isTurbopackStable } = getNextVersionFlags(intlayerConfig);
+	const isTurbopackEnabledFromCommand = isGteNext16 ? !process.env.npm_lifecycle_script?.includes("--webpack") : process.env.npm_lifecycle_script?.includes("--turbo");
+	const isTurbopackEnabled = configOptions?.enableTurbopack ?? isTurbopackEnabledFromCommand;
+	if (isTurbopackEnabled && typeof nextConfig.webpack !== "undefined") logger("Turbopack is enabled but a custom webpack config is present. It will be ignored.");
+	const { isBuildCommand, isDevCommand } = getCommandsEvent();
+	const turboConfig = {
+		resolveAlias: getAlias({
+			configuration: intlayerConfig,
+			formatter: (value) => `./${value}`
+		}),
+		rules: { "*.node": {
+			as: "*.node",
+			loaders: ["node-loader"]
+		} }
+	};
+	const serverExternalPackages = [
+		"esbuild",
+		"module",
+		"fs",
+		"chokidar",
+		"fsevents",
+		"recast",
+		"@intlayer/chokidar",
+		"@intlayer/webpack"
+	];
+	const getNewConfig = () => {
+		let config = { env: { INTLAYER_EDITOR_ENABLED: intlayerConfig.editor?.enabled === false ? "false" : "true" } };
+		if (isGteNext15) config = {
+			...config,
+			serverExternalPackages
+		};
+		if (isGteNext13 && !isGteNext15) config = {
+			...config,
+			experimental: {
+				...config?.experimental ?? {},
+				serverComponentsExternalPackages: serverExternalPackages
+			}
+		};
+		if (isTurbopackEnabled) if (isGteNext15 && isTurbopackStable) config = {
+			...config,
+			turbopack: turboConfig
+		};
+		else config = {
+			...config,
+			experimental: {
+				...config?.experimental ?? {},
+				turbo: turboConfig
+			}
+		};
+		else config = {
+			...config,
+			webpack: (config, options) => {
+				const { isServer, nextRuntime } = options;
+				if (typeof nextConfig.webpack === "function") config = nextConfig.webpack(config, options);
+				if (config.externals === false) config.externals = [];
+				const externalExact = new Set([
+					"esbuild",
+					"module",
+					"fs",
+					"chokidar",
+					"fsevents",
+					"recast"
+				]);
+				const externalPrefixes = ["@intlayer/chokidar", "@intlayer/webpack"];
+				config.externals.push(({ request }, callback) => {
+					if (request && (externalExact.has(request) || externalPrefixes.some((p) => request === p || request.startsWith(`${p}/`)))) return callback(null, `commonjs ${request}`);
+					callback(null);
+				});
+				config.module.rules.push({
+					test: /\.node$/,
+					loader: "node-loader"
+				});
+				config.resolve.alias = {
+					...config.resolve.alias,
+					...getAlias({
+						configuration: intlayerConfig,
+						formatter: (value) => resolve(value)
+					})
+				};
+				if (isDevCommand && isServer && nextRuntime === "nodejs") config.plugins.push(new IntlayerPlugin(intlayerConfig));
+				return config;
+			}
+		};
+		return config;
+	};
+	const pruneConfig = getPruneConfig(intlayerConfig, isBuildCommand, isTurbopackEnabled ?? false, isDevCommand, isGteNext13);
+	return defu(defu(getNewConfig(), pruneConfig), nextConfig);
+};
+/**
+* A Next.js plugin that adds the intlayer configuration to the webpack configuration
+* and sets the environment variables
+*
+* Usage:
+*
+* ```ts
+* // next.config.js
+* export default withIntlayer(nextConfig)
+* ```
+*
+* > Node withIntlayer is a promise function. Use withIntlayerSync instead if you want to use it synchronously.
+* > Using the promise allows to prepare the intlayer dictionaries before the build starts.
+*
+*/
+const withIntlayer = async (nextConfig = {}, configOptions) => {
+	const { isBuildCommand, isDevCommand, isStartCommand } = getCommandsEvent();
+	process.env.INTLAYER_IS_DEV_COMMAND = isDevCommand ? "true" : "false";
+	const intlayerConfig = getConfiguration(configOptions);
+	const { mode } = intlayerConfig.build;
+	if (!isStartCommand && (isDevCommand || isBuildCommand || mode === "auto")) await prepareIntlayer(intlayerConfig, {
+		clean: isBuildCommand,
+		cacheTimeoutMs: isBuildCommand ? 1e3 * 30 : 1e3 * 60 * 60,
+		env: isBuildCommand ? "prod" : "dev"
+	});
+	return withIntlayerSync(await nextConfig, configOptions);
+};
+
+//#endregion
+export { withIntlayer, withIntlayerSync };
 //# sourceMappingURL=withIntlayer.mjs.map