@intlayer/next-intl 9.4.4 → 9.5.0

package/dist/types/react-server/index.d.ts

@@ -0,0 +1,9 @@
+import { NextIntlClientProvider, NextIntlClientProviderProps } from "../client/NextIntlClientProvider.js";
+import { Routing, defineRouting } from "../routing.js";
+import { useFormatter, useNow, useTimeZone } from "./helpers.js";
+import { useDictionary } from "./useDictionary.js";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
+import { useLocale } from "./useLocale.js";
+import { useTranslations } from "./useTranslations.js";
+import { IntlError, IntlErrorCode, createFormatter, createTranslator, hasLocale, initializeConfig, useMessages } from "@intlayer/use-intl";
+export { IntlError, IntlErrorCode, NextIntlClientProvider, type NextIntlClientProviderProps, type Routing, createFormatter, createTranslator, defineRouting, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/react-server/resolveLocale.d.ts

@@ -0,0 +1,14 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/react-server/resolveLocale.d.ts
+/**
+ * Locale for a synchronous server hook, resolved the same way `getLocale()`
+ * resolves it — so server-rendered content and the client provider never
+ * disagree about which locale the request is in.
+ *
+ * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+ *    route segment), which is next-intl's source of truth for URL routing.
+ * 2. Otherwise Intlayer's ambient locale (server context, then the request).
+ */
+export declare const resolveServerLocale: () => LocalesValues;
+//#endregion
+//# sourceMappingURL=resolveLocale.d.ts.map

package/dist/types/react-server/resolveLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveLocale.d.ts","names":[],"sources":["../../../src/react-server/resolveLocale.ts"],"mappings":";;;;;;;;;;;qBAaa,2BAA0B"}

package/dist/types/react-server/useDictionary.d.ts

@@ -0,0 +1,24 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ScopedTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/react-server/useDictionary.d.ts
+/**
+ * Overload set mirroring the client `useDictionary` exactly, so the optimize
+ * pass can emit the same call shape whichever side of the boundary the
+ * component ends up on.
+ */
+type UseDictionary = {
+  <T extends Dictionary>(dictionary: T): TranslateFunction<T['key'] & DictionaryKeys>;
+  <T extends Dictionary, Prefix extends string>(dictionary: T, namespacePrefix: Prefix): ScopedTranslateFunction<T['key'] & DictionaryKeys, Prefix>;
+};
+/**
+ * Server counterpart of `@intlayer/use-intl`'s `useDictionary`.
+ *
+ * The optimize pass rewrites every `useTranslations(...)` call to this helper
+ * with the dictionary pre-imported. Resolving it here — rather than in a client
+ * component — keeps the dictionary out of the client bundle entirely: the
+ * server renders the text and only the rendered output crosses the boundary.
+ */
+export declare const useDictionary: UseDictionary;
+//#endregion
+//# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/react-server/useDictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/react-server/useDictionary.ts"],"mappings":";;;;;;;;;KAkBK;GACF,UAAU,YACT,YAAY,IACX,kBAAkB,WAAW;GAC/B,UAAU,YAAY,uBACrB,YAAY,GACZ,iBAAiB,SAChB,wBAAwB,WAAW,gBAAgB;;;;;;;;;;qBAW3C,eAYP"}

package/dist/types/react-server/useDictionaryDynamic.d.ts

@@ -0,0 +1,15 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ScopedTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/react-server/useDictionaryDynamic.d.ts
+type UseDictionaryDynamic = {
+  <T extends Dictionary, K extends DictionaryKeys>(dictionaryPromise: Record<string, () => Promise<T>>, key: K): TranslateFunction<K>;
+  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(dictionaryPromise: Record<string, () => Promise<T>>, key: K, namespacePrefix: Prefix): ScopedTranslateFunction<K, Prefix>;
+};
+/**
+ * Server counterpart of `useDictionaryDynamic`, emitted by the optimize pass
+ * for dictionaries on the per-locale loader.
+ */
+export declare const useDictionaryDynamic: UseDictionaryDynamic;
+//#endregion
+//# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/react-server/useDictionaryDynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/react-server/useDictionaryDynamic.ts"],"mappings":";;;;KAaK;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,qBAAqB,QAAQ,KAChD,KAAK,IACJ,kBAAkB;GACpB,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,qBAAqB,QAAQ,KAChD,KAAK,GACL,iBAAiB,SAChB,wBAAwB,GAAG;;;;;;qBAOnB,sBAiBP"}

package/dist/types/react-server/useLocale.d.ts

@@ -0,0 +1,9 @@
+import { useLocale as useLocale$1 } from "next-intl";
+//#region src/react-server/useLocale.d.ts
+/**
+ * Server counterpart of `useLocale`, resolved from the `[locale]` route segment
+ * forwarded through `setRequestLocale` when the app provides one.
+ */
+export declare const useLocale: typeof useLocale$1;
+//#endregion
+//# sourceMappingURL=useLocale.d.ts.map

package/dist/types/react-server/useLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/react-server/useLocale.ts"],"mappings":";;;;;;qBAOa,kBAAkB"}

package/dist/types/react-server/useTranslations.d.ts

@@ -0,0 +1,23 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { LooseTranslateFunction, TranslateFunction, TranslateFunctionForNamespace } from "@intlayer/use-intl";
+//#region src/react-server/useTranslations.d.ts
+type UseTranslations = {
+  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;
+  <N extends `${string}.${string}`>(namespace: N): TranslateFunctionForNamespace<N>;
+  (): LooseTranslateFunction;
+};
+/**
+ * Server counterpart of `useTranslations`.
+ *
+ * next-intl's `useTranslations` is isomorphic — the same component code runs in
+ * a Server or a Client Component — so the adapter has to be too. Without this
+ * every component calling it is forced across the client boundary, which drags
+ * its dictionary into a client chunk that Next shares across every locale.
+ *
+ * The optimize pass normally rewrites these calls to `useDictionary` with the
+ * dictionary inlined; this runtime path covers the calls it could not resolve
+ * statically (a dynamic namespace, or an unoptimized build).
+ */
+export declare const useTranslations: UseTranslations;
+//#endregion
+//# sourceMappingURL=useTranslations.d.ts.map

package/dist/types/react-server/useTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../src/react-server/useTranslations.ts"],"mappings":";;;KAUK;GACF,UAAU,gBAAgB,WAAW,IAAI,kBAAkB;GAC3D,iCACC,WAAW,IACV,8BAA8B;MAC7B;;;;;;;;;;;;;;qBAsBO,iBAmBP"}

package/dist/types/server/react/helpers.d.ts

@@ -0,0 +1,15 @@
+//#region src/server/react/helpers.d.ts
+/**
+ * Server counterparts of use-intl's ambient hooks. They mirror the client
+ * versions' signatures so the same component code type-checks on both sides.
+ */
+export declare const useFormatter: typeof import('@intlayer/use-intl').useFormatter;
+/** Current time on the server render. */
+export declare const useNow: typeof import('@intlayer/use-intl').useNow;
+/**
+ * Time zone the formatters resolve against — the same value the async
+ * `getTimeZone()` reports, so both server surfaces agree.
+ */
+export declare const useTimeZone: typeof import('@intlayer/use-intl').useTimeZone;
+//#endregion
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/server/react/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../../src/server/react/helpers.ts"],"mappings":";;;;;qBAOa,kDAAkD;;qBAIlD,4CAA4C;;;;;qBAO5C,iDAAiD"}

package/dist/types/server/react/index.d.ts

@@ -0,0 +1,9 @@
+import { NextIntlClientProvider, NextIntlClientProviderProps } from "../../client/NextIntlClientProvider.js";
+import { Routing, defineRouting } from "../../routing.js";
+import { useFormatter, useNow, useTimeZone } from "./helpers.js";
+import { useDictionary } from "./useDictionary.js";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
+import { useLocale } from "./useLocale.js";
+import { useTranslations } from "./useTranslations.js";
+import { IntlError, IntlErrorCode, createFormatter, createTranslator, hasLocale, initializeConfig, useMessages } from "@intlayer/use-intl";
+export { IntlError, IntlErrorCode, NextIntlClientProvider, type NextIntlClientProviderProps, type Routing, createFormatter, createTranslator, defineRouting, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/server/react/resolveLocale.d.ts

@@ -0,0 +1,18 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/server/react/resolveLocale.d.ts
+/**
+ * Locale for the synchronous server hooks, resolved the way `getLocale()`
+ * resolves it — so server-rendered output and the client provider never
+ * disagree about which locale the request is in.
+ *
+ * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+ *    route segment), which is next-intl's source of truth for URL routing.
+ * 2. Otherwise Intlayer's ambient locale (server context, then the request).
+ *
+ * The second rung must stay lazy. It ends in `headers()` / `cookies()`, which
+ * opts the route into dynamic rendering: evaluating it eagerly took this
+ * package's own benchmark app from 14 prerendered pages to 0.
+ */
+export declare const resolveServerLocale: () => LocalesValues;
+//#endregion
+//# sourceMappingURL=resolveLocale.d.ts.map

package/dist/types/server/react/resolveLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveLocale.d.ts","names":[],"sources":["../../../../src/server/react/resolveLocale.ts"],"mappings":";;;;;;;;;;;;;;;qBAsBa,2BAA0B"}

package/dist/types/server/react/useDictionary.d.ts

@@ -0,0 +1,24 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ScopedTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/server/react/useDictionary.d.ts
+/**
+ * Overload set mirroring the client `useDictionary` exactly, so the optimize
+ * pass can emit the same call shape whichever side of the boundary the
+ * component ends up on.
+ */
+type UseDictionary = {
+  <T extends Dictionary>(dictionary: T): TranslateFunction<T['key'] & DictionaryKeys>;
+  <T extends Dictionary, Prefix extends string>(dictionary: T, namespacePrefix: Prefix): ScopedTranslateFunction<T['key'] & DictionaryKeys, Prefix>;
+};
+/**
+ * Server counterpart of `@intlayer/use-intl`'s `useDictionary`.
+ *
+ * The optimize pass rewrites every `useTranslations(...)` call to this helper
+ * with the dictionary pre-imported. Resolving it here — rather than in a client
+ * component — keeps the dictionary out of the client bundle entirely: the
+ * server renders the text and only the rendered output crosses the boundary.
+ */
+export declare const useDictionary: UseDictionary;
+//#endregion
+//# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/server/react/useDictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../../src/server/react/useDictionary.ts"],"mappings":";;;;;;;;;KAeK;GACF,UAAU,YACT,YAAY,IACX,kBAAkB,WAAW;GAC/B,UAAU,YAAY,uBACrB,YAAY,GACZ,iBAAiB,SAChB,wBAAwB,WAAW,gBAAgB;;;;;;;;;;qBAW3C,eAQP"}

package/dist/types/server/react/useDictionaryDynamic.d.ts

@@ -0,0 +1,15 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ScopedTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/server/react/useDictionaryDynamic.d.ts
+type UseDictionaryDynamic = {
+  <T extends Dictionary, K extends DictionaryKeys>(dictionaryPromise: Record<string, () => Promise<T>>, key: K): TranslateFunction<K>;
+  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(dictionaryPromise: Record<string, () => Promise<T>>, key: K, namespacePrefix: Prefix): ScopedTranslateFunction<K, Prefix>;
+};
+/**
+ * Server counterpart of `useDictionaryDynamic`, emitted by the optimize pass
+ * for dictionaries on the per-locale loader.
+ */
+export declare const useDictionaryDynamic: UseDictionaryDynamic;
+//#endregion
+//# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/server/react/useDictionaryDynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../../src/server/react/useDictionaryDynamic.ts"],"mappings":";;;;KAUK;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,qBAAqB,QAAQ,KAChD,KAAK,IACJ,kBAAkB;GACpB,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,qBAAqB,QAAQ,KAChD,KAAK,GACL,iBAAiB,SAChB,wBAAwB,GAAG;;;;;;qBAOnB,sBAaP"}

package/dist/types/server/react/useLocale.d.ts

@@ -0,0 +1,9 @@
+import { useLocale as useLocale$1 } from "next-intl";
+//#region src/server/react/useLocale.d.ts
+/**
+ * Server counterpart of `useLocale`, resolved from the `[locale]` route segment
+ * forwarded through `setRequestLocale` when the app provides one.
+ */
+export declare const useLocale: typeof useLocale$1;
+//#endregion
+//# sourceMappingURL=useLocale.d.ts.map

package/dist/types/server/react/useLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../../src/server/react/useLocale.ts"],"mappings":";;;;;;qBAOa,kBAAkB"}

package/dist/types/server/react/useTranslations.d.ts

@@ -0,0 +1,23 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { LooseTranslateFunction, TranslateFunction, TranslateFunctionForNamespace } from "@intlayer/use-intl";
+//#region src/server/react/useTranslations.d.ts
+type UseTranslations = {
+  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;
+  <N extends `${string}.${string}`>(namespace: N): TranslateFunctionForNamespace<N>;
+  (): LooseTranslateFunction;
+};
+/**
+ * Server counterpart of `useTranslations`.
+ *
+ * next-intl's `useTranslations` is isomorphic — the same component code runs in
+ * a Server or a Client Component — so the adapter has to be too. Without this
+ * every component calling it is forced across the client boundary, which drags
+ * its dictionary into a client chunk that Next shares across every locale.
+ *
+ * The optimize pass normally rewrites these calls to `useDictionary` with the
+ * dictionary inlined; this runtime path covers the calls it could not resolve
+ * statically (a dynamic namespace, or an unoptimized build).
+ */
+export declare const useTranslations: UseTranslations;
+//#endregion
+//# sourceMappingURL=useTranslations.d.ts.map

package/dist/types/server/react/useTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../../src/server/react/useTranslations.ts"],"mappings":";;;KAUK;GACF,UAAU,gBAAgB,WAAW,IAAI,kBAAkB;GAC3D,iCACC,WAAW,IACV,8BAA8B;MAC7B;;;;;;;;;;;;;;qBAsBO,iBAmBP"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/next-intl",
-  "version": "9.4.4",
+  "version": "9.5.0",
   "private": false,
   "description": "next-intl API adapter for intlayer — useTranslations, useLocale, getTranslations, getLocale, NextIntlClientProvider backed by next-intlayer",
   "keywords": [
@@ -36,6 +36,7 @@
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
+      "react-server": "./dist/esm/server/react/index.mjs",
       "require": "./dist/cjs/index.cjs",
       "import": "./dist/esm/index.mjs"
     },
@@ -110,17 +111,17 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.4.4",
-    "@intlayer/core": "9.4.4",
-    "@intlayer/dictionaries-entry": "9.4.4",
-    "@intlayer/engine": "9.4.4",
-    "@intlayer/types": "9.4.4",
-    "@intlayer/use-intl": "9.4.4",
-    "next-intlayer": "9.4.4",
-    "react-intlayer": "9.4.4"
+    "@intlayer/config": "9.5.0",
+    "@intlayer/core": "9.5.0",
+    "@intlayer/dictionaries-entry": "9.5.0",
+    "@intlayer/engine": "9.5.0",
+    "@intlayer/types": "9.5.0",
+    "@intlayer/use-intl": "9.5.0",
+    "next-intlayer": "9.5.0",
+    "react-intlayer": "9.5.0"
   },
   "devDependencies": {
-    "@types/node": "26.4.1",
+    "@types/node": "26.5.0",
     "@types/react": "19.2.18",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",