next-intlayer 9.3.3 → 9.4.0

package/dist/types/server/format/useUnit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/server/format/useUnit.ts"],"mappings":";;;;;;;;;;;;cAaa,mBAAO,MAGD,kBAAkB"}

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

@@ -1,4 +1,14 @@
+import { IntlayerProvider, IntlayerProviderProps } from "./IntlayerProvider.js";
+import { t } from "./t.js";
+import { useDictionary } from "./useDictionary.js";
+import { useDictionaryAsync } from "./useDictionaryAsync.js";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
+import { useI18n } from "./useI18n.js";
+import { useIntl } from "./useIntl.js";
+import { useIntlayer } from "./useIntlayer.js";
+import { UseLocaleResult, useLocale } from "./useLocale.js";
+import { IntlayerServerProvider, IntlayerServerProviderProps } from "./IntlayerServerProvider.js";
 import { getLocale } from "./getLocale.js";
 import { withIntlayer, withIntlayerSync } from "./withIntlayer.js";
-import { IntlayerServerProvider, IntlayerServerProviderProps, locale, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale } from "react-intlayer/server";
-export { IntlayerServerProvider, type IntlayerServerProviderProps, getLocale, locale, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale, withIntlayer, withIntlayerSync };
+import { getServerContext, locale, setLocale, setVariant, useLoadDynamic } from "react-intlayer/server";
+export { IntlayerProvider, type IntlayerProviderProps, IntlayerServerProvider, type IntlayerServerProviderProps, type UseLocaleResult, getLocale, getServerContext, locale, setLocale, setVariant, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale, withIntlayer, withIntlayerSync };

package/dist/types/server/prepareSwcOptimization.d.ts

@@ -1,9 +1,9 @@
 import { SerializedFieldRenameMap } from "../@intlayer/babel/dist/types/babel-plugin-intlayer-field-rename.js";
 import "../@intlayer/babel/dist/types/index.js";
+import { Dictionary } from "@intlayer/types/dictionary";
 import { SwcExtraCallerConfig } from "@intlayer/config/callers";
 import { GetConfigurationOptions } from "@intlayer/config/node";
 import { IntlayerConfig } from "@intlayer/types/config";
-import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/server/prepareSwcOptimization.d.ts
 /**
  * Field-rename tables keyed by dictionary key, forwarded to the

package/dist/types/server/prepareSwcOptimization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepareSwcOptimization.d.ts","names":[],"sources":["../../../src/server/prepareSwcOptimization.ts"],"mappings":";;;;;;;;;;;KAsBY,gCAAgC,eAE1C;;KAIU;;;;;;;;cAoDC,qBAAkB,gBACb,mBACf;;;;;;;;;cAmGU,8BAA2B,gBACtB;KAkGb;;EAEH,gBAAgB;;EAEhB,eAAe;;EAEf,kBAAkB;;;;;EAKlB;;;;;;;;;;;;;;;;;;;;;;cAuBW,yBAAsB,gBACjB,gBAAc,QACtB,iCACP,QAAQ"}
+{"version":3,"file":"prepareSwcOptimization.d.ts","names":[],"sources":["../../../src/server/prepareSwcOptimization.ts"],"mappings":";;;;;;;;;;;KAsBY,gCAAgC,eAE1C;;KAIU;;;;;;;;cAoDC,qBAAkB,gBACb,mBACf;;;;;;;;;cAqGU,8BAA2B,gBACtB;KAkGb;;EAEH,gBAAgB;;EAEhB,eAAe;;EAEf,kBAAkB;;;;;EAKlB;;;;;;;;;;;;;;;;;;;;;;cAuBW,yBAAsB,gBACjB,gBAAc,QACtB,iCACP,QAAQ"}

package/dist/types/server/suspendingReader.d.ts

@@ -0,0 +1,22 @@
+//#region src/server/suspendingReader.d.ts
+/**
+ * Turns an async loader into a synchronous reader that suspends until the
+ * value is available, without going through `React.use`.
+ *
+ * `React.use` matches its per-component state positionally across suspense
+ * retries, so a `use()` call whose condition can change between attempts
+ * (here: the server context is seeded by the provider concurrently with the
+ * page render) shifts the index and hands a later `use()` — such as the
+ * dynamic dictionary chunk loader — the wrong promise's value. Throwing the
+ * promise ourselves and caching the settlement in a request-scoped store
+ * keeps the suspension mechanics without touching React's positional state,
+ * which makes the ambient chain safe to run conditionally.
+ *
+ * Requires `React.cache` for per-request isolation; without it (React < 19)
+ * the reader reports `undefined` so callers fall back to the default locale,
+ * matching the previous behavior.
+ */
+declare const createSuspendingReader: <T>(load: () => Promise<T | undefined>) => (() => T | undefined);
+//#endregion
+export { createSuspendingReader };
+//# sourceMappingURL=suspendingReader.d.ts.map

package/dist/types/server/suspendingReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspendingReader.d.ts","names":[],"sources":["../../../src/server/suspendingReader.ts"],"mappings":";;;;;;;;;;;;;;;;;;cA0Ba,yBAA0B,GAAC,YAC1B,QAAQ,0BACZ"}

package/dist/types/server/t.d.ts

@@ -0,0 +1,13 @@
+import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { t as t$1 } from "react-intlayer/server";
+//#region src/server/t.d.ts
+/**
+ * On the server side, returns the translation of a multilingual object.
+ *
+ * If the locale is not provided, it will use the locale from the server
+ * context, falling back to the locale carried by the request.
+ */
+declare const t: <Content = string, L extends LocalesValues = DeclaredLocales>(multilangContent: StrictModeLocaleMap<Content>, locale?: L) => ReturnType<typeof t$1<Content, L>>;
+//#endregion
+export { t };
+//# sourceMappingURL=t.d.ts.map

package/dist/types/server/t.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;;;;;cAca,IAAK,kBAAkB,UAAU,gBAAgB,iBAAe,kBACzD,oBAAoB,UAAQ,SACrC,MACR,kBAAkB,IAAM,SAAS"}

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

@@ -6,7 +6,8 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from
  * On the server side, hook that transforms a dictionary (or qualified
  * dictionary group) and returns the content for the given locale or selector.
  *
- * If the locale is not provided, it will use the locale from the server context.
+ * If the locale is not provided, it will use the locale from the server
+ * context, falling back to the locale carried by the request.
  */
 declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => ReturnType<typeof useDictionary$1<T, A>>;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;cAmBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,kBAAkB,gBAAkB,GAAG"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;;cAmBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,kBAAkB,gBAAkB,GAAG"}

package/dist/types/server/useDictionaryAsync.d.ts

@@ -1,13 +1,14 @@
-import { DeclaredLocales, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { useDictionaryAsync as useDictionaryAsync$1 } from "react-intlayer/server";
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/server/useDictionaryAsync.d.ts
 /**
- * On the server side, Hook that transform a dictionary and return the content
+ * On the server side, hook that transforms a dictionary and returns the content
  *
- * If the locale is not provided, it will use the locale from the server context
+ * If the locale is not provided, it will use the locale from the server
+ * context, falling back to the locale carried by the request.
  */
-declare const useDictionaryAsync: <const T extends Dictionary, const L extends DeclaredLocales = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L) => ReturnType<typeof useDictionaryAsync$1<T, L>>;
+declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L) => ReturnType<typeof useDictionaryAsync$1<T, L>>;
 //#endregion
 export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

package/dist/types/server/useDictionaryAsync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;cAaa,2BACL,UAAU,kBACV,UAAU,kBAAkB,iBAAe,mBAE9B,0BAA0B,QAAQ,KAAG,SAC/C,MACR,kBAAkB,qBAAuB,GAAG"}
+{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;;cAea,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,MACR,kBAAkB,qBAAuB,GAAG"}

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

@@ -1,13 +1,14 @@
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { useDictionaryDynamic as useDictionaryDynamic$1 } from "react-intlayer/server";
-import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator";
 import { Dictionary, DictionarySelector } from "@intlayer/types/dictionary";
+import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator";
 //#region src/server/useDictionaryDynamic.d.ts
 /**
  * On the server side, hook that lazily loads a dictionary (plain or qualified)
  * and returns the content for the given locale or selector.
  *
- * If the locale is not provided, it will use the locale from the server context.
+ * If the locale is not provided, it will use the locale from the server
+ * context, falling back to the locale carried by the request.
  */
 declare const useDictionaryDynamic: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A) => ReturnType<typeof useDictionaryDynamic$1<T, A>>;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;cAmBa,6BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAGhE,0BAA0B,QAAQ,MAClC,2BAAyB,aAClB,mBACQ,MAClB,kBAAkB,uBAAyB,GAAG"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;cAoBa,6BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAGhE,0BAA0B,QAAQ,MAClC,2BAAyB,aAClB,mBACQ,MAClB,kBAAkB,uBAAyB,GAAG"}

package/dist/types/server/useI18n.d.ts

@@ -0,0 +1,14 @@
+import { DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
+import { useI18n as useI18n$1 } from "react-intlayer/server";
+//#region src/server/useI18n.d.ts
+/**
+ * On the server side, hook returning a `t(path)` function scoped to one
+ * dictionary key, in the i18next / next-intl style.
+ *
+ * If the locale is not provided, it will use the locale from the server
+ * context, falling back to the locale carried by the request.
+ */
+declare const useI18n: <T extends DictionaryKeys>(namespace: T, locale?: LocalesValues) => ReturnType<typeof useI18n$1<T>>;
+//#endregion
+export { useI18n };
+//# sourceMappingURL=useI18n.d.ts.map

package/dist/types/server/useI18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/server/useI18n.ts"],"mappings":";;;;;;;;;;cAca,UAAW,UAAU,gBAAc,WACnC,GAAC,SACH,kBACR,kBAAkB,UAAY"}

package/dist/types/server/useIntl.d.ts

@@ -0,0 +1,13 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { WrappedIntl } from "@intlayer/core/formatters";
+//#region src/server/useIntl.d.ts
+/**
+ * On the server side, hook providing a locale-bound `Intl` object.
+ *
+ * If the locale is not provided, it will use the locale from the server
+ * context, falling back to the locale carried by the request.
+ */
+declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
+//#endregion
+export { useIntl };
+//# sourceMappingURL=useIntl.d.ts.map

package/dist/types/server/useIntl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/server/useIntl.ts"],"mappings":";;;;;;;;;cAWa,UAAO,SAAa,kBAAgB"}

package/dist/types/server/useIntlayer.d.ts

@@ -1,16 +1,15 @@
 import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
 import { useIntlayer as useIntlayer$1 } from "react-intlayer/server";
 //#region src/server/useIntlayer.d.ts
-declare const safeUseLocale: () => Locale | undefined;
 /**
- * On the server side, hook that picks one dictionary by its key and returns the
+ * On the server side, hook picking one dictionary by its key and returning the
  * content for the given locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  *
- * If the locale is not provided, it will use the locale from the server context.
+ * If the locale is not provided, it will use the locale from the server
+ * context, falling back to the locale carried by the request.
  */
 declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => ReturnType<typeof useIntlayer$1<T, A>>;
 //#endregion
-export { safeUseLocale, useIntlayer };
+export { useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

package/dist/types/server/useIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;cAca,qBAAoB;;;;;;;;cAwBpB,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,kBAAkB,cAAgB,GAAG"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;;cAiBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,kBAAkB,cAAgB,GAAG"}

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

@@ -0,0 +1,20 @@
+import { DeclaredLocales } from "@intlayer/types/module_augmentation";
+//#region src/server/useLocale.d.ts
+type UseLocaleResult = {
+  locale: DeclaredLocales;
+  defaultLocale: DeclaredLocales;
+  availableLocales: DeclaredLocales[];
+};
+/**
+ * On the server side, hook returning the current locale along with the default
+ * and available ones.
+ *
+ * Reimplemented rather than re-exported from `react-intlayer/server`: that one
+ * takes no locale argument, so there is no way to hand it the ambient locale —
+ * it would read the server context alone and report the default locale on any
+ * render the provider did not reach.
+ */
+declare const useLocale: () => UseLocaleResult;
+//#endregion
+export { UseLocaleResult, useLocale };
+//# sourceMappingURL=useLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/server/useLocale.ts"],"mappings":";;KAIY;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;;;;;;;;;;;cAYP,iBAAgB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-intlayer",
-  "version": "9.3.3",
+  "version": "9.4.0",
   "private": false,
   "description": "Simplify internationalization i18n in Next.js with context providers, hooks, locale detection, and multilingual content integration.",
   "keywords": [
@@ -36,6 +36,11 @@
   "sideEffects": false,
   "exports": {
     ".": {
+      "react-server": {
+        "types": "./dist/types/rsc/index.d.ts",
+        "require": "./dist/cjs/rsc/index.cjs",
+        "import": "./dist/esm/rsc/index.mjs"
+      },
       "types": "./dist/types/index.d.ts",
       "require": "./dist/cjs/index.cjs",
       "import": "./dist/esm/index.mjs"
@@ -133,18 +138,18 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.3.3",
-    "@intlayer/core": "9.3.3",
-    "@intlayer/dictionaries-entry": "9.3.3",
-    "@intlayer/engine": "9.3.2",
-    "@intlayer/types": "9.3.3",
-    "@intlayer/webpack": "9.3.2",
+    "@intlayer/config": "9.4.0",
+    "@intlayer/core": "9.4.0",
+    "@intlayer/dictionaries-entry": "9.4.0",
+    "@intlayer/engine": "9.4.0",
+    "@intlayer/types": "9.4.0",
+    "@intlayer/webpack": "9.4.0",
     "defu": "6.1.7",
     "node-loader": "2.1.0",
-    "react-intlayer": "9.3.3"
+    "react-intlayer": "9.4.0"
   },
   "devDependencies": {
-    "@types/node": "26.2.0",
+    "@types/node": "26.3.0",
     "@types/react": ">=16.0.0",
     "@types/react-dom": ">=16.0.0",
     "@utils/ts-config": "1.0.4",