astro-intlayer 9.5.4 → 9.5.5

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,37 @@
+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.
+ *
+ * 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: ({ updateConfig, addMiddleware }: 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":";;;;;;;;;;;KAqCK,qBAAqB,WACxB,YAAY;KAGT,mBAAmB,WACtB,YAAY;;;;;;;;;;;;;;;qBAiBD,gBAAW,cAAA,iBAGrB,uBAAqB;;;;;;;qBAkDX,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,46 @@
+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.
+ *
+ * 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":";;;;;;YASY;;EAEV,QAAQ;;EAER,eAAe;;EAEf,kBAAkB;;QAGZ;YACI;cACE;MACR,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2BH,WAAW"}

package/dist/types/requestStorage.d.ts

@@ -0,0 +1,22 @@
+import { IntlayerLocals } from "./middleware.js";
+import { DeclaredLocales } from "@intlayer/types/module_augmentation";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/requestStorage.d.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.
+ */
+export declare const requestStorage: AsyncLocalStorage<{
+  intlayer?: IntlayerLocals;
+}>;
+/**
+ * Returns the Intlayer locals of the request being rendered, if any.
+ */
+export declare const getIntlayerLocals: () => IntlayerLocals | undefined;
+/**
+ * Returns the locale of the request being rendered, if any.
+ */
+export declare const getRequestLocale: () => DeclaredLocales | undefined;
+//#endregion
+//# sourceMappingURL=requestStorage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requestStorage.d.ts","names":[],"sources":["../../src/requestStorage.ts"],"mappings":";;;;;;;;;qBASa,gBAAc;EACd,WAAA;;;;;qBAMA,yBAAwB;;;;qBAMxB,wBAAuB"}

package/dist/types/useDictionary.d.ts

@@ -0,0 +1,29 @@
+import { DeepTransformContent, WithOnChange } from "vanilla-intlayer";
+import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
+import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent } from "@intlayer/types/dictionary";
+//#region src/useDictionary.d.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);
+ * ---
+ * ```
+ */
+export declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => WithOnChange<DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>>;
+//#endregion
+//# sourceMappingURL=useDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../src/useDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;qBA0Ca,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,aACD,qBACE,kCAAkC,GAAG,IACrC,sBAAsB"}

package/dist/types/useIntlayer.d.ts

@@ -0,0 +1,28 @@
+import { DeepTransformContent, WithOnChange } from "vanilla-intlayer";
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, DictionarySelectorForKey, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/useIntlayer.d.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>
+ * ```
+ */
+export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => WithOnChange<DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>>;
+//#endregion
+//# sourceMappingURL=useIntlayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../src/useIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;qBAuCa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,aACD,qBAAqB,yBAAyB,GAAG,IAAI,sBAAsB"}

package/dist/types/useLocale.d.ts

@@ -0,0 +1,29 @@
+import { UseLocaleProps, UseLocaleProps as UseLocaleProps$1, UseLocaleResult as UseLocaleResult$1 } from "vanilla-intlayer";
+//#region src/useLocale.d.ts
+export type UseLocaleResult = UseLocaleResult$1;
+/**
+ * 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}>
+ * ```
+ */
+export declare const useLocale: (_props?: UseLocaleProps$1) => UseLocaleResult;
+//#endregion
+export type { UseLocaleProps };
+//# sourceMappingURL=useLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../src/useLocale.ts"],"mappings":";;YAUY,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;qBA0BjB,YAAS,SAAY,qBAAsB"}

package/dist/types/withInertOnChange.d.ts

