next-intlayer 9.3.3 → 9.4.0-canary.0

package/README.md

@@ -327,4 +327,4 @@ Contribute on [GitHub](https://github.com/aymericzip/intlayer), [GitLab](https:/
 
 If you like Intlayer, give us a ⭐ on GitHub. It helps others discover the project! [See why GitHub Stars matter](https://github.com/aymericzip/intlayer/blob/main/CONTRIBUTING.md#why-github-stars-matter-).
 
-[![Star History Chart](https://api.star-history.com/svg?repos=aymericzip/intlayer&type=Date)](https://star-history.com/#aymericzip/intlayer&Date)
+[![Star History Chart](https://star-history.dera.page/svg?repos=aymericzip/intlayer&type=Date)](https://star-history.dera.page/#aymericzip/intlayer&Date)

package/dist/cjs/index.cjs

@@ -37,6 +37,12 @@ Object.defineProperty(exports, 'IntlayerClientContext', {
   }
 });
 exports.IntlayerClientProvider = require_client_IntlayerClientProvider.IntlayerClientProvider;
+Object.defineProperty(exports, 'IntlayerProvider', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.IntlayerProvider;
+  }
+});
 exports.MarkdownProvider = MarkdownProvider;
 exports.MarkdownRenderer = MarkdownRenderer;
 exports.generateStaticParams = require_generateStaticParams.generateStaticParams;

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["_MarkdownProvider","_useMarkdownContext","_renderMarkdown","_useMarkdownRenderer","_MarkdownRenderer"],"sources":["../../src/index.ts"],"sourcesContent":["export {\n  getDictionary,\n  getIntlayer,\n  IntlayerClientContext,\n  type IntlayerNode,\n  localeCookie,\n  localeInStorage,\n  setLocaleCookie,\n  setLocaleInStorage,\n  t,\n  useDictionary,\n  useDictionaryAsync,\n  useDictionaryDynamic,\n  useI18n,\n  useIntl,\n  useIntlayer,\n  useLoadDynamic,\n  useLocaleCookie,\n  useLocaleStorage,\n} from 'react-intlayer';\nexport * from './client/index';\nexport { generateStaticParams } from './generateStaticParams';\nexport type {\n  LocalParams,\n  LocalPromiseParams,\n  Next14LayoutIntlayer,\n  Next14PageIntlayer,\n  Next15LayoutIntlayer,\n  Next15PageIntlayer,\n  NextLayoutIntlayer,\n  NextPageIntlayer,\n} from './types/index';\n\nimport type {\n  MarkdownProviderOptions as _MarkdownProviderOptions,\n  MarkdownRendererProps as _MarkdownRendererProps,\n  RenderMarkdownProps as _RenderMarkdownProps,\n} from './markdown';\nimport {\n  MarkdownProvider as _MarkdownProvider,\n  MarkdownRenderer as _MarkdownRenderer,\n  renderMarkdown as _renderMarkdown,\n  useMarkdownContext as _useMarkdownContext,\n  useMarkdownRenderer as _useMarkdownRenderer,\n} from './markdown';\n\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownProvider = _MarkdownProvider;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownContext = _useMarkdownContext;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownProviderOptions = _MarkdownProviderOptions;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const renderMarkdown = _renderMarkdown;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownRenderer = _useMarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownRenderer = _MarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type RenderMarkdownProps = _RenderMarkdownProps;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownRendererProps = _MarkdownRendererProps;\n"],"mappings":";;;;;;;;;;;;;AAiDA,MAAa,2DAAmBA;;;;AAIhC,MAAa,6DAAqBC;;;;AAQlC,MAAa,yDAAiBC;;;;AAI9B,MAAa,8DAAsBC;;;;AAInC,MAAa,2DAAmBC"}
+{"version":3,"file":"index.cjs","names":["_MarkdownProvider","_useMarkdownContext","_renderMarkdown","_useMarkdownRenderer","_MarkdownRenderer"],"sources":["../../src/index.ts"],"sourcesContent":["export {\n  getDictionary,\n  getIntlayer,\n  IntlayerClientContext,\n  type IntlayerNode,\n  IntlayerProvider,\n  type IntlayerProviderProps,\n  localeCookie,\n  localeInStorage,\n  setLocaleCookie,\n  setLocaleInStorage,\n  t,\n  useDictionary,\n  useDictionaryAsync,\n  useDictionaryDynamic,\n  useI18n,\n  useIntl,\n  useIntlayer,\n  useLoadDynamic,\n  useLocaleCookie,\n  useLocaleStorage,\n} from 'react-intlayer';\nexport * from './client/index';\nexport { generateStaticParams } from './generateStaticParams';\nexport type {\n  LocalParams,\n  LocalPromiseParams,\n  Next14LayoutIntlayer,\n  Next14PageIntlayer,\n  Next15LayoutIntlayer,\n  Next15PageIntlayer,\n  NextLayoutIntlayer,\n  NextPageIntlayer,\n} from './types/index';\n\nimport type {\n  MarkdownProviderOptions as _MarkdownProviderOptions,\n  MarkdownRendererProps as _MarkdownRendererProps,\n  RenderMarkdownProps as _RenderMarkdownProps,\n} from './markdown';\nimport {\n  MarkdownProvider as _MarkdownProvider,\n  MarkdownRenderer as _MarkdownRenderer,\n  renderMarkdown as _renderMarkdown,\n  useMarkdownContext as _useMarkdownContext,\n  useMarkdownRenderer as _useMarkdownRenderer,\n} from './markdown';\n\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownProvider = _MarkdownProvider;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownContext = _useMarkdownContext;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownProviderOptions = _MarkdownProviderOptions;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const renderMarkdown = _renderMarkdown;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownRenderer = _useMarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownRenderer = _MarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type RenderMarkdownProps = _RenderMarkdownProps;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownRendererProps = _MarkdownRendererProps;\n"],"mappings":";;;;;;;;;;;;;AAmDA,MAAa,2DAAmBA;;;;AAIhC,MAAa,6DAAqBC;;;;AAQlC,MAAa,yDAAiBC;;;;AAI9B,MAAa,8DAAsBC;;;;AAInC,MAAa,2DAAmBC"}

package/dist/cjs/rsc/index.cjs

@@ -0,0 +1,96 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_client_IntlayerClientProvider = require('../client/IntlayerClientProvider.cjs');
+const require_client_usePathname = require('../client/usePathname.cjs');
+const require_client_useLocalePageRouter = require('../client/useLocalePageRouter.cjs');
+const require_generateStaticParams = require('../generateStaticParams.cjs');
+const require_server_IntlayerProvider = require('../server/IntlayerProvider.cjs');
+const require_server_t = require('../server/t.cjs');
+const require_server_useDictionary = require('../server/useDictionary.cjs');
+const require_server_useDictionaryAsync = require('../server/useDictionaryAsync.cjs');
+const require_server_useDictionaryDynamic = require('../server/useDictionaryDynamic.cjs');
+const require_server_useI18n = require('../server/useI18n.cjs');
+const require_server_useIntl = require('../server/useIntl.cjs');
+const require_server_useIntlayer = require('../server/useIntlayer.cjs');
+const require_server_useLocale = require('../server/useLocale.cjs');
+let react_intlayer = require("react-intlayer");
+let react_intlayer_server = require("react-intlayer/server");
+
+Object.defineProperty(exports, 'IntlayerClientContext', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.IntlayerClientContext;
+  }
+});
+exports.IntlayerClientProvider = require_client_IntlayerClientProvider.IntlayerClientProvider;
+exports.IntlayerProvider = require_server_IntlayerProvider.IntlayerProvider;
+exports.generateStaticParams = require_generateStaticParams.generateStaticParams;
+Object.defineProperty(exports, 'getDictionary', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.getDictionary;
+  }
+});
+Object.defineProperty(exports, 'getIntlayer', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.getIntlayer;
+  }
+});
+Object.defineProperty(exports, 'localeCookie', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.localeCookie;
+  }
+});
+Object.defineProperty(exports, 'localeInStorage', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.localeInStorage;
+  }
+});
+Object.defineProperty(exports, 'setLocaleCookie', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.setLocaleCookie;
+  }
+});
+Object.defineProperty(exports, 'setLocaleInStorage', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.setLocaleInStorage;
+  }
+});
+exports.t = require_server_t.t;
+exports.useDictionary = require_server_useDictionary.useDictionary;
+exports.useDictionaryAsync = require_server_useDictionaryAsync.useDictionaryAsync;
+exports.useDictionaryDynamic = require_server_useDictionaryDynamic.useDictionaryDynamic;
+exports.useI18n = require_server_useI18n.useI18n;
+exports.useIntl = require_server_useIntl.useIntl;
+exports.useIntlayer = require_server_useIntlayer.useIntlayer;
+Object.defineProperty(exports, 'useLoadDynamic', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer_server.useLoadDynamic;
+  }
+});
+exports.useLocale = require_server_useLocale.useLocale;
+Object.defineProperty(exports, 'useLocaleCookie', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.useLocaleCookie;
+  }
+});
+exports.useLocalePageRouter = require_client_useLocalePageRouter.useLocalePageRouter;
+Object.defineProperty(exports, 'useLocaleStorage', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.useLocaleStorage;
+  }
+});
+exports.usePathname = require_client_usePathname.usePathname;
+Object.defineProperty(exports, 'useRewriteURL', {
+  enumerable: true,
+  get: function () {
+    return react_intlayer.useRewriteURL;
+  }
+});

package/dist/cjs/server/IntlayerProvider.cjs

@@ -0,0 +1,54 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_client_IntlayerClientProvider = require('../client/IntlayerClientProvider.cjs');
+let react_jsx_runtime = require("react/jsx-runtime");
+let react_intlayer_server = require("react-intlayer/server");
+
+//#region src/server/IntlayerProvider.tsx
+/**
+* Unified Intlayer provider for the Next.js App Router.
+*
+* Server component that seeds the request-scoped server context (locale and
+* ambient variant) read by the server hooks, and mounts the client provider so
+* client components receive the same values — one provider for both halves.
+*
+* Mount it once, in the locale layout:
+*
+* ```tsx
+* import { IntlayerProvider } from 'next-intlayer/server';
+*
+* const LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {
+*   const { locale } = await params;
+*
+*   return (
+*     <IntlayerProvider locale={locale}>
+*       <html lang={locale}>
+*         <body>{children}</body>
+*       </html>
+*     </IntlayerProvider>
+*   );
+* };
+* ```
+*
+* The server context is request-scoped, not tree-scoped: on client-side
+* navigations that only re-render the page segment, the layout — and with it
+* this provider — does not re-run. The server hooks then fall back to the
+* locale carried by the request (the `x-intlayer-locale` header set by the
+* intlayer proxy, then the locale cookie), so content stays correct without a
+* per-page provider. The ambient `variant` has no request-carried fallback:
+* seed it per request with `setVariant` when server components read it outside
+* a full render of this provider.
+*/
+const IntlayerProvider = ({ children, locale, variant, ...clientProps }) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_intlayer_server.IntlayerServerProvider, {
+	locale,
+	variant,
+	children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_client_IntlayerClientProvider.IntlayerClientProvider, {
+		locale,
+		variant,
+		...clientProps,
+		children
+	})
+});
+
+//#endregion
+exports.IntlayerProvider = IntlayerProvider;
+//# sourceMappingURL=IntlayerProvider.cjs.map

package/dist/cjs/server/IntlayerProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntlayerProvider.cjs","names":["IntlayerServerProvider","IntlayerClientProvider"],"sources":["../../../src/server/IntlayerProvider.tsx"],"sourcesContent":["import type { FC } from 'react';\nimport {\n  IntlayerServerProvider,\n  type IntlayerServerProviderProps,\n} from 'react-intlayer/server';\nimport {\n  IntlayerClientProvider,\n  type IntlayerClientProviderProps,\n} from '../client/IntlayerClientProvider';\n\nexport type IntlayerProviderProps = IntlayerClientProviderProps &\n  IntlayerServerProviderProps;\n\n/**\n * Unified Intlayer provider for the Next.js App Router.\n *\n * Server component that seeds the request-scoped server context (locale and\n * ambient variant) read by the server hooks, and mounts the client provider so\n * client components receive the same values — one provider for both halves.\n *\n * Mount it once, in the locale layout:\n *\n * ```tsx\n * import { IntlayerProvider } from 'next-intlayer/server';\n *\n * const LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {\n *   const { locale } = await params;\n *\n *   return (\n *     <IntlayerProvider locale={locale}>\n *       <html lang={locale}>\n *         <body>{children}</body>\n *       </html>\n *     </IntlayerProvider>\n *   );\n * };\n * ```\n *\n * The server context is request-scoped, not tree-scoped: on client-side\n * navigations that only re-render the page segment, the layout — and with it\n * this provider — does not re-run. The server hooks then fall back to the\n * locale carried by the request (the `x-intlayer-locale` header set by the\n * intlayer proxy, then the locale cookie), so content stays correct without a\n * per-page provider. The ambient `variant` has no request-carried fallback:\n * seed it per request with `setVariant` when server components read it outside\n * a full render of this provider.\n */\nexport const IntlayerProvider: FC<IntlayerProviderProps> = ({\n  children,\n  locale,\n  variant,\n  ...clientProps\n}) => (\n  <IntlayerServerProvider locale={locale} variant={variant}>\n    <IntlayerClientProvider locale={locale} variant={variant} {...clientProps}>\n      {children}\n    </IntlayerClientProvider>\n  </IntlayerServerProvider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,MAAa,oBAA+C,EAC1D,UACA,QACA,SACA,GAAG,kBAEH,2CAACA,8CAAD;CAAgC;CAAiB;WAC/C,2CAACC,8DAAD;EAAgC;EAAiB;EAAS,GAAI;EAC3D;CACqB;AACF"}

package/dist/cjs/server/IntlayerServerProvider.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let react_intlayer_server = require("react-intlayer/server");
+
+//#region src/server/IntlayerServerProvider.ts
+/**
+* @deprecated Mount `IntlayerProvider` from `next-intlayer/server` once in the
+* locale layout instead — it seeds both the server context and the client
+* provider, and the server hooks fall back to the locale carried by the
+* request when the layout is skipped on client-side navigations. For a page
+* that must seed the locale itself (statically rendered routes on
+* Next.js < 16), use the imperative `setLocale` instead of wrapping the tree.
+*/
+const IntlayerServerProvider = react_intlayer_server.IntlayerServerProvider;
+
+//#endregion
+exports.IntlayerServerProvider = IntlayerServerProvider;
+//# sourceMappingURL=IntlayerServerProvider.cjs.map

package/dist/cjs/server/IntlayerServerProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntlayerServerProvider.cjs","names":["IntlayerServerProviderBase"],"sources":["../../../src/server/IntlayerServerProvider.ts"],"sourcesContent":["import { IntlayerServerProvider as IntlayerServerProviderBase } from 'react-intlayer/server';\n\n/**\n * @deprecated Mount `IntlayerProvider` from `next-intlayer/server` once in the\n * locale layout instead — it seeds both the server context and the client\n * provider, and the server hooks fall back to the locale carried by the\n * request when the layout is skipped on client-side navigations. For a page\n * that must seed the locale itself (statically rendered routes on\n * Next.js < 16), use the imperative `setLocale` instead of wrapping the tree.\n */\nexport const IntlayerServerProvider = IntlayerServerProviderBase;\n"],"mappings":";;;;;;;;;;;;AAUA,MAAa,yBAAyBA"}

package/dist/cjs/server/ambientLocale.cjs

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_getLocale = require('./getLocale.cjs');
+const require_server_suspendingReader = require('./suspendingReader.cjs');
+let react_intlayer_server = require("react-intlayer/server");
+
+//#region src/server/ambientLocale.ts
+/**
+* Whether the call site already carries a locale — either a plain locale
+* argument or a selector object with an explicit `locale` field.
+*/
+const hasExplicitLocale = (localeOrSelector) => typeof localeOrSelector === "string" || typeof localeOrSelector === "object" && localeOrSelector !== null && Boolean(localeOrSelector.locale);
+/**
+* Whether the request-derived locale is worth reading at all.
+*
+* The base hooks in `react-intlayer/server` already prefer, in order, the
+* locale passed at the call site and the request-scoped server context seeded
+* by `IntlayerProvider`; they only fall back to the third argument these
+* helpers produce. Reading request storage means calling `headers()` /
+* `cookies()`, which opts the route into dynamic rendering — so it must stay
+* behind both of those, and never run when either already answers.
+*/
+const needsRequestLocale = (localeOrSelector) => !hasExplicitLocale(localeOrSelector) && !(0, react_intlayer_server.getServerContext)(react_intlayer_server.IntlayerServer);
+/**
+* Reads the locale carried by the request: the `x-intlayer-locale` header set
+* by the intlayer proxy, then the locale cookie, then `accept-language`.
+*
+* Errors are not swallowed — during prerendering Next.js relies on the throw
+* from `headers()` to mark the route dynamic.
+*/
+const readStoredLocale = require_server_suspendingReader.createSuspendingReader(require_server_getLocale.getLocale);
+/**
+* Fallback locale for the synchronous server hooks, so a page does not need a
+* provider of its own. Not a React hook despite suspending — it holds no
+* positional state, which is what lets it run conditionally (see
+* {@link createSuspendingReader}): on a client-side navigation that re-renders only the
+* page segment, the layout — and with it `IntlayerProvider` — does not re-run,
+* and the locale carried by the request takes over.
+*
+* Suspends until the request storage resolves. Returns `undefined` when the
+* call site or the server context already carries the locale.
+*/
+const resolveFallbackLocale = (localeOrSelector) => needsRequestLocale(localeOrSelector) ? readStoredLocale() : void 0;
+/**
+* Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are
+* already async and can await the request storage instead of suspending on it.
+*/
+const getFallbackLocale = async (localeOrSelector) => needsRequestLocale(localeOrSelector) ? await require_server_getLocale.getLocale() : void 0;
+/**
+* Full ambient locale for the server APIs that take a plain locale argument
+* (or none at all): call site → server context → locale carried by the
+* request.
+*
+* {@link resolveFallbackLocale} only yields the last rung, because the base hooks
+* in `react-intlayer/server` consult the first two themselves. The APIs
+* reimplemented here have no such fallback slot, so they need the resolved
+* value.
+*/
+const resolveAmbientLocale = (locale) => locale ?? (0, react_intlayer_server.getServerContext)(react_intlayer_server.IntlayerServer) ?? resolveFallbackLocale(locale);
+
+//#endregion
+exports.getFallbackLocale = getFallbackLocale;
+exports.resolveAmbientLocale = resolveAmbientLocale;
+exports.resolveFallbackLocale = resolveFallbackLocale;
+//# sourceMappingURL=ambientLocale.cjs.map

package/dist/cjs/server/ambientLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambientLocale.cjs","names":["getServerContext","IntlayerServer","createSuspendingReader","getLocale"],"sources":["../../../src/server/ambientLocale.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getServerContext, IntlayerServer } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\nimport { createSuspendingReader } from './suspendingReader';\n\n/**\n * Whether the call site already carries a locale — either a plain locale\n * argument or a selector object with an explicit `locale` field.\n */\nconst hasExplicitLocale = (localeOrSelector?: unknown): boolean =>\n  typeof localeOrSelector === 'string' ||\n  (typeof localeOrSelector === 'object' &&\n    localeOrSelector !== null &&\n    Boolean((localeOrSelector as { locale?: unknown }).locale));\n\n/**\n * Whether the request-derived locale is worth reading at all.\n *\n * The base hooks in `react-intlayer/server` already prefer, in order, the\n * locale passed at the call site and the request-scoped server context seeded\n * by `IntlayerProvider`; they only fall back to the third argument these\n * helpers produce. Reading request storage means calling `headers()` /\n * `cookies()`, which opts the route into dynamic rendering — so it must stay\n * behind both of those, and never run when either already answers.\n */\nconst needsRequestLocale = (localeOrSelector?: unknown): boolean =>\n  !hasExplicitLocale(localeOrSelector) && !getServerContext(IntlayerServer);\n\n/**\n * Reads the locale carried by the request: the `x-intlayer-locale` header set\n * by the intlayer proxy, then the locale cookie, then `accept-language`.\n *\n * Errors are not swallowed — during prerendering Next.js relies on the throw\n * from `headers()` to mark the route dynamic.\n */\nconst readStoredLocale = createSuspendingReader<Locale>(getLocale);\n\n/**\n * Fallback locale for the synchronous server hooks, so a page does not need a\n * provider of its own. Not a React hook despite suspending — it holds no\n * positional state, which is what lets it run conditionally (see\n * {@link createSuspendingReader}): on a client-side navigation that re-renders only the\n * page segment, the layout — and with it `IntlayerProvider` — does not re-run,\n * and the locale carried by the request takes over.\n *\n * Suspends until the request storage resolves. Returns `undefined` when the\n * call site or the server context already carries the locale.\n */\nexport const resolveFallbackLocale = (\n  localeOrSelector?: unknown\n): Locale | undefined =>\n  needsRequestLocale(localeOrSelector) ? readStoredLocale() : undefined;\n\n/**\n * Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are\n * already async and can await the request storage instead of suspending on it.\n */\nexport const getFallbackLocale = async (\n  localeOrSelector?: unknown\n): Promise<Locale | undefined> =>\n  needsRequestLocale(localeOrSelector) ? await getLocale() : undefined;\n\n/**\n * Full ambient locale for the server APIs that take a plain locale argument\n * (or none at all): call site → server context → locale carried by the\n * request.\n *\n * {@link resolveFallbackLocale} only yields the last rung, because the base hooks\n * in `react-intlayer/server` consult the first two themselves. The APIs\n * reimplemented here have no such fallback slot, so they need the resolved\n * value.\n */\nexport const resolveAmbientLocale = (\n  locale?: LocalesValues\n): LocalesValues | undefined =>\n  locale ??\n  getServerContext<LocalesValues>(IntlayerServer) ??\n  resolveFallbackLocale(locale);\n"],"mappings":";;;;;;;;;;AAUA,MAAM,qBAAqB,qBACzB,OAAO,qBAAqB,YAC3B,OAAO,qBAAqB,YAC3B,qBAAqB,QACrB,QAAS,iBAA0C,MAAM;;;;;;;;;;;AAY7D,MAAM,sBAAsB,qBAC1B,CAAC,kBAAkB,gBAAgB,KAAK,KAACA,wCAAiBC,oCAAc;;;;;;;;AAS1E,MAAM,mBAAmBC,uDAA+BC,kCAAS;;;;;;;;;;;;AAajE,MAAa,yBACX,qBAEA,mBAAmB,gBAAgB,IAAI,iBAAiB,IAAI;;;;;AAM9D,MAAa,oBAAoB,OAC/B,qBAEA,mBAAmB,gBAAgB,IAAI,MAAMA,mCAAU,IAAI;;;;;;;;;;;AAY7D,MAAa,wBACX,WAEA,cACAH,wCAAgCC,oCAAc,KAC9C,sBAAsB,MAAM"}

package/dist/cjs/server/format/index.cjs

@@ -1,8 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_format_useUnit = require('./useUnit.cjs');
+const require_server_format_useDate = require('./useDate.cjs');
+const require_server_format_useNumber = require('./useNumber.cjs');
+const require_server_format_useRelativeTime = require('./useRelativeTime.cjs');
+const require_server_format_useCompact = require('./useCompact.cjs');
+const require_server_format_useList = require('./useList.cjs');
+const require_server_format_usePercentage = require('./usePercentage.cjs');
+const require_server_format_useCurrency = require('./useCurrency.cjs');
 
-var react_intlayer_server_format = require("react-intlayer/server/format");
-Object.keys(react_intlayer_server_format).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return react_intlayer_server_format[k]; }
-  });
-});
+exports.useCompact = require_server_format_useCompact.useCompact;
+exports.useCurrency = require_server_format_useCurrency.useCurrency;
+exports.useDate = require_server_format_useDate.useDate;
+exports.useList = require_server_format_useList.useList;
+exports.useNumber = require_server_format_useNumber.useNumber;
+exports.usePercentage = require_server_format_usePercentage.usePercentage;
+exports.useRelativeTime = require_server_format_useRelativeTime.useRelativeTime;
+exports.useUnit = require_server_format_useUnit.useUnit;

package/dist/cjs/server/format/useCompact.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_ambientLocale = require('../ambientLocale.cjs');
+let _intlayer_core_formatters = require("@intlayer/core/formatters");
+
+//#region src/server/format/useCompact.ts
+/**
+* On the server side, hook returning a `compact` formatter bound to the ambient
+* locale: the server context, falling back to the locale carried by the
+* request. A per-call `locale` option still wins.
+*
+* Reimplemented rather than re-exported from `react-intlayer/server/format`:
+* 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 format with the default
+* locale on any render the provider did not reach.
+*/
+const useCompact = () => {
+	const locale = require_server_ambientLocale.resolveAmbientLocale();
+	return (...args) => (0, _intlayer_core_formatters.compact)(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+exports.useCompact = useCompact;
+//# sourceMappingURL=useCompact.cjs.map

package/dist/cjs/server/format/useCompact.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCompact.cjs","names":["resolveAmbientLocale","compact"],"sources":["../../../../src/server/format/useCompact.ts"],"sourcesContent":["import { compact } from '@intlayer/core/formatters';\nimport { resolveAmbientLocale } from '../ambientLocale';\n\n/**\n * On the server side, hook returning a `compact` formatter bound to the ambient\n * locale: the server context, falling back to the locale carried by the\n * request. A per-call `locale` option still wins.\n *\n * Reimplemented rather than re-exported from `react-intlayer/server/format`:\n * that one takes no locale argument, so there is no way to hand it the ambient\n * locale — it would read the server context alone and format with the default\n * locale on any render the provider did not reach.\n */\nexport const useCompact = () => {\n  const locale = resolveAmbientLocale();\n\n  return (...args: Parameters<typeof compact>) =>\n    compact(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,mBAAmB;CAC9B,MAAM,SAASA,kDAAqB;CAEpC,QAAQ,GAAG,aACTC,mCAAQ,KAAK,IAAI;EACf,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useCurrency.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_ambientLocale = require('../ambientLocale.cjs');
+let _intlayer_core_formatters = require("@intlayer/core/formatters");
+
+//#region src/server/format/useCurrency.ts
+/**
+* On the server side, hook returning a `currency` formatter bound to the ambient
+* locale: the server context, falling back to the locale carried by the
+* request. A per-call `locale` option still wins.
+*
+* Reimplemented rather than re-exported from `react-intlayer/server/format`:
+* 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 format with the default
+* locale on any render the provider did not reach.
+*/
+const useCurrency = () => {
+	const locale = require_server_ambientLocale.resolveAmbientLocale();
+	return (...args) => (0, _intlayer_core_formatters.currency)(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+exports.useCurrency = useCurrency;
+//# sourceMappingURL=useCurrency.cjs.map

package/dist/cjs/server/format/useCurrency.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrency.cjs","names":["resolveAmbientLocale","currency"],"sources":["../../../../src/server/format/useCurrency.ts"],"sourcesContent":["import { currency } from '@intlayer/core/formatters';\nimport { resolveAmbientLocale } from '../ambientLocale';\n\n/**\n * On the server side, hook returning a `currency` formatter bound to the ambient\n * locale: the server context, falling back to the locale carried by the\n * request. A per-call `locale` option still wins.\n *\n * Reimplemented rather than re-exported from `react-intlayer/server/format`:\n * that one takes no locale argument, so there is no way to hand it the ambient\n * locale — it would read the server context alone and format with the default\n * locale on any render the provider did not reach.\n */\nexport const useCurrency = () => {\n  const locale = resolveAmbientLocale();\n\n  return (...args: Parameters<typeof currency>) =>\n    currency(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,oBAAoB;CAC/B,MAAM,SAASA,kDAAqB;CAEpC,QAAQ,GAAG,aACTC,oCAAS,KAAK,IAAI;EAChB,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useDate.cjs

@@ -0,0 +1,33 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_ambientLocale = require('../ambientLocale.cjs');
+let _intlayer_core_formatters = require("@intlayer/core/formatters");
+
+//#region src/server/format/useDate.ts
+/**
+* On the server side, hook returning a `date` formatter bound to the ambient
+* locale: the server context, falling back to the locale carried by the
+* request. A per-call `locale` option still wins.
+*
+* Reimplemented rather than re-exported from `react-intlayer/server/format`:
+* 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 format with the default
+* locale on any render the provider did not reach.
+*
+* The options argument is either a preset name or an options object, so the
+* preset is resolved before the locale is merged in — spreading the string
+* itself would scatter its characters and drop the preset.
+*/
+const useDate = () => {
+	const locale = require_server_ambientLocale.resolveAmbientLocale();
+	return (...args) => (0, _intlayer_core_formatters.date)(args[0], typeof args[1] === "string" ? {
+		..._intlayer_core_formatters.presets[args[1]],
+		locale
+	} : {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+exports.useDate = useDate;
+//# sourceMappingURL=useDate.cjs.map

package/dist/cjs/server/format/useDate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDate.cjs","names":["resolveAmbientLocale","date","presets"],"sources":["../../../../src/server/format/useDate.ts"],"sourcesContent":["import { date, presets } from '@intlayer/core/formatters';\nimport { resolveAmbientLocale } from '../ambientLocale';\n\n/**\n * On the server side, hook returning a `date` formatter bound to the ambient\n * locale: the server context, falling back to the locale carried by the\n * request. A per-call `locale` option still wins.\n *\n * Reimplemented rather than re-exported from `react-intlayer/server/format`:\n * that one takes no locale argument, so there is no way to hand it the ambient\n * locale — it would read the server context alone and format with the default\n * locale on any render the provider did not reach.\n *\n * The options argument is either a preset name or an options object, so the\n * preset is resolved before the locale is merged in — spreading the string\n * itself would scatter its characters and drop the preset.\n */\nexport const useDate = () => {\n  const locale = resolveAmbientLocale();\n\n  return (...args: Parameters<typeof date>) =>\n    date(\n      args[0],\n      typeof args[1] === 'string'\n        ? { ...presets[args[1]], locale }\n        : { ...args[1], locale: args[1]?.locale ?? locale }\n    );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiBA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,kDAAqB;CAEpC,QAAQ,GAAG,aACTC,gCACE,KAAK,IACL,OAAO,KAAK,OAAO,WACf;EAAE,GAAGC,kCAAQ,KAAK;EAAK;CAAO,IAC9B;EAAE,GAAG,KAAK;EAAI,QAAQ,KAAK,EAAE,EAAE,UAAU;CAAO,CACtD;AACJ"}

package/dist/cjs/server/format/useList.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_ambientLocale = require('../ambientLocale.cjs');
+let _intlayer_core_formatters = require("@intlayer/core/formatters");
+
+//#region src/server/format/useList.ts
+/**
+* On the server side, hook returning a `list` formatter bound to the ambient
+* locale: the server context, falling back to the locale carried by the
+* request. A per-call `locale` option still wins.
+*
+* Reimplemented rather than re-exported from `react-intlayer/server/format`:
+* 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 format with the default
+* locale on any render the provider did not reach.
+*/
+const useList = () => {
+	const locale = require_server_ambientLocale.resolveAmbientLocale();
+	return (...args) => (0, _intlayer_core_formatters.list)(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+exports.useList = useList;
+//# sourceMappingURL=useList.cjs.map

package/dist/cjs/server/format/useList.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useList.cjs","names":["resolveAmbientLocale","list"],"sources":["../../../../src/server/format/useList.ts"],"sourcesContent":["import { list } from '@intlayer/core/formatters';\nimport { resolveAmbientLocale } from '../ambientLocale';\n\n/**\n * On the server side, hook returning a `list` formatter bound to the ambient\n * locale: the server context, falling back to the locale carried by the\n * request. A per-call `locale` option still wins.\n *\n * Reimplemented rather than re-exported from `react-intlayer/server/format`:\n * that one takes no locale argument, so there is no way to hand it the ambient\n * locale — it would read the server context alone and format with the default\n * locale on any render the provider did not reach.\n */\nexport const useList = () => {\n  const locale = resolveAmbientLocale();\n\n  return (...args: Parameters<typeof list>) =>\n    list(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,kDAAqB;CAEpC,QAAQ,GAAG,aACTC,gCAAK,KAAK,IAAI;EACZ,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useNumber.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_ambientLocale = require('../ambientLocale.cjs');
+let _intlayer_core_formatters = require("@intlayer/core/formatters");
+
+//#region src/server/format/useNumber.ts
+/**
+* On the server side, hook returning a `number` formatter bound to the ambient
+* locale: the server context, falling back to the locale carried by the
+* request. A per-call `locale` option still wins.
+*
+* Reimplemented rather than re-exported from `react-intlayer/server/format`:
+* 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 format with the default
+* locale on any render the provider did not reach.
+*/
+const useNumber = () => {
+	const locale = require_server_ambientLocale.resolveAmbientLocale();
+	return (...args) => (0, _intlayer_core_formatters.number)(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+exports.useNumber = useNumber;
+//# sourceMappingURL=useNumber.cjs.map

package/dist/cjs/server/format/useNumber.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNumber.cjs","names":["resolveAmbientLocale","number"],"sources":["../../../../src/server/format/useNumber.ts"],"sourcesContent":["import { number } from '@intlayer/core/formatters';\nimport { resolveAmbientLocale } from '../ambientLocale';\n\n/**\n * On the server side, hook returning a `number` formatter bound to the ambient\n * locale: the server context, falling back to the locale carried by the\n * request. A per-call `locale` option still wins.\n *\n * Reimplemented rather than re-exported from `react-intlayer/server/format`:\n * that one takes no locale argument, so there is no way to hand it the ambient\n * locale — it would read the server context alone and format with the default\n * locale on any render the provider did not reach.\n */\nexport const useNumber = () => {\n  const locale = resolveAmbientLocale();\n\n  return (...args: Parameters<typeof number>) =>\n    number(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,kBAAkB;CAC7B,MAAM,SAASA,kDAAqB;CAEpC,QAAQ,GAAG,aACTC,kCAAO,KAAK,IAAI;EACd,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/usePercentage.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_ambientLocale = require('../ambientLocale.cjs');
+let _intlayer_core_formatters = require("@intlayer/core/formatters");
+
+//#region src/server/format/usePercentage.ts
+/**
+* On the server side, hook returning a `percentage` formatter bound to the ambient
+* locale: the server context, falling back to the locale carried by the
+* request. A per-call `locale` option still wins.
+*
+* Reimplemented rather than re-exported from `react-intlayer/server/format`:
+* 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 format with the default
+* locale on any render the provider did not reach.
+*/
+const usePercentage = () => {
+	const locale = require_server_ambientLocale.resolveAmbientLocale();
+	return (...args) => (0, _intlayer_core_formatters.percentage)(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+exports.usePercentage = usePercentage;
+//# sourceMappingURL=usePercentage.cjs.map

package/dist/cjs/server/format/usePercentage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePercentage.cjs","names":["resolveAmbientLocale","percentage"],"sources":["../../../../src/server/format/usePercentage.ts"],"sourcesContent":["import { percentage } from '@intlayer/core/formatters';\nimport { resolveAmbientLocale } from '../ambientLocale';\n\n/**\n * On the server side, hook returning a `percentage` formatter bound to the ambient\n * locale: the server context, falling back to the locale carried by the\n * request. A per-call `locale` option still wins.\n *\n * Reimplemented rather than re-exported from `react-intlayer/server/format`:\n * that one takes no locale argument, so there is no way to hand it the ambient\n * locale — it would read the server context alone and format with the default\n * locale on any render the provider did not reach.\n */\nexport const usePercentage = () => {\n  const locale = resolveAmbientLocale();\n\n  return (...args: Parameters<typeof percentage>) =>\n    percentage(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,sBAAsB;CACjC,MAAM,SAASA,kDAAqB;CAEpC,QAAQ,GAAG,aACTC,sCAAW,KAAK,IAAI;EAClB,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useRelativeTime.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_ambientLocale = require('../ambientLocale.cjs');
+let _intlayer_core_formatters = require("@intlayer/core/formatters");
+
+//#region src/server/format/useRelativeTime.ts
+/**
+* On the server side, hook returning a `relativeTime` formatter bound to the ambient
+* locale: the server context, falling back to the locale carried by the
+* request. A per-call `locale` option still wins.
+*
+* Reimplemented rather than re-exported from `react-intlayer/server/format`:
+* 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 format with the default
+* locale on any render the provider did not reach.
+*/
+const useRelativeTime = () => {
+	const locale = require_server_ambientLocale.resolveAmbientLocale();
+	return (...args) => (0, _intlayer_core_formatters.relativeTime)(args[0], args[1] ?? /* @__PURE__ */ new Date(), {
+		...args[2],
+		locale: args[2]?.locale ?? locale
+	});
+};
+
+//#endregion
+exports.useRelativeTime = useRelativeTime;
+//# sourceMappingURL=useRelativeTime.cjs.map

package/dist/cjs/server/format/useRelativeTime.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRelativeTime.cjs","names":["resolveAmbientLocale","relativeTime"],"sources":["../../../../src/server/format/useRelativeTime.ts"],"sourcesContent":["import { relativeTime } from '@intlayer/core/formatters';\nimport { resolveAmbientLocale } from '../ambientLocale';\n\n/**\n * On the server side, hook returning a `relativeTime` formatter bound to the ambient\n * locale: the server context, falling back to the locale carried by the\n * request. A per-call `locale` option still wins.\n *\n * Reimplemented rather than re-exported from `react-intlayer/server/format`:\n * that one takes no locale argument, so there is no way to hand it the ambient\n * locale — it would read the server context alone and format with the default\n * locale on any render the provider did not reach.\n */\nexport const useRelativeTime = () => {\n  const locale = resolveAmbientLocale();\n\n  return (...args: Parameters<typeof relativeTime>) =>\n    relativeTime(args[0], args[1] ?? new Date(), {\n      ...args[2],\n      locale: args[2]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,wBAAwB;CACnC,MAAM,SAASA,kDAAqB;CAEpC,QAAQ,GAAG,aACTC,wCAAa,KAAK,IAAI,KAAK,sBAAM,IAAI,KAAK,GAAG;EAC3C,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}

package/dist/cjs/server/format/useUnit.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_ambientLocale = require('../ambientLocale.cjs');
+let _intlayer_core_formatters = require("@intlayer/core/formatters");
+
+//#region src/server/format/useUnit.ts
+/**
+* On the server side, hook returning a `units` formatter bound to the ambient
+* locale: the server context, falling back to the locale carried by the
+* request. A per-call `locale` option still wins.
+*
+* Reimplemented rather than re-exported from `react-intlayer/server/format`:
+* 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 format with the default
+* locale on any render the provider did not reach.
+*/
+const useUnit = () => {
+	const locale = require_server_ambientLocale.resolveAmbientLocale();
+	return (...args) => (0, _intlayer_core_formatters.units)(args[0], {
+		...args[1],
+		locale: args[1]?.locale ?? locale
+	});
+};
+
+//#endregion
+exports.useUnit = useUnit;
+//# sourceMappingURL=useUnit.cjs.map

package/dist/cjs/server/format/useUnit.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUnit.cjs","names":["resolveAmbientLocale","units"],"sources":["../../../../src/server/format/useUnit.ts"],"sourcesContent":["import { units } from '@intlayer/core/formatters';\nimport { resolveAmbientLocale } from '../ambientLocale';\n\n/**\n * On the server side, hook returning a `units` formatter bound to the ambient\n * locale: the server context, falling back to the locale carried by the\n * request. A per-call `locale` option still wins.\n *\n * Reimplemented rather than re-exported from `react-intlayer/server/format`:\n * that one takes no locale argument, so there is no way to hand it the ambient\n * locale — it would read the server context alone and format with the default\n * locale on any render the provider did not reach.\n */\nexport const useUnit = () => {\n  const locale = resolveAmbientLocale();\n\n  return (...args: Parameters<typeof units>) =>\n    units(args[0], {\n      ...args[1],\n      locale: args[1]?.locale ?? locale,\n    });\n};\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,gBAAgB;CAC3B,MAAM,SAASA,kDAAqB;CAEpC,QAAQ,GAAG,aACTC,iCAAM,KAAK,IAAI;EACb,GAAG,KAAK;EACR,QAAQ,KAAK,EAAE,EAAE,UAAU;CAC7B,CAAC;AACL"}