astro-intlayer 9.5.4 → 9.5.6

package/dist/cjs/index.cjs

@@ -1,24 +1,25 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-const require_emitRewrittenPages = require('./emitRewrittenPages.cjs');
-let node_path = require("node:path");
-let _intlayer_config_node = require("@intlayer/config/node");
-let _intlayer_config_utils = require("@intlayer/config/utils");
-let _intlayer_engine_build = require("@intlayer/engine/build");
-let vite_intlayer = require("vite-intlayer");
+const require_requestStorage = require('./requestStorage.cjs');
+const require_useDictionary = require('./useDictionary.cjs');
+const require_useIntlayer = require('./useIntlayer.cjs');
+const require_useLocale = require('./useLocale.cjs');
 
 //#region src/index.ts
 /**
-* Keeps the intlayer packages out of Node's native module loader in *every*
-* Vite environment Astro renders from.
+* Package self-reference to the Node-only half of the integration.
 *
-* A static dev server renders from `ssr`, but other setups render from Astro's
-* `astro` or `prerender` environments, and a top-level `ssr.noExternal` only
-* seeds the `ssr` one. Declaring it per environment covers the rest.
+* Kept in a variable so the `import()` below is not statically analyzable:
+* Astro bundles this package into the server build (`ssr.noExternal`), and a
+* literal specifier would make the bundler follow it into `vite-intlayer`,
+* `@intlayer/engine` and the framework compilers — which have no business in
+* the server build, and do not even bundle (`velocityjs`, …). Left alone, the
+* import only runs from `astro.config`, in Node.
 */