@@ -0,0 +1,12 @@
+import { WithOnChange } from "vanilla-intlayer";
+//#region src/withInertOnChange.d.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.
+ */
+export declare const withInertOnChange: <T>(content: T) => WithOnChange<T>;
+//#endregion
+//# sourceMappingURL=withInertOnChange.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withInertOnChange.d.ts","names":[],"sources":["../../src/withInertOnChange.ts"],"mappings":";;;;;;;;;qBASa,oBAAqB,GAAC,SAAW,MAAI,aAAa"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-intlayer",
-  "version": "9.5.4",
+  "version": "9.5.5",
   "private": false,
   "description": "Easily internationalize i18n your Astro applications with type-safe multilingual content management.",
   "keywords": [
@@ -41,9 +41,71 @@
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
+      "node": {
+        "require": "./dist/cjs/index.cjs",
+        "import": "./dist/esm/index.mjs"
+      },
+      "bun": {
+        "require": "./dist/cjs/index.cjs",
+        "import": "./dist/esm/index.mjs"
+      },
+      "deno": {
+        "require": "./dist/cjs/index.cjs",
+        "import": "./dist/esm/index.mjs"
+      },
+      "workerd": {
+        "require": "./dist/cjs/index.cjs",
+        "import": "./dist/esm/index.mjs"
+      },
+      "worker": {
+        "require": "./dist/cjs/index.cjs",
+        "import": "./dist/esm/index.mjs"
+      },
+      "edge-light": {
+        "require": "./dist/cjs/index.cjs",
+        "import": "./dist/esm/index.mjs"
+      },
+      "browser": {
+        "require": "./dist/cjs/client/index.cjs",
+        "import": "./dist/esm/client/index.mjs"
+      },
       "require": "./dist/cjs/index.cjs",
       "import": "./dist/esm/index.mjs"
     },
+    "./client": {
+      "types": "./dist/types/client/index.d.ts",
+      "require": "./dist/cjs/client/index.cjs",
+      "import": "./dist/esm/client/index.mjs"
+    },
+    "./integration": {
+      "types": "./dist/types/integration.d.ts",
+      "require": "./dist/cjs/integration.cjs",
+      "import": "./dist/esm/integration.mjs"
+    },
+    "./middleware": {
+      "types": "./dist/types/middleware.d.ts",
+      "require": "./dist/cjs/middleware.cjs",
+      "import": "./dist/esm/middleware.mjs"
+    },
+    "./format": {
+      "types": "./dist/types/format/index.d.ts",
+      "browser": {
+        "require": "./dist/cjs/client/format/index.cjs",
+        "import": "./dist/esm/client/format/index.mjs"
+      },
+      "require": "./dist/cjs/format/index.cjs",
+      "import": "./dist/esm/format/index.mjs"
+    },
+    "./html": {
+      "types": "./dist/types/html/index.d.ts",
+      "require": "./dist/cjs/html/index.cjs",
+      "import": "./dist/esm/html/index.mjs"
+    },
+    "./markdown": {
+      "types": "./dist/types/markdown/index.d.ts",
+      "require": "./dist/cjs/markdown/index.cjs",
+      "import": "./dist/esm/markdown/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "main": "dist/cjs/index.cjs",
@@ -51,8 +113,26 @@
   "types": "dist/types/index.d.ts",
   "typesVersions": {
     "*": {
+      "client": [
+        "./dist/types/client/index.d.ts"
+      ],
+      "format": [
+        "./dist/types/format/index.d.ts"
+      ],
+      "html": [
+        "./dist/types/html/index.d.ts"
+      ],
+      "markdown": [
+        "./dist/types/markdown/index.d.ts"
+      ],
+      "middleware": [
+        "./dist/types/middleware.d.ts"
+      ],
       "package.json": [
         "./package.json"
+      ],
+      "integration": [
+        "./dist/types/integration.d.ts"
       ]
     }
   },
@@ -79,13 +159,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.5.4",
-    "@intlayer/core": "9.5.4",
-    "@intlayer/engine": "9.5.4",
-    "@intlayer/types": "9.5.4",
-    "vite-intlayer": "9.5.4"
+    "@intlayer/config": "9.5.5",
+    "@intlayer/core": "9.5.5",
+    "@intlayer/engine": "9.5.5",
+    "@intlayer/types": "9.5.5",
+    "vanilla-intlayer": "9.5.5",
+    "vite-intlayer": "9.5.5"
   },
   "devDependencies": {
+    "@intlayer/dictionaries-entry": "9.5.5",
     "@types/node": "^22",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",