@intlayer/docs 9.0.0-canary.6 → 9.0.0-canary.7

package/docs/en/packages/vite-intlayer/intlayer.md

@@ -1,31 +1,35 @@
 ---
 createdAt: 2026-01-21
-updatedAt: 2026-01-21
+updatedAt: 2026-06-25
 title: intlayer Vite Plugin Documentation | vite-intlayer
-description: See how to use the intlayer plugin for vite-intlayer package
+description: Complete guide to the intlayer() Vite plugin – dictionary preparation, aliases, dev watcher, locale-routing proxy, and compiler.
 keywords:
   - intlayer
   - vite
   - plugin
-  - Intlayer
-  - intlayer
-  - Internationalization
-  - Documentation
+  - proxy
+  - compiler
+  - internationalization
+  - i18n
+  - routing
 slugs:
   - doc
   - packages
   - vite-intlayer
   - intlayer
 history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Proxy and compiler bundled into intlayer(); added proxy option, compatCallers, routing.enableProxy"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Init doc"
 author: aymericzip
 ---
 
-# intlayer Vite Plugin Documentation
+# intlayer Vite Plugin
 
-The `intlayer` Vite plugin integrates Intlayer configuration into the build process. It handles dictionary aliases, starts the dictionary watcher in development mode, and prepares dictionaries for the build.
+The `intlayer` plugin is the single entry-point for integrating Intlayer into a Vite application. Register it once and everything works out of the box: dictionary compilation, module aliases, dev-server watching, locale-routing middleware, and production build optimisations.
 
 ## Usage
 
@@ -39,11 +43,126 @@ export default defineConfig({
 });
 ```
 
-## Description
+## Options
+
+```ts
+import type { IntlayerPluginOptions } from "vite-intlayer";
+```
+
+`IntlayerPluginOptions` extends `GetConfigurationOptions` (see `@intlayer/config`) with the following additional fields:
+
+| Option          | Type                            | Default     | Description                                                                                                                           |
+| --------------- | ------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `compatCallers` | `CompatCallerConfig[]`          | `[]`        | Extra caller patterns for compat-adapter packages (e.g. `@intlayer/react-i18next`). Passed to the field-usage analyser at build time. |
+| `proxy`         | `{ ignore?: (req) => boolean }` | `undefined` | Options forwarded to the bundled locale-routing proxy. Use `ignore` to exclude specific paths (e.g. API routes) from locale routing.  |
+
+All other options (`override`, `configFile`, …) are forwarded directly to `getConfiguration()`.
+
+### Examples
+
+#### Ignore API routes from locale routing
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+#### With a custom config file path
+
+```ts
+export default defineConfig({
+  plugins: [
+    intlayer({
+      configFile: "./config/intlayer.config.ts",
+    }),
+  ],
+});
+```
+
+#### With compat-adapter callers
+
+```ts
+import { intlayer } from "vite-intlayer";
+import { reactI18nextCallerConfig } from "@intlayer/react-i18next/plugin";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      compatCallers: [reactI18nextCallerConfig],
+    }),
+  ],
+});
+```
+
+## What the plugin does
+
+### 1. Dictionary preparation
+
+Before the build starts (and once per hour in dev), `intlayer` calls `prepareIntlayer` to compile all `.content.ts` files into optimised JSON dictionaries stored in `.intlayer/`.
+
+### 2. Module aliases
+
+The plugin adds Vite resolve aliases so that `import { myDict } from 'intlayer/dictionaries/my-dict'` resolves to the compiled JSON file on disk. SSR builds use `ssr.noExternal` to ensure all `@intlayer/*` packages are bundled with aliases applied.
+
+### 3. Dev-server watcher
+
+In development mode a `chokidar` watcher is started. When a `.content.ts` file changes the dictionaries are recompiled and Vite's HMR propagates the update to the browser.
+
+### 4. Bundled locale-routing proxy (v9+)
+
+Since Intlayer v9 the `intlayerProxy` middleware is registered automatically inside `intlayer()`. It handles:
+
+- Locale detection from URL prefix, cookies, and `Accept-Language` header.
+- 301 redirects when the detected locale does not match the current URL.
+- Internal URL rewrites so the framework sees the correct `[locale]` route parameter.
+
+The proxy is controlled by `routing.enableProxy` (default `true`) in your Intlayer config. To disable it completely:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  routing: { enableProxy: false },
+});
+```
+
+To customise proxy behaviour without a separate `intlayerProxy()` call, pass `proxy` options to the main plugin:
+
+```ts
+intlayer({ proxy: { ignore: (req) => req.url?.startsWith("/api") } });
+```
+
+See the [intlayerProxy documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerProxy.md) for the full routing behaviour reference.
+
+### 5. Bundled compiler (v9+)
+
+When `compiler.enabled` is `true` **and** `compiler.output` is set in your Intlayer config, `intlayer()` registers `intlayerCompiler` automatically. The compiler extracts inline content declarations written directly inside component files and writes them to dictionaries at transform time. See [intlayerCompiler documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerCompiler.md).
+
+### 6. Build optimisations
+
+During a production build the plugin adds:
+
+- **intlayerOptimize** – Babel transform that rewrites `useIntlayer('key')` → `useDictionary(hash)` and injects direct JSON imports.
+- **intlayerPrune** – removes unused content fields from dictionary JSON.
+- **intlayerMinify** – compacts dictionary JSON and optionally mangles field names.
+
+These are inactive in development mode.
 
-The plugin performs the following tasks:
+## Deprecated aliases
 
-1. **Prepare Dictionaries**: It compiles the dictionaries into optimized files at the start of the build or dev process.
-2. **Watch Mode**: In development mode, it watches for changes in dictionary files and recompiles them automatically.
-3. **Aliases**: it provides aliases for accessing the dictionaries in your application.
-4. **Tree-shaking**: it supports tree-shaking unused translations through the `intlayerPrune` plugin.
+| Deprecated export | Replacement |
+| ----------------- | ----------- |
+| `intlayerPlugin`  | `intlayer`  |
+| `intLayerPlugin`  | `intlayer`  |

package/docs/en/packages/vite-intlayer/intlayerCompiler.md

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: intlayerCompiler Vite Plugin Documentation | vite-intlayer
+description: Vite plugin that extracts inline Intlayer content declarations from component files and writes them to dictionary JSON files at build/transform time.
+keywords:
+  - intlayerCompiler
+  - vite
+  - plugin
+  - compiler
+  - content
+  - dictionary
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Bundled into intlayer(); init doc"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+`intlayerCompiler` is a Vite plugin that scans component source files for **inline Intlayer content declarations** — content defined directly inside a component rather than in a separate `.content.ts` file — and writes them to dictionary JSON files during the transform phase.
+
+> **Since Intlayer v9** `intlayerCompiler` is automatically included inside the main [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md) plugin when both `compiler.enabled` is `true` and `compiler.output` is set in your Intlayer config. You only need to register it separately when you want full control over compiler-specific configuration.
+
+## Usage
+
+### As part of `intlayer()` (recommended, v9+)
+
+Enable the compiler through your Intlayer config:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // where extracted dictionaries are written
+  },
+});
+```
+
+Then use the standard plugin with no extra registration:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Standalone (when needed)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Options
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Option           | Type                      | Description                                                                                 |
+| ---------------- | ------------------------- | ------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Intlayer configuration overrides forwarded to `getConfiguration()`.                         |
+| `compilerConfig` | `Partial<CompilerConfig>` | Overrides for the compiler-specific config section (e.g. `enabled`, `output`, `filesList`). |
+
+### Example
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## How it works
+
+### Transform phase
+
+For every source file that matches `compiler.filesList`, the compiler plugin:
+
+1. Passes the file content through `extractContent` from `@intlayer/babel`.
+2. Calls `onExtract` for each declaration found, which writes the resulting dictionary JSON to `compiler.output`.
+3. Returns the transformed source code with inline declarations replaced by standard `useIntlayer('key')` / `getIntlayer('key')` calls.
+
+Supported file types: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+When a component file is saved in development mode, the compiler:
+
+1. Detects the file change via Vite's `handleHotUpdate` hook.
+2. Re-extracts content from the updated file.
+3. Writes the updated dictionary JSON.
+4. Triggers a full page reload (`server.ws.send({ type: 'full-reload' })`).
+
+A 500 ms debounce prevents the dictionary write itself (which also triggers a file-change event) from causing an infinite re-extraction loop.
+
+### Deduplication
+
+`intlayerCompiler` uses the same `createPrimaryInstanceGuard` deduplication mechanism as the other bundled plugins. When both `intlayer()` (which bundles the compiler) and a manual `intlayerCompiler()` call are present, only the first registered instance runs — no dictionaries are written twice.

package/docs/en/packages/vite-intlayer/intlayerMinify.md

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: intlayerMinify Vite Plugin Documentation | vite-intlayer
+description: Vite plugin that minifies compiled Intlayer dictionary JSON files and optionally mangles content field names to reduce bundle size.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minify
+  - bundle size
+  - dictionary
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Init doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` is a Vite plugin that minifies compiled dictionary JSON files during a production build. It strips all unnecessary whitespace and, when combined with `intlayerPrune`, optionally renames content field names to short alphabetic aliases (`a`, `b`, `c`, …) to further reduce bundle size.
+
+> The plugin is already included and configured automatically when you use [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md). You only need to register it manually if you are composing the plugin stack yourself.
+
+## Usage
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Activation conditions
+
+`intlayerMinify` is active **only** when all three of the following are true:
+
+1. The Vite command is `build` (not `serve` / dev).
+2. `build.optimize` is `true` (or `undefined`, which defaults to `true` for builds).
+3. `build.minify` is `true` in your Intlayer config.
+
+It is automatically **disabled** when `editor.enabled` is `true` because the editor needs the full, human-readable dictionary content.
+
+## What gets minified
+
+The plugin targets two dictionary locations (as resolved from `intlayer.system`):
+
+- `dictionariesDir` — static all-locale dictionaries (e.g. `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — per-locale dynamic dictionaries
+
+> Fetch-mode dictionaries (`fetchDictionariesDir`) are **never** minified because they are served from a remote API at runtime using their original field names. Renaming fields would create a mismatch between the server response and client-side property accesses.
+
+## Field-name mangling (property minification)
+
+When `intlayerPrune` has analysed the codebase and populated `pruneContext.dictionaryKeyToFieldRenameMap`, `intlayerMinify` also renames content field names to short aliases. For example:
+
+```json
+// before
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// after (with mangling)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+The corresponding source-file property accesses are renamed by the Babel pass inside `intlayerOptimize`, so runtime behaviour is unchanged.
+
+Internal Intlayer fields (`nodeType`, `translation`, etc.) are never renamed.
+
+## Edge-case dictionaries
+
+Dictionaries flagged in `pruneContext.dictionariesWithEdgeCases` (structural anomalies detected during the prune phase) are skipped entirely — neither minified nor mangled — to avoid shipping broken data.
+
+## Qualified groups (collections / variants / meta records)
+
+For dictionaries with a `qualifierTypes` array (collections, variants, and meta records), the plugin preserves the `qualifierTypes` array and the `meta` side-map verbatim. Only the `content` entries have their field names mangled. The composite keys (used for selector matching at runtime) are never touched.

package/docs/en/packages/vite-intlayer/intlayerProxy.md

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: intlayerProxy Vite Plugin Documentation | vite-intlayer
+description: Locale-routing middleware for Vite dev/preview servers and production SSR. Handles locale detection, URL redirects, and internal rewrites.
+keywords:
+  - intlayerProxy
+  - vite
+  - plugin
+  - middleware
+  - locale
+  - routing
+  - internationalization
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Merged configOptions into single options object; proxy bundled into intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+`intlayerProxy` is a Vite plugin that registers locale-routing middleware for **every environment**: dev server, preview server, and production SSR (Nitro / TanStack Start).
+
+> **Since Intlayer v9** `intlayerProxy` is automatically included inside the main [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md) plugin and enabled by default via `routing.enableProxy: true`. You only need to register it separately if you need lower-level control or are using it outside the standard `intlayer()` setup.
+
+## Usage
+
+### As part of `intlayer()` (recommended, v9+)
+
+Pass `proxy` options to the main plugin instead of registering `intlayerProxy` separately:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+### Standalone (when needed)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Options
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+All options are optional and passed as a single object:
+
+| Option          | Type                                | Description                                                                                                                                        |
+| --------------- | ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Predicate that excludes requests from locale routing. Return `true` to skip a request (e.g. API routes, health checks).                            |
+| `configOptions` | `GetConfigurationOptions`           | Intlayer configuration overrides forwarded to `getConfiguration()`. Use when you need the proxy to read a specific config file or override values. |
+
+### Example
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+`createIntlayerProxyHandler` creates a standalone, framework-agnostic Node.js `(req, res, next)` middleware that contains all the locale-routing logic. It is useful in environments where the Vite plugin API is unavailable (e.g. a plain Node.js server or a custom Nitro module).
+
+```ts
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+const handler = createIntlayerProxyHandler({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+
+// Express / Connect
+app.use(handler);
+```
+
+### Production SSR (TanStack Start / Nitro via h3)
+
+```ts
+// server/middleware/intlayerProxy.ts
+import { fromNodeMiddleware } from "h3";
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+export default fromNodeMiddleware(
+  createIntlayerProxyHandler({
+    ignore: (req) => req.url?.startsWith("/api"),
+  })
+);
+```
+
+## Routing behaviour
+
+The middleware mirrors the routing logic from `next-intlayer` middleware and supports all Intlayer routing modes.
+
+### Routing modes
+
+| Mode            | URL visible in browser   | Behaviour                                                                                               |
+| --------------- | ------------------------ | ------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/en/about`              | Default. Locale prefix in the URL. Default locale redirects to the un-prefixed URL unless `prefix-all`. |
+| `prefix-all`    | `/en/about`, `/fr/about` | All locales — including default — are always prefixed.                                                  |
+| `no-prefix`     | `/about`                 | No locale in the URL. Locale is stored in cookies only; URL rewrites happen internally.                 |
+| `search-params` | `/about?locale=en`       | Locale passed as a query parameter. Redirects to add/update the `locale` param when missing or stale.   |
+
+### Detection priority
+
+1. URL path prefix (e.g. `/fr/about` → `fr`).
+2. Cookie / localStorage value (`intlayer-locale`).
+3. `Accept-Language` header.
+4. `defaultLocale` from config.
+
+### Automatic bypass
+
+The middleware always passes these requests straight through without locale handling:
+
+- Requests matching the `ignore` predicate.
+- `/node_modules/**`
+- `/@**` – Vite internals (`@vite/`, `@fs/`, `@id/`, etc.).
+- `/_**` – server internals (`__vite_ping`, `__manifest`, etc.).
+- Requests whose path ends with a file extension (static assets). If a locale prefix is present on a static asset path (e.g. `/fr/logo.png`), it is stripped so the file can be served correctly.
+
+### Domain routing
+
+When `routing.domains` is configured in your Intlayer config, the middleware handles cross-domain locale routing:
+
+- A request for `/zh/about` on `intlayer.org` is redirected to `https://intlayer.zh/about` when `domains.zh = "intlayer.zh"`.
+- A request to `intlayer.zh/about` is rewritten internally to `/zh/about` so the `[locale]` route parameter is populated.
+
+### Redirect loop protection
+
+The middleware tracks redirect counts per `originalUrl → newUrl` pair within a 2-second sliding window. More than 10 redirects within that window returns a `500` response with a descriptive error instead of looping forever.
+
+## Nitro / production SSR (automatic injection, v9+)
+
+When `intlayerProxy` is used as a Vite plugin, it carries a `.nitro` property. The `nitro/vite` build plugin reads this property and pushes it into `nitroConfig.modules`, so `intlayerNitroHandler` is registered as a Nitro server middleware automatically — no manual configuration is needed for production SSR.
+
+The Nitro handler uses h3 v2's Web Fetch API event model (not `fromNodeMiddleware`) so it is compatible with all Nitro presets: Node, Bun, Deno, edge runtimes.
+
+## Deprecated aliases
+
+| Deprecated export          | Replacement     |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |