astro-intlayer 9.5.4 → 9.5.6

package/dist/esm/middleware.mjs

@@ -0,0 +1,100 @@
+import { requestStorage } from "./requestStorage.mjs";
+import { getLocaleFromRequest, resolveProxyMode } from "@intlayer/core/localization";
+import * as builtConfiguration from "@intlayer/config/built";
+import { createIntlayerWebProxyHandler } from "vite-intlayer/web-proxy-handler";
+
+//#region src/middleware.ts
+/**
+* Whether `astro dev` is serving the app. Vite inlines `import.meta.env.DEV`
+* into the server bundle; the optional chain keeps the module loadable where
+* no bundler defines it (`process.env.NODE_ENV` cannot be used instead: the
+* package build inlines it).
+*/
+const isDevServer = import.meta.env?.DEV === true;
+const configuration = builtConfiguration;
+const { internationalization: internationalization$1, routing: routing$1 } = configuration;
+/**
+* Locale-routing proxy shared with the Vite dev server and the Nitro handler.
+*
+* `undefined` when `routing.enableProxy` is `false`. In auto mode (option
+* unset) `astro dev` keeps routing URL-driven: the stored locale is not a
+* redirect source, exactly like the Vite proxy mounted on the same dev server,
+* so the two never disagree.
+*/
+const proxy = resolveProxyMode(routing$1.enableProxy) === "disabled" ? void 0 : createIntlayerWebProxyHandler({
+	configuration,
+	isDevServer
+});
+/**
+* Appends the headers the proxy produced (the persisted locale cookie) to the
+* rendered response. Some responses ship immutable headers, in which case the
+* body is re-wrapped in a fresh `Response`.
+*/
+const withProxyHeaders = (response, headers) => {
+	const entries = [...headers];
+	if (entries.length === 0) return response;
+	const applyHeaders = (target) => {
+		for (const [name, value] of entries) target.headers.append(name, value);
+		return target;
+	};
+	try {
+		return applyHeaders(response);
+	} catch {
+		return applyHeaders(new Response(response.body, response));
+	}
+};
+/**
+* Astro middleware resolving the request locale into `Astro.locals.intlayer`.
+*
+* Priority: the URL (path prefix or `?locale=` search param, in every routing
+* mode but `no-prefix`), then the locale persisted by the client (cookie or
+* custom header), then `Accept-Language` negotiation.
+*
+* On server-rendered requests it also runs the Intlayer locale-routing proxy,
+* so a visitor whose stored locale is `fr` is redirected from `/` to `/fr`
+* (per `routing.mode`) and the resolved locale is persisted on the response.
+* Only redirects are honoured: the proxy's internal rewrites target
+* prefix-based routers, while Astro pages already resolve the locale from the
+* URL they are rendered for. Prerendered pages are served as static files, so
+* nothing can redirect them at request time and the proxy is skipped.
+*
+* The `intlayer()` integration registers it automatically, before the user
+* middleware, so `Astro.locals.intlayer` is available in every page, endpoint
+* and middleware. The rest of the request renders inside an
+* `AsyncLocalStorage` scope bound to those locals, which is how the hooks of
+* `astro-intlayer/server` read the locale with no argument.
+*
+* @example
+* ```ts
+* // src/middleware.ts — only needed when composing it by hand
+* import { onRequest as intlayer } from 'astro-intlayer/middleware';
+* import { sequence } from 'astro:middleware';
+*
+* export const onRequest = sequence(intlayer, myMiddleware);
+* ```
+*/
+const onRequest = async (context, next) => {
+	let proxyOutcome;
+	if (proxy && !context.isPrerendered) {
+		const outcome = proxy({
+			url: context.url,
+			headers: context.request.headers
+		});
+		if (outcome.kind === "response") return outcome.response;
+		proxyOutcome = outcome;
+	}
+	context.locals.intlayer = {
+		locale: await getLocaleFromRequest({
+			url: context.url,
+			headers: context.isPrerendered ? new Headers() : context.request.headers
+		}),
+		defaultLocale: internationalization$1.defaultLocale,
+		availableLocales: internationalization$1.locales
+	};
+	const response = await requestStorage.run(context.locals, next);
+	return proxyOutcome ? withProxyHeaders(response, proxyOutcome.headers) : response;
+};
+
+//#endregion
+export { onRequest };
+//# sourceMappingURL=middleware.mjs.map

package/dist/esm/middleware.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.mjs","names":["routing","internationalization"],"sources":["../../src/middleware.ts"],"sourcesContent":["import * as builtConfiguration from '@intlayer/config/built';\nimport {\n  getLocaleFromRequest,\n  resolveProxyMode,\n} from '@intlayer/core/localization';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { MiddlewareHandler } from 'astro';\nimport {\n  createIntlayerWebProxyHandler,\n  type WebProxyOutcome,\n} from 'vite-intlayer/web-proxy-handler';\nimport { requestStorage } from './requestStorage';\n\n/** Proxy outcome letting the request continue to the page. */\ntype WebProxyNextOutcome = Extract<WebProxyOutcome, { kind: 'next' }>;\n\n/**\n * Whether `astro dev` is serving the app. Vite inlines `import.meta.env.DEV`\n * into the server bundle; the optional chain keeps the module loadable where\n * no bundler defines it (`process.env.NODE_ENV` cannot be used instead: the\n * package build inlines it).\n */\nconst isDevServer =\n  (import.meta as { env?: { DEV?: boolean } }).env?.DEV === true;\n\nconst configuration = builtConfiguration as unknown as IntlayerConfig;\nconst { internationalization, routing } = configuration;\n\n/**\n * Locale-routing proxy shared with the Vite dev server and the Nitro handler.\n *\n * `undefined` when `routing.enableProxy` is `false`. In auto mode (option\n * unset) `astro dev` keeps routing URL-driven: the stored locale is not a\n * redirect source, exactly like the Vite proxy mounted on the same dev server,\n * so the two never disagree.\n */\nconst proxy =\n  resolveProxyMode(routing.enableProxy) === 'disabled'\n    ? undefined\n    : createIntlayerWebProxyHandler({\n        configuration,\n        isDevServer,\n      });\n\n/**\n * Appends the headers the proxy produced (the persisted locale cookie) to the\n * rendered response. Some responses ship immutable headers, in which case the\n * body is re-wrapped in a fresh `Response`.\n */\nconst withProxyHeaders = (response: Response, headers: Headers): Response => {\n  const entries = [...headers];\n  if (entries.length === 0) return response;\n\n  const applyHeaders = (target: Response) => {\n    for (const [name, value] of entries) {\n      target.headers.append(name, value);\n    }\n    return target;\n  };\n\n  try {\n    return applyHeaders(response);\n  } catch {\n    return applyHeaders(new Response(response.body, response));\n  }\n};\n\n/**\n * Intlayer state stored in `Astro.locals.intlayer` by the {@link onRequest} middleware.\n */\nexport type IntlayerLocals = {\n  /** Locale resolved for the current request. */\n  locale: DeclaredLocales;\n  /** Locale configured as fallback in `intlayer.config.ts`. */\n  defaultLocale: DeclaredLocales;\n  /** Every locale declared in `intlayer.config.ts`. */\n  availableLocales: DeclaredLocales[];\n};\n\ndeclare global {\n  namespace App {\n    interface Locals {\n      intlayer: IntlayerLocals;\n    }\n  }\n}\n\n/**\n * Astro middleware resolving the request locale into `Astro.locals.intlayer`.\n *\n * Priority: the URL (path prefix or `?locale=` search param, in every routing\n * mode but `no-prefix`), then the locale persisted by the client (cookie or\n * custom header), then `Accept-Language` negotiation.\n *\n * On server-rendered requests it also runs the Intlayer locale-routing proxy,\n * so a visitor whose stored locale is `fr` is redirected from `/` to `/fr`\n * (per `routing.mode`) and the resolved locale is persisted on the response.\n * Only redirects are honoured: the proxy's internal rewrites target\n * prefix-based routers, while Astro pages already resolve the locale from the\n * URL they are rendered for. Prerendered pages are served as static files, so\n * nothing can redirect them at request time and the proxy is skipped.\n *\n * The `intlayer()` integration registers it automatically, before the user\n * middleware, so `Astro.locals.intlayer` is available in every page, endpoint\n * and middleware. The rest of the request renders inside an\n * `AsyncLocalStorage` scope bound to those locals, which is how the hooks of\n * `astro-intlayer/server` read the locale with no argument.\n *\n * @example\n * ```ts\n * // src/middleware.ts — only needed when composing it by hand\n * import { onRequest as intlayer } from 'astro-intlayer/middleware';\n * import { sequence } from 'astro:middleware';\n *\n * export const onRequest = sequence(intlayer, myMiddleware);\n * ```\n */\nexport const onRequest: MiddlewareHandler = async (context, next) => {\n  let proxyOutcome: WebProxyNextOutcome | undefined;\n\n  if (proxy && !context.isPrerendered) {\n    const outcome = proxy({\n      url: context.url,\n      headers: context.request.headers,\n    });\n\n    if (outcome.kind === 'response') return outcome.response;\n    proxyOutcome = outcome;\n  }\n\n  context.locals.intlayer = {\n    locale: await getLocaleFromRequest({\n      url: context.url,\n      // A prerendered page is rendered once and served to every visitor, so\n      // its locale can only come from the URL. Reading the request headers\n      // there would also make Astro warn on every page of the build.\n      headers: context.isPrerendered ? new Headers() : context.request.headers,\n    }),\n    defaultLocale: internationalization.defaultLocale as DeclaredLocales,\n    availableLocales: internationalization.locales as DeclaredLocales[],\n  };\n\n  const response = await requestStorage.run(context.locals, next);\n\n  return proxyOutcome\n    ? withProxyHeaders(response, proxyOutcome.headers)\n    : response;\n};\n"],"mappings":";;;;;;;;;;;;AAuBA,MAAM,cACH,YAA4C,KAAK,QAAQ;AAE5D,MAAM,gBAAgB;AACtB,MAAM,EAAE,8CAAsB,uBAAY;;;;;;;;;AAU1C,MAAM,QACJ,iBAAiBA,UAAQ,WAAW,MAAM,aACtC,SACA,8BAA8B;CAC5B;CACA;AACF,CAAC;;;;;;AAOP,MAAM,oBAAoB,UAAoB,YAA+B;CAC3E,MAAM,UAAU,CAAC,GAAG,OAAO;CAC3B,IAAI,QAAQ,WAAW,GAAG,OAAO;CAEjC,MAAM,gBAAgB,WAAqB;EACzC,KAAK,MAAM,CAAC,MAAM,UAAU,SAC1B,OAAO,QAAQ,OAAO,MAAM,KAAK;EAEnC,OAAO;CACT;CAEA,IAAI;EACF,OAAO,aAAa,QAAQ;CAC9B,QAAQ;EACN,OAAO,aAAa,IAAI,SAAS,SAAS,MAAM,QAAQ,CAAC;CAC3D;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAa,YAA+B,OAAO,SAAS,SAAS;CACnE,IAAI;CAEJ,IAAI,SAAS,CAAC,QAAQ,eAAe;EACnC,MAAM,UAAU,MAAM;GACpB,KAAK,QAAQ;GACb,SAAS,QAAQ,QAAQ;EAC3B,CAAC;EAED,IAAI,QAAQ,SAAS,YAAY,OAAO,QAAQ;EAChD,eAAe;CACjB;CAEA,QAAQ,OAAO,WAAW;EACxB,QAAQ,MAAM,qBAAqB;GACjC,KAAK,QAAQ;GAIb,SAAS,QAAQ,gBAAgB,IAAI,QAAQ,IAAI,QAAQ,QAAQ;EACnE,CAAC;EACD,eAAeC,uBAAqB;EACpC,kBAAkBA,uBAAqB;CACzC;CAEA,MAAM,WAAW,MAAM,eAAe,IAAI,QAAQ,QAAQ,IAAI;CAE9D,OAAO,eACH,iBAAiB,UAAU,aAAa,OAAO,IAC/C;AACN"}

package/dist/esm/requestStorage.mjs

@@ -0,0 +1,21 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/requestStorage.ts
+/**
+* `Astro.locals` of the request being rendered, made available to every
+* function running inside the middleware scope — page and component
+* frontmatter, endpoints, nested middleware — without passing `Astro` around.
+*/
+const requestStorage = new AsyncLocalStorage();
+/**
+* Returns the Intlayer locals of the request being rendered, if any.
+*/
+const getIntlayerLocals = () => requestStorage.getStore()?.intlayer;
+/**
+* Returns the locale of the request being rendered, if any.
+*/
+const getRequestLocale = () => getIntlayerLocals()?.locale;
+
+//#endregion
+export { getIntlayerLocals, getRequestLocale, requestStorage };
+//# sourceMappingURL=requestStorage.mjs.map

package/dist/esm/requestStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestStorage.mjs","names":[],"sources":["../../src/requestStorage.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { IntlayerLocals } from './middleware';\n\n/**\n * `Astro.locals` of the request being rendered, made available to every\n * function running inside the middleware scope — page and component\n * frontmatter, endpoints, nested middleware — without passing `Astro` around.\n */\nexport const requestStorage = new AsyncLocalStorage<{\n  intlayer?: IntlayerLocals;\n}>();\n\n/**\n * Returns the Intlayer locals of the request being rendered, if any.\n */\nexport const getIntlayerLocals = (): IntlayerLocals | undefined =>\n  requestStorage.getStore()?.intlayer;\n\n/**\n * Returns the locale of the request being rendered, if any.\n */\nexport const getRequestLocale = (): DeclaredLocales | undefined =>\n  getIntlayerLocals()?.locale;\n"],"mappings":";;;;;;;;AASA,MAAa,iBAAiB,IAAI,kBAE/B;;;;AAKH,MAAa,0BACX,eAAe,SAAS,CAAC,EAAE;;;;AAK7B,MAAa,yBACX,kBAAkB,CAAC,EAAE"}

package/dist/esm/useDictionary.mjs

@@ -0,0 +1,37 @@
+import { getRequestLocale } from "./requestStorage.mjs";
+import { withInertOnChange } from "./withInertOnChange.mjs";
+import { resolveDictionaryArgument } from "@intlayer/core/dictionaryManipulator";
+import { getDictionary } from "vanilla-intlayer";
+
+//#region src/useDictionary.ts
+/**
+* Transforms an imported dictionary (or qualified dictionary group) and returns
+* its content for the locale of the request being rendered, read from
+* `Astro.locals.intlayer`.
+*
+* The second argument is either a locale or a selector object
+* (`{ item }`, `{ variant }`, optionally with `locale`); it takes precedence
+* over the request locale.
+*
+* Same signature and content shape as the client-side hook this entry resolves
+* to in the browser (`vanilla-intlayer`).
+*
+* @example
+* ```astro
+* ---
+* import { useDictionary } from 'astro-intlayer';
+* import homeContent from '../content/home.content';
+*
+* const { title } = useDictionary(homeContent);
+* ---
+* ```
+*/
+const useDictionary = (dictionary, localeOrSelector) => withInertOnChange(getDictionary(dictionary, resolveDictionaryArgument({
+	localeOrSelector,
+	contextLocale: getRequestLocale(),
+	dictionaryKey: dictionary.key
+})));
+
+//#endregion
+export { useDictionary };
+//# sourceMappingURL=useDictionary.mjs.map

package/dist/esm/useDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../src/useDictionary.ts"],"sourcesContent":["import { resolveDictionaryArgument } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  Dictionary,\n  DictionarySelectorForGroup,\n  QualifiedDictionaryGroup,\n  ResolveQualifiedDictionaryContent,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  type DeepTransformContent,\n  getDictionary,\n  type WithOnChange,\n} from 'vanilla-intlayer';\nimport { getRequestLocale } from './requestStorage';\nimport { withInertOnChange } from './withInertOnChange';\n\n/**\n * Transforms an imported dictionary (or qualified dictionary group) and returns\n * its content for the locale of the request being rendered, read from\n * `Astro.locals.intlayer`.\n *\n * The second argument is either a locale or a selector object\n * (`{ item }`, `{ variant }`, optionally with `locale`); it takes precedence\n * over the request locale.\n *\n * Same signature and content shape as the client-side hook this entry resolves\n * to in the browser (`vanilla-intlayer`).\n *\n * @example\n * ```astro\n * ---\n * import { useDictionary } from 'astro-intlayer';\n * import homeContent from '../content/home.content';\n *\n * const { title } = useDictionary(homeContent);\n * ---\n * ```\n */\nexport const useDictionary = <\n  const T extends Dictionary | QualifiedDictionaryGroup,\n  const A extends\n    | LocalesValues\n    | DictionarySelectorForGroup<T> = DeclaredLocales,\n>(\n  dictionary: T,\n  localeOrSelector?: A\n): WithOnChange<\n  DeepTransformContent<\n    ResolveQualifiedDictionaryContent<T, A>,\n    ExtractSelectorLocale<A>\n  >\n> =>\n  withInertOnChange(\n    getDictionary<T, A>(\n      dictionary,\n      resolveDictionaryArgument({\n        localeOrSelector,\n        contextLocale: getRequestLocale(),\n        dictionaryKey: dictionary.key,\n      }) as A\n    )\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,MAAa,iBAMX,YACA,qBAOA,kBACE,cACE,YACA,0BAA0B;CACxB;CACA,eAAe,iBAAiB;CAChC,eAAe,WAAW;AAC5B,CAAC,CACH,CACF"}

package/dist/esm/useIntlayer.mjs

@@ -0,0 +1,37 @@
+import { getRequestLocale } from "./requestStorage.mjs";
+import { withInertOnChange } from "./withInertOnChange.mjs";
+import { resolveDictionaryArgument } from "@intlayer/core/dictionaryManipulator";
+import { getIntlayer } from "vanilla-intlayer";
+
+//#region src/useIntlayer.ts
+/**
+* Picks one dictionary by its key and returns its content for the locale of
+* the request being rendered, read from `Astro.locals.intlayer`.
+*
+* The second argument is either a locale or a selector object
+* (`{ item }`, `{ variant }`, optionally with `locale`); it takes precedence
+* over the request locale.
+*
+* Same signature and content shape as the client-side hook this entry resolves
+* to in the browser (`vanilla-intlayer`), so a call moves between the
+* frontmatter and a `<script>` unchanged.
+*
+* @example
+* ```astro
+* ---
+* import { useIntlayer } from 'astro-intlayer';
+*
+* const { title, description } = useIntlayer('home');
+* ---
+* <h1>{title}</h1>
+* ```
+*/
+const useIntlayer = (key, localeOrSelector) => withInertOnChange(getIntlayer(key, resolveDictionaryArgument({
+	localeOrSelector,
+	contextLocale: getRequestLocale(),
+	dictionaryKey: key
+})));
+
+//#endregion
+export { useIntlayer };
+//# sourceMappingURL=useIntlayer.mjs.map

package/dist/esm/useIntlayer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.mjs","names":[],"sources":["../../src/useIntlayer.ts"],"sourcesContent":["import { resolveDictionaryArgument } from '@intlayer/core/dictionaryManipulator';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  DictionarySelectorForKey,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  type DeepTransformContent,\n  getIntlayer,\n  type WithOnChange,\n} from 'vanilla-intlayer';\nimport { getRequestLocale } from './requestStorage';\nimport { withInertOnChange } from './withInertOnChange';\n\n/**\n * Picks one dictionary by its key and returns its content for the locale of\n * the request being rendered, read from `Astro.locals.intlayer`.\n *\n * The second argument is either a locale or a selector object\n * (`{ item }`, `{ variant }`, optionally with `locale`); it takes precedence\n * over the request locale.\n *\n * Same signature and content shape as the client-side hook this entry resolves\n * to in the browser (`vanilla-intlayer`), so a call moves between the\n * frontmatter and a `<script>` unchanged.\n *\n * @example\n * ```astro\n * ---\n * import { useIntlayer } from 'astro-intlayer';\n *\n * const { title, description } = useIntlayer('home');\n * ---\n * <h1>{title}</h1>\n * ```\n */\nexport const useIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A\n): WithOnChange<\n  DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>\n> =>\n  withInertOnChange(\n    getIntlayer<T, A>(\n      key,\n      resolveDictionaryArgument({\n        localeOrSelector,\n        contextLocale: getRequestLocale(),\n        dictionaryKey: key as string,\n      }) as A\n    )\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,eAIX,KACA,qBAIA,kBACE,YACE,KACA,0BAA0B;CACxB;CACA,eAAe,iBAAiB;CAChC,eAAe;AACjB,CAAC,CACH,CACF"}

package/dist/esm/useLocale.mjs

@@ -0,0 +1,40 @@
+import { getRequestLocale } from "./requestStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+
+//#region src/useLocale.ts
+const { defaultLocale, locales: availableLocales } = internationalization;
+/**
+* Returns the locale of the request being rendered, read from
+* `Astro.locals.intlayer`, with the configured default and available locales.
+*
+* Falls back to the default locale outside of a request, i.e. when the
+* `astro-intlayer/middleware` did not run.
+*
+* Same shape as the client-side hook this entry resolves to in the browser
+* (`vanilla-intlayer`). A request has no locale to switch, so `setLocale` and
+* `subscribe` are inert here: switch the locale from a `<script>`, where the
+* same import gives the client implementation.
+*
+* @example
+* ```astro
+* ---
+* import { useLocale } from 'astro-intlayer';
+*
+* const { locale, availableLocales } = useLocale();
+* ---
+* <html lang={locale}>
+* ```
+*/
+const useLocale = (_props = {}) => ({
+	locale: getRequestLocale() ?? defaultLocale,
+	defaultLocale,
+	availableLocales,
+	setLocale: () => {
+		console.warn("[astro-intlayer] setLocale() has no effect during a server render. Call it from a client <script> instead.");
+	},
+	subscribe: () => () => {}
+});
+
+//#endregion
+export { useLocale };
+//# sourceMappingURL=useLocale.mjs.map

package/dist/esm/useLocale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.mjs","names":[],"sources":["../../src/useLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type {\n  UseLocaleProps,\n  UseLocaleResult as VanillaUseLocaleResult,\n} from 'vanilla-intlayer';\nimport { getRequestLocale } from './requestStorage';\n\nexport type { UseLocaleProps } from 'vanilla-intlayer';\n\nexport type UseLocaleResult = VanillaUseLocaleResult;\n\nconst { defaultLocale, locales: availableLocales } = internationalization;\n\n/**\n * Returns the locale of the request being rendered, read from\n * `Astro.locals.intlayer`, with the configured default and available locales.\n *\n * Falls back to the default locale outside of a request, i.e. when the\n * `astro-intlayer/middleware` did not run.\n *\n * Same shape as the client-side hook this entry resolves to in the browser\n * (`vanilla-intlayer`). A request has no locale to switch, so `setLocale` and\n * `subscribe` are inert here: switch the locale from a `<script>`, where the\n * same import gives the client implementation.\n *\n * @example\n * ```astro\n * ---\n * import { useLocale } from 'astro-intlayer';\n *\n * const { locale, availableLocales } = useLocale();\n * ---\n * <html lang={locale}>\n * ```\n */\nexport const useLocale = (_props: UseLocaleProps = {}): UseLocaleResult => ({\n  locale: getRequestLocale() ?? (defaultLocale as DeclaredLocales),\n  defaultLocale: defaultLocale as DeclaredLocales,\n  availableLocales: availableLocales as DeclaredLocales[],\n  setLocale: () => {\n    console.warn(\n      '[astro-intlayer] setLocale() has no effect during a server render. Call it from a client <script> instead.'\n    );\n  },\n  subscribe: () => () => {},\n});\n"],"mappings":";;;;AAYA,MAAM,EAAE,eAAe,SAAS,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;AAwBrD,MAAa,aAAa,SAAyB,CAAC,OAAwB;CAC1E,QAAQ,iBAAiB,KAAM;CAChB;CACG;CAClB,iBAAiB;EACf,QAAQ,KACN,4GACF;CACF;CACA,uBAAuB,CAAC;AAC1B"}

package/dist/esm/withInertOnChange.mjs

@@ -0,0 +1,16 @@
+//#region src/withInertOnChange.ts
+/**
+* Gives server-rendered content the `.onChange()` of its client counterpart.
+*
+* The locale cannot change during a server render, so the subscription never
+* fires; it only keeps the content shape identical on both sides of the
+* `astro-intlayer` entry.
+*/
+const withInertOnChange = (content) => {
+	if (content !== null && typeof content === "object") content.onChange = () => content;
+	return content;
+};
+
+//#endregion
+export { withInertOnChange };
+//# sourceMappingURL=withInertOnChange.mjs.map

package/dist/esm/withInertOnChange.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"withInertOnChange.mjs","names":[],"sources":["../../src/withInertOnChange.ts"],"sourcesContent":["import type { WithOnChange } from 'vanilla-intlayer';\n\n/**\n * Gives server-rendered content the `.onChange()` of its client counterpart.\n *\n * The locale cannot change during a server render, so the subscription never\n * fires; it only keeps the content shape identical on both sides of the\n * `astro-intlayer` entry.\n */\nexport const withInertOnChange = <T>(content: T): WithOnChange<T> => {\n  // A selector can resolve to null or a primitive; only objects carry `.onChange`.\n  if (content !== null && typeof content === 'object') {\n    (content as WithOnChange<T>).onChange = () => content as WithOnChange<T>;\n  }\n\n  return content as WithOnChange<T>;\n};\n"],"mappings":";;;;;;;;AASA,MAAa,qBAAwB,YAAgC;CAEnE,IAAI,YAAY,QAAQ,OAAO,YAAY,UACzC,AAAC,QAA4B,iBAAiB;CAGhD,OAAO;AACT"}

package/dist/types/client/format/index.d.ts

@@ -0,0 +1,2 @@
+import { useCompact, useCurrency, useDate, useIntl, useList, useNumber, usePercentage, useRelativeTime, useUnit } from "vanilla-intlayer/format";
+export { useCompact, useCurrency, useDate, useIntl, useList, useNumber, usePercentage, useRelativeTime, useUnit };

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

@@ -0,0 +1,2 @@
+import { DeepTransformContent, IntlayerNode, UseLocaleProps, UseLocaleResult, WithOnChange, getDictionary, getIntlayer, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage } from "vanilla-intlayer";
+export { type DeepTransformContent, type IntlayerNode, type UseLocaleProps, type UseLocaleResult, type WithOnChange, getDictionary, getIntlayer, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage };

package/dist/types/client/localeRedirect.d.ts

@@ -0,0 +1,26 @@
+//#region src/client/localeRedirect.d.ts
+/**
+ * Computes where a prerendered page should send the visitor so it matches the
+ * locale they stored (cookie, localStorage or sessionStorage, per
+ * `routing.storage`).
+ *
+ * Mirrors the redirect the Intlayer proxy performs on server-rendered requests,
+ * for pages served as static files where no server can read the cookie:
+ * - the URL wins over storage, so a localized URL is never redirected;
+ * - `routing.enableProxy: false` and `no-prefix` routing disable it;
+ * - in auto mode a dev server keeps routing URL-driven, like the proxy.
+ *
+ * @param url - The URL of the current page.
+ * @param isDevServer - Whether `astro dev` is serving the page.
+ * @returns The localized URL to navigate to, or `undefined` to stay put.
+ */
+export declare const getStoredLocaleRedirect: (url: URL, isDevServer: boolean) => string | undefined;
+/**
+ * Sends the visitor of a prerendered page to the URL of their stored locale.
+ *
+ * Injected on every page by the `intlayer()` integration; a no-op once the URL
+ * already names a locale, so a redirected page does not redirect again.
+ */
+export declare const redirectToStoredLocale: () => void;
+//#endregion
+//# sourceMappingURL=localeRedirect.d.ts.map

package/dist/types/client/localeRedirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeRedirect.d.ts","names":[],"sources":["../../../src/client/localeRedirect.ts"],"mappings":";;;;;;;;;;;;;;;;qBAwCa,0BAAuB,KAC7B,KAAG;;;;;;;qBAoCG"}

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

@@ -0,0 +1,10 @@
+import { useCompact } from "./useCompact.js";
+import { useCurrency } from "./useCurrency.js";
+import { useDate } from "./useDate.js";
+import { useIntl } from "./useIntl.js";
+import { useList } from "./useList.js";
+import { useNumber } from "./useNumber.js";
+import { usePercentage } from "./usePercentage.js";
+import { useRelativeTime } from "./useRelativeTime.js";
+import { useUnit } from "./useUnit.js";
+export { useCompact, useCurrency, useDate, useIntl, useList, useNumber, usePercentage, useRelativeTime, useUnit };

package/dist/types/format/useCompact.d.ts

@@ -0,0 +1,5 @@
+import { compact } from "@intlayer/core/formatters";
+//#region src/format/useCompact.d.ts
+export declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
+//#endregion
+//# sourceMappingURL=useCompact.d.ts.map

package/dist/types/format/useCompact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../src/format/useCompact.ts"],"mappings":";;qBAOa,sBAAU,MAGJ,kBAAkB"}

package/dist/types/format/useCurrency.d.ts

@@ -0,0 +1,5 @@
+import { currency } from "@intlayer/core/formatters";
+//#region src/format/useCurrency.d.ts
+export declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
+//#endregion
+//# sourceMappingURL=useCurrency.d.ts.map

package/dist/types/format/useCurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../src/format/useCurrency.ts"],"mappings":";;qBAOa,uBAAW,MAGL,kBAAkB"}

package/dist/types/format/useDate.d.ts

@@ -0,0 +1,8 @@
+import { date } from "@intlayer/core/formatters";
+//#region src/format/useDate.d.ts
+/**
+ * Astro hook that provides a localized date/time formatter bound to the request locale.
+ */
+export declare const useDate: () => (...args: Parameters<typeof date>) => string;
+//#endregion
+//# sourceMappingURL=useDate.d.ts.map

package/dist/types/format/useDate.d.ts.map

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

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

@@ -0,0 +1,15 @@
+import { WrappedIntl } from "@intlayer/core/utils";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/format/useIntl.d.ts
+/**
+ * Astro hook that provides a locale-bound `Intl` object.
+ *
+ * It uses the request locale on the server, falling back to the configured
+ * default locale.
+ */
+export declare const useIntl: (locale?: LocalesValues) => {
+  intl: WrappedIntl;
+  subscribe: (callback: (intl: WrappedIntl) => void) => () => void;
+};
+//#endregion
+//# sourceMappingURL=useIntl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/format/useIntl.ts"],"mappings":";;;;;;;;;qBAgBa,UAAO,SACT;EAET,MAAM;EACN,YAAY,WAAW,MAAM"}

package/dist/types/format/useList.d.ts

@@ -0,0 +1,5 @@
+import { list } from "@intlayer/core/formatters";
+//#region src/format/useList.d.ts
+export declare const useList: () => (...args: Parameters<typeof list>) => string;
+//#endregion
+//# sourceMappingURL=useList.d.ts.map

package/dist/types/format/useList.d.ts.map

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

package/dist/types/format/useNumber.d.ts

@@ -0,0 +1,8 @@
+import { number } from "@intlayer/core/formatters";
+//#region src/format/useNumber.d.ts
+/**
+ * Astro hook that provides a localized number formatter bound to the request locale.
+ */
+export declare const useNumber: () => (...args: Parameters<typeof number>) => string;
+//#endregion
+//# sourceMappingURL=useNumber.d.ts.map

package/dist/types/format/useNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../src/format/useNumber.ts"],"mappings":";;;;;qBAUa,qBAAS,MAGH,kBAAkB"}

package/dist/types/format/usePercentage.d.ts

@@ -0,0 +1,5 @@
+import { percentage } from "@intlayer/core/formatters";
+//#region src/format/usePercentage.d.ts
+export declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
+//#endregion
+//# sourceMappingURL=usePercentage.d.ts.map

package/dist/types/format/usePercentage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../src/format/usePercentage.ts"],"mappings":";;qBAOa,yBAAa,MAGP,kBAAkB"}

package/dist/types/format/useRelativeTime.d.ts

@@ -0,0 +1,5 @@
+import { relativeTime } from "@intlayer/core/formatters";
+//#region src/format/useRelativeTime.d.ts
+export declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
+//#endregion
+//# sourceMappingURL=useRelativeTime.d.ts.map

package/dist/types/format/useRelativeTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"mappings":";;qBAOa,2BAAe,MAGT,kBAAkB"}

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

@@ -0,0 +1,5 @@
+import { units } from "@intlayer/core/formatters";
+//#region src/format/useUnit.d.ts
+export declare const useUnit: () => (...args: Parameters<typeof units>) => string;
+//#endregion
+//# sourceMappingURL=useUnit.d.ts.map

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

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

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

@@ -0,0 +1,2 @@
+import { HTMLComponents, IntlayerHTMLPluginOptions, IntlayerHTMLProvider, RenderHTMLFunction, RenderHTMLOptions, RenderHTMLProps, installIntlayerHTML, installIntlayerHTMLDynamic, renderHTML, useHTML, useHTMLRenderer } from "vanilla-intlayer/html";
+export { type HTMLComponents, type IntlayerHTMLPluginOptions, type IntlayerHTMLProvider, type RenderHTMLFunction, type RenderHTMLOptions, type RenderHTMLProps, installIntlayerHTML, installIntlayerHTMLDynamic, renderHTML, useHTML, useHTMLRenderer };

package/dist/types/index.d.ts

@@ -1,3 +1,8 @@
+import { IntlayerLocals } from "./middleware.js";
+import { getIntlayerLocals } from "./requestStorage.js";
+import { useDictionary } from "./useDictionary.js";
+import { useIntlayer } from "./useIntlayer.js";
+import { UseLocaleProps, UseLocaleResult, useLocale } from "./useLocale.js";
 import { AstroIntegration } from "astro";
 //#region src/index.d.ts
 /**
@@ -7,12 +12,14 @@ import { AstroIntegration } from "astro";
  * 1. Preparing Intlayer resources (dictionaries) at config setup.
  * 2. Injecting Vite plugins for aliases, locale-based routing (middleware), and build optimizations (prune).
  * 3. Configuring Vite aliases for dictionary access.
- * 4. Emitting the prerendered pages at their rewritten (localized) URLs.
+ * 4. Registering the `astro-intlayer/middleware`, which resolves the request
+ *    locale into `Astro.locals.intlayer` for the `useLocale` / `useIntlayer` /
+ *    `useDictionary` hooks of this package.
+ * 5. Emitting the prerendered pages at their rewritten (localized) URLs.
  *
- * The dev-time content watcher is not started here: the bundled
- * `vite-intlayer` plugin already starts one from `configureServer`, and
- * `watch()` subscribes anew on every call, so doing both would rebuild each
- * content edit twice.
+ * The implementation is loaded lazily: this entry is also the one pages import
+ * their hooks from, and it must not drag the Node-only tooling into their
+ * server bundle.
  *
  * @returns An Astro integration object.
  *
@@ -29,5 +36,5 @@ import { AstroIntegration } from "astro";
  */
 export declare const intlayer: () => AstroIntegration;
 //#endregion
-export { intlayer as default };
+export { type IntlayerLocals, type UseLocaleProps, type UseLocaleResult, intlayer as default, getIntlayerLocals, useDictionary, useIntlayer, useLocale };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsDa,gBAAe"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqDa,gBAAe"}

package/dist/types/integration.d.ts

@@ -0,0 +1,41 @@
+import { AstroIntegration } from "astro";
+//#region src/integration.d.ts
+/**
+ * Node-only half of the integration, loaded lazily by the `astro-intlayer`
+ * entry when a hook runs.
+ *
+ * Pages import their hooks from that same entry, and Astro bundles the whole
+ * package into the server build (`ssr.noExternal`), so the config loader,
+ * `@intlayer/engine` and `vite-intlayer` must stay behind a dynamic import:
+ * a static one would put them in the module graph of every page.
+ */
+type ConfigSetupOptions = Parameters<NonNullable<AstroIntegration['hooks']['astro:config:setup']>>[0];
+type BuildDoneOptions = Parameters<NonNullable<AstroIntegration['hooks']['astro:build:done']>>[0];
+/**
+ * `astro:config:setup`:
+ * 1. Prepares the Intlayer resources (dictionaries).
+ * 2. Injects the Vite plugins for aliases, locale-based routing and build
+ *    optimizations (prune).
+ * 3. Configures the Vite aliases for dictionary access.
+ * 4. Registers the `astro-intlayer/middleware`, which resolves the request
+ *    locale into `Astro.locals.intlayer` for the hooks and redirects
+ *    server-rendered requests to the visitor's locale.
+ * 5. Injects the client-side locale redirect, which does the same for
+ *    prerendered pages: served as static files, nothing else can read the
+ *    stored locale there.
+ *
+ * The dev-time content watcher is not started here: the bundled
+ * `vite-intlayer` plugin already starts one from `configureServer`, and
+ * `watch()` subscribes anew on every call, so doing both would rebuild each
+ * content edit twice.
+ */
+export declare const configSetup: ({ command, updateConfig, addMiddleware, injectScript }: ConfigSetupOptions) => Promise<void>;
+/**
+ * `astro:build:done`: Astro renders each page from its canonical file-system
+ * route, so a static build has no file for the localized paths declared in
+ * `routing.rewrite`. Mirror them here, otherwise the URLs produced by
+ * `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.
+ */
+export declare const buildDone: ({ dir, logger }: BuildDoneOptions) => Promise<void>;
+//#endregion
+//# sourceMappingURL=integration.d.ts.map

package/dist/types/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","names":[],"sources":["../../src/integration.ts"],"mappings":";;;;;;;;;;;KA0CK,qBAAqB,WACxB,YAAY;KAGT,mBAAmB,WACtB,YAAY;;;;;;;;;;;;;;;;;;;qBAqBD,gBAAW,SAAA,cAAA,eAAA,gBAKrB,uBAAqB;;;;;;;qBAsEX,cAAS,KAAA,UAGnB,qBAAmB"}

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

@@ -0,0 +1,2 @@
+import { IntlayerMarkdownPluginOptions, IntlayerMarkdownProvider, MarkdownCompilerOptions, MarkdownProviderOptions, ParsedMarkdown, RenderMarkdownFunction, RenderMarkdownProps, compileMarkdown, installIntlayerMarkdown, installIntlayerMarkdownDynamic, parseMarkdown, renderMarkdown, useMarkdown, useMarkdownRenderer } from "vanilla-intlayer/markdown";
+export { type IntlayerMarkdownPluginOptions, type IntlayerMarkdownProvider, type MarkdownCompilerOptions, type MarkdownProviderOptions, type ParsedMarkdown, type RenderMarkdownFunction, type RenderMarkdownProps, compileMarkdown, installIntlayerMarkdown, installIntlayerMarkdownDynamic, parseMarkdown, renderMarkdown, useMarkdown, useMarkdownRenderer };

package/dist/types/middleware.d.ts

@@ -0,0 +1,54 @@
+import { DeclaredLocales } from "@intlayer/types/module_augmentation";
+import { MiddlewareHandler } from "astro";
+//#region src/middleware.d.ts
+/**
+ * Intlayer state stored in `Astro.locals.intlayer` by the {@link onRequest} middleware.
+ */
+export type IntlayerLocals = {
+  /** Locale resolved for the current request. */
+  locale: DeclaredLocales;
+  /** Locale configured as fallback in `intlayer.config.ts`. */
+  defaultLocale: DeclaredLocales;
+  /** Every locale declared in `intlayer.config.ts`. */
+  availableLocales: DeclaredLocales[];
+};
+declare global {
+  namespace App {
+    interface Locals {
+      intlayer: IntlayerLocals;
+    }
+  }
+}
+/**
+ * Astro middleware resolving the request locale into `Astro.locals.intlayer`.
+ *
+ * Priority: the URL (path prefix or `?locale=` search param, in every routing
+ * mode but `no-prefix`), then the locale persisted by the client (cookie or
+ * custom header), then `Accept-Language` negotiation.
+ *
+ * On server-rendered requests it also runs the Intlayer locale-routing proxy,
+ * so a visitor whose stored locale is `fr` is redirected from `/` to `/fr`
+ * (per `routing.mode`) and the resolved locale is persisted on the response.
+ * Only redirects are honoured: the proxy's internal rewrites target
+ * prefix-based routers, while Astro pages already resolve the locale from the
+ * URL they are rendered for. Prerendered pages are served as static files, so
+ * nothing can redirect them at request time and the proxy is skipped.
+ *
+ * The `intlayer()` integration registers it automatically, before the user
+ * middleware, so `Astro.locals.intlayer` is available in every page, endpoint
+ * and middleware. The rest of the request renders inside an
+ * `AsyncLocalStorage` scope bound to those locals, which is how the hooks of
+ * `astro-intlayer/server` read the locale with no argument.
+ *
+ * @example
+ * ```ts
+ * // src/middleware.ts — only needed when composing it by hand
+ * import { onRequest as intlayer } from 'astro-intlayer/middleware';
+ * import { sequence } from 'astro:middleware';
+ *
+ * export const onRequest = sequence(intlayer, myMiddleware);
+ * ```
+ */
+export declare const onRequest: MiddlewareHandler;
+//#endregion
+//# sourceMappingURL=middleware.d.ts.map

package/dist/types/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/middleware.ts"],"mappings":";;;;;;YAuEY;;EAEV,QAAQ;;EAER,eAAe;;EAEf,kBAAkB;;QAGZ;YACI;cACE;MACR,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCH,WAAW"}