-const intlayerNoExternalEnvironments = () => ({
-	name: "astro-intlayer-no-external",
-	configEnvironment: () => ({ resolve: { noExternal: [vite_intlayer.INTLAYER_NO_EXTERNAL_PATTERN] } })
-});
+const integrationSpecifier = "astro-intlayer/integration";
+const loadIntegration = () => import(
+	/* @vite-ignore */
+	integrationSpecifier
+);
 /**
 * Astro integration for Intlayer.
 *
@@ -26,12 +27,14 @@ const intlayerNoExternalEnvironments = () => ({
 * 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.
 *
@@ -49,22 +52,13 @@ const intlayerNoExternalEnvironments = () => ({
 const intlayer = () => ({
 	name: "astro-intlayer",
 	hooks: {
-		"astro:config:setup": async ({ updateConfig }) => {
-			const configuration = (0, _intlayer_config_node.getConfiguration)();
-			await (0, _intlayer_engine_build.prepareIntlayer)(configuration);
-			updateConfig({ vite: {
-				plugins: [(0, vite_intlayer.intlayer)(), intlayerNoExternalEnvironments()],
-				resolve: { alias: { ...(0, _intlayer_config_utils.getAlias)({
-					configuration,
-					formatter: (value) => (0, node_path.resolve)(value)
-				}) } },
-				ssr: { noExternal: [vite_intlayer.INTLAYER_NO_EXTERNAL_PATTERN] }
-			} });
+		"astro:config:setup": async (options) => {
+			const { configSetup } = await loadIntegration();
+			await configSetup(options);
 		},
-		"astro:build:done": async ({ dir, logger }) => {
-			const configuration = (0, _intlayer_config_node.getConfiguration)();
-			const emittedPages = await require_emitRewrittenPages.emitRewrittenPages(configuration, dir);
-			if (emittedPages.length > 0) logger.info(`Emitted ${emittedPages.length} rewritten page(s): ${emittedPages.map(([from, to]) => `${from} \u2192 ${to}`).join(", ")}`);
+		"astro:build:done": async (options) => {
+			const { buildDone } = await loadIntegration();
+			await buildDone(options);
 		}
 	}
 });
@@ -72,4 +66,8 @@ const intlayer = () => ({
 //#endregion
 exports.default = intlayer;
 exports.intlayer = intlayer;
+exports.getIntlayerLocals = require_requestStorage.getIntlayerLocals;
+exports.useDictionary = require_useDictionary.useDictionary;
+exports.useIntlayer = require_useIntlayer.useIntlayer;
+exports.useLocale = require_useLocale.useLocale;
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["INTLAYER_NO_EXTERNAL_PATTERN","getConfiguration","prepareIntlayer","viteIntlayerPlugin","getAlias","resolve","emitRewrittenPages"],"sources":["../../src/index.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { getAlias } from '@intlayer/config/utils';\nimport { prepareIntlayer } from '@intlayer/engine/build';\nimport type { AstroIntegration } from 'astro';\nimport type { PluginOption } from 'vite';\nimport {\n  INTLAYER_NO_EXTERNAL_PATTERN,\n  intlayer as viteIntlayerPlugin,\n} from 'vite-intlayer';\nimport { emitRewrittenPages } from './emitRewrittenPages';\n\n/**\n * Keeps the intlayer packages out of Node's native module loader in *every*\n * Vite environment Astro renders from.\n *\n * A static dev server renders from `ssr`, but other setups render from Astro's\n * `astro` or `prerender` environments, and a top-level `ssr.noExternal` only\n * seeds the `ssr` one. Declaring it per environment covers the rest.\n */\nconst intlayerNoExternalEnvironments = (): PluginOption => ({\n  name: 'astro-intlayer-no-external',\n  configEnvironment: () => ({\n    resolve: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] },\n  }),\n});\n\n/**\n * Astro integration for Intlayer.\n *\n * It handles:\n * 1. Preparing Intlayer resources (dictionaries) at config setup.\n * 2. Injecting Vite plugins for aliases, locale-based routing (middleware), and build optimizations (prune).\n * 3. Configuring Vite aliases for dictionary access.\n * 4. Emitting the prerendered pages at their rewritten (localized) URLs.\n *\n * The dev-time content watcher is not started here: the bundled\n * `vite-intlayer` plugin already starts one from `configureServer`, and\n * `watch()` subscribes anew on every call, so doing both would rebuild each\n * content edit twice.\n *\n * @returns An Astro integration object.\n *\n * @example\n * ```ts\n * // astro.config.mjs\n * import { defineConfig } from 'astro/config';\n * import { intlayer } from 'astro-intlayer';\n *\n * export default defineConfig({\n *   integrations: [intlayer()],\n * });\n * ```\n */\nexport const intlayer = (): AstroIntegration =>\n  ({\n    name: 'astro-intlayer',\n    hooks: {\n      'astro:config:setup': async ({ updateConfig }) => {\n        const configuration = getConfiguration();\n\n        // Prepare once per process start to ensure generated entries exist\n        await prepareIntlayer(configuration);\n\n        updateConfig({\n          vite: {\n            plugins: [\n              viteIntlayerPlugin(),\n              intlayerNoExternalEnvironments(),\n            ] as PluginOption[],\n            resolve: {\n              alias: {\n                ...getAlias({\n                  configuration,\n                  formatter: (value) => resolve(value),\n                }),\n              },\n            },\n            // `astro-intlayer` is tagged with the `astro` keyword, so Astro\n            // treats it as an Astro package and crawls its dependency tree\n            // (`vitefu`), force-externalizing every dependency it finds —\n            // `@intlayer/core`, `@intlayer/config`, … — into\n            // `resolve.external`. Vite checks `external` before `noExternal`,\n            // so the `ssr.noExternal` that `vite-intlayer` returns from its\n            // Vite `config` hook loses that race and the packages are loaded\n            // natively by Node, stranding dictionary edits behind Node's\n            // require cache. Declaring it here instead runs before the crawl,\n            // which drops explicitly no-externalized packages from its result.\n            ssr: {\n              noExternal: [INTLAYER_NO_EXTERNAL_PATTERN],\n            },\n          },\n        });\n      },\n\n      // Astro renders each page from its canonical file-system route, so a\n      // static build has no file for the localized paths declared in\n      // `routing.rewrite`. Mirror them here, otherwise the URLs produced by\n      // `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.\n      'astro:build:done': async ({ dir, logger }) => {\n        const configuration = getConfiguration();\n\n        const emittedPages = await emitRewrittenPages(configuration, dir);\n\n        if (emittedPages.length > 0) {\n          logger.info(\n            `Emitted ${emittedPages.length} rewritten page(s): ${emittedPages\n              .map(([from, to]) => `${from} \\u2192 ${to}`)\n              .join(', ')}`\n          );\n        }\n      },\n    },\n  }) satisfies AstroIntegration;\n\n/**\n * Alias of {@link intlayer}, kept so `astro add astro-intlayer` works.\n *\n * Astro's CLI codemod always writes a default import\n * (`import intlayer from 'astro-intlayer'`) without checking what the package\n * exports, so the integration has to be reachable that way too. The named\n * export stays the documented one.\n */\nexport default intlayer;\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,MAAM,wCAAsD;CAC1D,MAAM;CACN,0BAA0B,EACxB,SAAS,EAAE,YAAY,CAACA,0CAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,kBACV;CACC,MAAM;CACN,OAAO;EACL,sBAAsB,OAAO,EAAE,mBAAmB;GAChD,MAAM,oBAAgBC,wCAAiB;GAGvC,UAAMC,wCAAgB,aAAa;GAEnC,aAAa,EACX,MAAM;IACJ,SAAS,KACPC,wBAAmB,GACnB,+BAA+B,CACjC;IACA,SAAS,EACP,OAAO,EACL,OAAGC,iCAAS;KACV;KACA,YAAY,cAAUC,mBAAQ,KAAK;IACrC,CAAC,EACH,EACF;IAWA,KAAK,EACH,YAAY,CAACL,0CAA4B,EAC3C;GACF,EACF,CAAC;EACH;EAMA,oBAAoB,OAAO,EAAE,KAAK,aAAa;GAC7C,MAAM,oBAAgBC,wCAAiB;GAEvC,MAAM,eAAe,MAAMK,8CAAmB,eAAe,GAAG;GAEhE,IAAI,aAAa,SAAS,GACxB,OAAO,KACL,WAAW,aAAa,OAAO,sBAAsB,aAClD,KAAK,CAAC,MAAM,QAAQ,GAAG,KAAK,UAAU,IAAI,CAAC,CAC3C,KAAK,IAAI,GACd;EAEJ;CACF;AACF"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["import type { AstroIntegration } from 'astro';\n\nexport type { IntlayerLocals } from './middleware';\nexport { getIntlayerLocals } from './requestStorage';\nexport { useDictionary } from './useDictionary';\nexport { useIntlayer } from './useIntlayer';\nexport type { UseLocaleProps, UseLocaleResult } from './useLocale';\nexport { useLocale } from './useLocale';\n\n/**\n * Package self-reference to the Node-only half of the integration.\n *\n * Kept in a variable so the `import()` below is not statically analyzable:\n * Astro bundles this package into the server build (`ssr.noExternal`), and a\n * literal specifier would make the bundler follow it into `vite-intlayer`,\n * `@intlayer/engine` and the framework compilers — which have no business in\n * the server build, and do not even bundle (`velocityjs`, …). Left alone, the\n * import only runs from `astro.config`, in Node.\n */\nconst integrationSpecifier = 'astro-intlayer/integration';\n\nconst loadIntegration = (): Promise<typeof import('./integration')> =>\n  import(/* @vite-ignore */ integrationSpecifier);\n\n/**\n * Astro integration for Intlayer.\n *\n * It handles:\n * 1. Preparing Intlayer resources (dictionaries) at config setup.\n * 2. Injecting Vite plugins for aliases, locale-based routing (middleware), and build optimizations (prune).\n * 3. Configuring Vite aliases for dictionary access.\n * 4. Registering the `astro-intlayer/middleware`, which resolves the request\n *    locale into `Astro.locals.intlayer` for the `useLocale` / `useIntlayer` /\n *    `useDictionary` hooks of this package.\n * 5. Emitting the prerendered pages at their rewritten (localized) URLs.\n *\n * The implementation is loaded lazily: this entry is also the one pages import\n * their hooks from, and it must not drag the Node-only tooling into their\n * server bundle.\n *\n * @returns An Astro integration object.\n *\n * @example\n * ```ts\n * // astro.config.mjs\n * import { defineConfig } from 'astro/config';\n * import { intlayer } from 'astro-intlayer';\n *\n * export default defineConfig({\n *   integrations: [intlayer()],\n * });\n * ```\n */\nexport const intlayer = (): AstroIntegration =>\n  ({\n    name: 'astro-intlayer',\n    hooks: {\n      'astro:config:setup': async (options) => {\n        const { configSetup } = await loadIntegration();\n\n        await configSetup(options);\n      },\n      'astro:build:done': async (options) => {\n        const { buildDone } = await loadIntegration();\n\n        await buildDone(options);\n      },\n    },\n  }) satisfies AstroIntegration;\n\n/**\n * Alias of {@link intlayer}, kept so `astro add astro-intlayer` works.\n *\n * Astro's CLI codemod always writes a default import\n * (`import intlayer from 'astro-intlayer'`) without checking what the package\n * exports, so the integration has to be reachable that way too. The named\n * export stays the documented one.\n */\nexport default intlayer;\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,MAAM,uBAAuB;AAE7B,MAAM,wBACJ;;CAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+B5B,MAAa,kBACV;CACC,MAAM;CACN,OAAO;EACL,sBAAsB,OAAO,YAAY;GACvC,MAAM,EAAE,gBAAgB,MAAM,gBAAgB;GAE9C,MAAM,YAAY,OAAO;EAC3B;EACA,oBAAoB,OAAO,YAAY;GACrC,MAAM,EAAE,cAAc,MAAM,gBAAgB;GAE5C,MAAM,UAAU,OAAO;EACzB;CACF;AACF"}

package/dist/cjs/integration.cjs

@@ -0,0 +1,77 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_emitRewrittenPages = require('./emitRewrittenPages.cjs');
+let node_path = require("node:path");
+let _intlayer_core_localization = require("@intlayer/core/localization");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_node = require("@intlayer/config/node");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_engine_build = require("@intlayer/engine/build");
+let vite_intlayer = require("vite-intlayer");
+
+//#region src/integration.ts
+/**
+* Keeps the intlayer packages out of Node's native module loader in *every*
+* Vite environment Astro renders from.
+*
+* A static dev server renders from `ssr`, but other setups render from Astro's
+* `astro` or `prerender` environments, and a top-level `ssr.noExternal` only
+* seeds the `ssr` one. Declaring it per environment covers the rest.
+*/
+const intlayerNoExternalEnvironments = () => ({
+	name: "astro-intlayer-no-external",
+	configEnvironment: () => ({ resolve: { noExternal: [vite_intlayer.INTLAYER_NO_EXTERNAL_PATTERN] } })
+});
+/**
+* `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.
+*/
+const configSetup = async ({ command, updateConfig, addMiddleware, injectScript }) => {
+	const configuration = (0, _intlayer_config_node.getConfiguration)();
+	await (0, _intlayer_engine_build.prepareIntlayer)(configuration);
+	addMiddleware({
+		entrypoint: "astro-intlayer/middleware",
+		order: "pre"
+	});
+	if ((0, _intlayer_core_localization.resolveProxyMode)(configuration.routing.enableProxy) !== "disabled") {
+		injectScript("page", `import { redirectToStoredLocale } from 'astro-intlayer/client/locale-redirect';\nredirectToStoredLocale();`);
+		if (command === "preview") (0, _intlayer_config_logger.getAppLogger)(configuration)((0, _intlayer_core_localization.formatProxyEnabledMessage)(false), { level: "info" });
+	}
+	updateConfig({ vite: {
+		plugins: [(0, vite_intlayer.intlayer)(), intlayerNoExternalEnvironments()],
+		resolve: { alias: { ...(0, _intlayer_config_utils.getAlias)({
+			configuration,
+			formatter: (value) => (0, node_path.resolve)(value)
+		}) } },
+		ssr: { noExternal: [vite_intlayer.INTLAYER_NO_EXTERNAL_PATTERN] }
+	} });
+};
+/**
+* `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.
+*/
+const buildDone = async ({ dir, logger }) => {
+	const configuration = (0, _intlayer_config_node.getConfiguration)();
+	const emittedPages = await require_emitRewrittenPages.emitRewrittenPages(configuration, dir);
+	if (emittedPages.length > 0) logger.info(`Emitted ${emittedPages.length} rewritten page(s): ${emittedPages.map(([from, to]) => `${from} \u2192 ${to}`).join(", ")}`);
+};
+
+//#endregion
+exports.buildDone = buildDone;
+exports.configSetup = configSetup;
+//# sourceMappingURL=integration.cjs.map

package/dist/cjs/integration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.cjs","names":["INTLAYER_NO_EXTERNAL_PATTERN","getConfiguration","prepareIntlayer","resolveProxyMode","formatProxyEnabledMessage","viteIntlayerPlugin","getAlias","resolve","emitRewrittenPages"],"sources":["../../src/integration.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { getAppLogger } from '@intlayer/config/logger';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { getAlias } from '@intlayer/config/utils';\nimport {\n  formatProxyEnabledMessage,\n  resolveProxyMode,\n} from '@intlayer/core/localization';\nimport { prepareIntlayer } from '@intlayer/engine/build';\nimport type { AstroIntegration } from 'astro';\nimport type { PluginOption } from 'vite';\nimport {\n  INTLAYER_NO_EXTERNAL_PATTERN,\n  intlayer as viteIntlayerPlugin,\n} from 'vite-intlayer';\nimport { emitRewrittenPages } from './emitRewrittenPages';\n\n/**\n * Keeps the intlayer packages out of Node's native module loader in *every*\n * Vite environment Astro renders from.\n *\n * A static dev server renders from `ssr`, but other setups render from Astro's\n * `astro` or `prerender` environments, and a top-level `ssr.noExternal` only\n * seeds the `ssr` one. Declaring it per environment covers the rest.\n */\nconst intlayerNoExternalEnvironments = (): PluginOption => ({\n  name: 'astro-intlayer-no-external',\n  configEnvironment: () => ({\n    resolve: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] },\n  }),\n});\n\n/**\n * Node-only half of the integration, loaded lazily by the `astro-intlayer`\n * entry when a hook runs.\n *\n * Pages import their hooks from that same entry, and Astro bundles the whole\n * package into the server build (`ssr.noExternal`), so the config loader,\n * `@intlayer/engine` and `vite-intlayer` must stay behind a dynamic import:\n * a static one would put them in the module graph of every page.\n */\n\ntype ConfigSetupOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:config:setup']>\n>[0];\n\ntype BuildDoneOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:build:done']>\n>[0];\n\n/**\n * `astro:config:setup`:\n * 1. Prepares the Intlayer resources (dictionaries).\n * 2. Injects the Vite plugins for aliases, locale-based routing and build\n *    optimizations (prune).\n * 3. Configures the Vite aliases for dictionary access.\n * 4. Registers the `astro-intlayer/middleware`, which resolves the request\n *    locale into `Astro.locals.intlayer` for the hooks and redirects\n *    server-rendered requests to the visitor's locale.\n * 5. Injects the client-side locale redirect, which does the same for\n *    prerendered pages: served as static files, nothing else can read the\n *    stored locale there.\n *\n * The dev-time content watcher is not started here: the bundled\n * `vite-intlayer` plugin already starts one from `configureServer`, and\n * `watch()` subscribes anew on every call, so doing both would rebuild each\n * content edit twice.\n */\nexport const configSetup = async ({\n  command,\n  updateConfig,\n  addMiddleware,\n  injectScript,\n}: ConfigSetupOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  // Prepare once per process start to ensure generated entries exist\n  await prepareIntlayer(configuration);\n\n  // Runs before the user middleware so `Astro.locals.intlayer` is set\n  // everywhere, including in a hand-written `src/middleware.ts`.\n  addMiddleware({\n    entrypoint: 'astro-intlayer/middleware',\n    order: 'pre',\n  });\n\n  const proxyMode = resolveProxyMode(configuration.routing.enableProxy);\n\n  if (proxyMode !== 'disabled') {\n    injectScript(\n      'page',\n      `import { redirectToStoredLocale } from 'astro-intlayer/client/locale-redirect';\\nredirectToStoredLocale();`\n    );\n\n    // `dev` and `build` are announced by the bundled `vite-intlayer` plugin.\n    // `astro preview` runs no Vite plugin, so the served output is announced\n    // here: the stored locale drives redirects again once the output is\n    // served — by the middleware on server-rendered pages, by the injected\n    // script on static ones.\n    if (command === 'preview') {\n      getAppLogger(configuration)(formatProxyEnabledMessage(false), {\n        level: 'info',\n      });\n    }\n  }\n\n  updateConfig({\n    vite: {\n      plugins: [\n        viteIntlayerPlugin(),\n        intlayerNoExternalEnvironments(),\n      ] as PluginOption[],\n      resolve: {\n        alias: {\n          ...getAlias({\n            configuration,\n            formatter: (value) => resolve(value),\n          }),\n        },\n      },\n      // `astro-intlayer` is tagged with the `astro` keyword, so Astro\n      // treats it as an Astro package and crawls its dependency tree\n      // (`vitefu`), force-externalizing every dependency it finds —\n      // `@intlayer/core`, `@intlayer/config`, … — into\n      // `resolve.external`. Vite checks `external` before `noExternal`,\n      // so the `ssr.noExternal` that `vite-intlayer` returns from its\n      // Vite `config` hook loses that race and the packages are loaded\n      // natively by Node, stranding dictionary edits behind Node's\n      // require cache. Declaring it here instead runs before the crawl,\n      // which drops explicitly no-externalized packages from its result.\n      ssr: {\n        noExternal: [INTLAYER_NO_EXTERNAL_PATTERN],\n      },\n    },\n  });\n};\n\n/**\n * `astro:build:done`: Astro renders each page from its canonical file-system\n * route, so a static build has no file for the localized paths declared in\n * `routing.rewrite`. Mirror them here, otherwise the URLs produced by\n * `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.\n */\nexport const buildDone = async ({\n  dir,\n  logger,\n}: BuildDoneOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  const emittedPages = await emitRewrittenPages(configuration, dir);\n\n  if (emittedPages.length > 0) {\n    logger.info(\n      `Emitted ${emittedPages.length} rewritten page(s): ${emittedPages\n        .map(([from, to]) => `${from} \\u2192 ${to}`)\n        .join(', ')}`\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAyBA,MAAM,wCAAsD;CAC1D,MAAM;CACN,0BAA0B,EACxB,SAAS,EAAE,YAAY,CAACA,0CAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,cAAc,OAAO,EAChC,SACA,cACA,eACA,mBACuC;CACvC,MAAM,oBAAgBC,wCAAiB;CAGvC,UAAMC,wCAAgB,aAAa;CAInC,cAAc;EACZ,YAAY;EACZ,OAAO;CACT,CAAC;CAID,QAFkBC,8CAAiB,cAAc,QAAQ,WAE7C,MAAM,YAAY;EAC5B,aACE,QACA,4GACF;EAOA,IAAI,YAAY,WACd,0CAAa,aAAa,CAAC,KAACC,uDAA0B,KAAK,GAAG,EAC5D,OAAO,OACT,CAAC;CAEL;CAEA,aAAa,EACX,MAAM;EACJ,SAAS,KACPC,wBAAmB,GACnB,+BAA+B,CACjC;EACA,SAAS,EACP,OAAO,EACL,OAAGC,iCAAS;GACV;GACA,YAAY,cAAUC,mBAAQ,KAAK;EACrC,CAAC,EACH,EACF;EAWA,KAAK,EACH,YAAY,CAACP,0CAA4B,EAC3C;CACF,EACF,CAAC;AACH;;;;;;;AAQA,MAAa,YAAY,OAAO,EAC9B,KACA,aACqC;CACrC,MAAM,oBAAgBC,wCAAiB;CAEvC,MAAM,eAAe,MAAMO,8CAAmB,eAAe,GAAG;CAEhE,IAAI,aAAa,SAAS,GACxB,OAAO,KACL,WAAW,aAAa,OAAO,sBAAsB,aAClD,KAAK,CAAC,MAAM,QAAQ,GAAG,KAAK,UAAU,IAAI,CAAC,CAC3C,KAAK,IAAI,GACd;AAEJ"}

package/dist/cjs/markdown/index.cjs

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let vanilla_intlayer_markdown = require("vanilla-intlayer/markdown");
+
+Object.defineProperty(exports, 'compileMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.compileMarkdown;
+  }
+});
+Object.defineProperty(exports, 'installIntlayerMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.installIntlayerMarkdown;
+  }
+});
+Object.defineProperty(exports, 'installIntlayerMarkdownDynamic', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.installIntlayerMarkdownDynamic;
+  }
+});
+Object.defineProperty(exports, 'parseMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.parseMarkdown;
+  }
+});
+Object.defineProperty(exports, 'renderMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.renderMarkdown;
+  }
+});
+Object.defineProperty(exports, 'useMarkdown', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.useMarkdown;
+  }
+});
+Object.defineProperty(exports, 'useMarkdownRenderer', {
+  enumerable: true,
+  get: function () {
+    return vanilla_intlayer_markdown.useMarkdownRenderer;
+  }
+});

package/dist/cjs/middleware.cjs

@@ -0,0 +1,103 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_requestStorage = require('./requestStorage.cjs');
+let _intlayer_core_localization = require("@intlayer/core/localization");
+let _intlayer_config_built = require("@intlayer/config/built");
+_intlayer_config_built = require_runtime.__toESM(_intlayer_config_built);
+let vite_intlayer_web_proxy_handler = require("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 = {}.env?.DEV === true;
+const configuration = _intlayer_config_built;
+const { internationalization, routing } = 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 = (0, _intlayer_core_localization.resolveProxyMode)(routing.enableProxy) === "disabled" ? void 0 : (0, vite_intlayer_web_proxy_handler.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 (0, _intlayer_core_localization.getLocaleFromRequest)({
+			url: context.url,
+			headers: context.isPrerendered ? new Headers() : context.request.headers
+		}),
+		defaultLocale: internationalization.defaultLocale,
+		availableLocales: internationalization.locales
+	};
+	const response = await require_requestStorage.requestStorage.run(context.locals, next);
+	return proxyOutcome ? withProxyHeaders(response, proxyOutcome.headers) : response;
+};
+
+//#endregion
+exports.onRequest = onRequest;
+//# sourceMappingURL=middleware.cjs.map

package/dist/cjs/middleware.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.cjs","names":["builtConfiguration","resolveProxyMode","createIntlayerWebProxyHandler","getLocaleFromRequest","requestStorage"],"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,iBACyC,KAAK,QAAQ;AAE5D,MAAM,gBAAgBA;AACtB,MAAM,EAAE,sBAAsB,YAAY;;;;;;;;;AAU1C,MAAM,YACJC,8CAAiB,QAAQ,WAAW,MAAM,aACtC,aACAC,+DAA8B;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,UAAMC,kDAAqB;GACjC,KAAK,QAAQ;GAIb,SAAS,QAAQ,gBAAgB,IAAI,QAAQ,IAAI,QAAQ,QAAQ;EACnE,CAAC;EACD,eAAe,qBAAqB;EACpC,kBAAkB,qBAAqB;CACzC;CAEA,MAAM,WAAW,MAAMC,sCAAe,IAAI,QAAQ,QAAQ,IAAI;CAE9D,OAAO,eACH,iBAAiB,UAAU,aAAa,OAAO,IAC/C;AACN"}

package/dist/cjs/requestStorage.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let node_async_hooks = require("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 node_async_hooks.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
+exports.getIntlayerLocals = getIntlayerLocals;
+exports.getRequestLocale = getRequestLocale;
+exports.requestStorage = requestStorage;
+//# sourceMappingURL=requestStorage.cjs.map

package/dist/cjs/requestStorage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestStorage.cjs","names":["AsyncLocalStorage"],"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,IAAIA,mCAE/B;;;;AAKH,MAAa,0BACX,eAAe,SAAS,CAAC,EAAE;;;;AAK7B,MAAa,yBACX,kBAAkB,CAAC,EAAE"}

package/dist/cjs/useDictionary.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_requestStorage = require('./requestStorage.cjs');
+const require_withInertOnChange = require('./withInertOnChange.cjs');
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+let vanilla_intlayer = require("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) => require_withInertOnChange.withInertOnChange((0, vanilla_intlayer.getDictionary)(dictionary, (0, _intlayer_core_dictionaryManipulator.resolveDictionaryArgument)({
+	localeOrSelector,
+	contextLocale: require_requestStorage.getRequestLocale(),
+	dictionaryKey: dictionary.key
+})));
+
+//#endregion
+exports.useDictionary = useDictionary;
+//# sourceMappingURL=useDictionary.cjs.map

package/dist/cjs/useDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.cjs","names":["withInertOnChange","getDictionary","resolveDictionaryArgument","getRequestLocale"],"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,qBAOAA,gDACEC,gCACE,gBACAC,gEAA0B;CACxB;CACA,eAAeC,wCAAiB;CAChC,eAAe,WAAW;AAC5B,CAAC,CACH,CACF"}

package/dist/cjs/useIntlayer.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_requestStorage = require('./requestStorage.cjs');
+const require_withInertOnChange = require('./withInertOnChange.cjs');
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+let vanilla_intlayer = require("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) => require_withInertOnChange.withInertOnChange((0, vanilla_intlayer.getIntlayer)(key, (0, _intlayer_core_dictionaryManipulator.resolveDictionaryArgument)({
+	localeOrSelector,
+	contextLocale: require_requestStorage.getRequestLocale(),
+	dictionaryKey: key
+})));
+
+//#endregion
+exports.useIntlayer = useIntlayer;
+//# sourceMappingURL=useIntlayer.cjs.map

package/dist/cjs/useIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.cjs","names":["withInertOnChange","getIntlayer","resolveDictionaryArgument","getRequestLocale"],"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,qBAIAA,gDACEC,8BACE,SACAC,gEAA0B;CACxB;CACA,eAAeC,wCAAiB;CAChC,eAAe;AACjB,CAAC,CACH,CACF"}

package/dist/cjs/useLocale.cjs

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_requestStorage = require('./requestStorage.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+
+//#region src/useLocale.ts
+const { defaultLocale, locales: availableLocales } = _intlayer_config_built.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: require_requestStorage.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
+exports.useLocale = useLocale;
+//# sourceMappingURL=useLocale.cjs.map

package/dist/cjs/useLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.cjs","names":["internationalization","getRequestLocale"],"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,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;AAwBrD,MAAa,aAAa,SAAyB,CAAC,OAAwB;CAC1E,QAAQC,wCAAiB,KAAM;CAChB;CACG;CAClB,iBAAiB;EACf,QAAQ,KACN,4GACF;CACF;CACA,uBAAuB,CAAC;AAC1B"}

package/dist/cjs/withInertOnChange.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#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
+exports.withInertOnChange = withInertOnChange;
+//# sourceMappingURL=withInertOnChange.cjs.map

package/dist/cjs/withInertOnChange.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"withInertOnChange.cjs","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/esm/client/format/index.mjs

@@ -0,0 +1,3 @@
+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/esm/client/index.mjs

@@ -0,0 +1,3 @@
+import { getDictionary, getIntlayer, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage } from "vanilla-intlayer";
+
+export { getDictionary, getIntlayer, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage };