vite-intlayer 9.3.1 → 9.3.3

package/dist/types/intlayerChunkPlugin.d.ts

@@ -0,0 +1,88 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Plugin } from "vite";
+//#region src/intlayerChunkPlugin.d.ts
+/**
+ * Module-graph accessor Rolldown passes to a chunk-name function.
+ *
+ * Declared structurally rather than imported from `rolldown` so this plugin
+ * keeps working against the Rolldown bundled inside Vite, whose types are not
+ * re-exported.
+ */
+type ChunkingContext = {
+  getModuleInfo: (moduleId: string) => ModuleGraphNode | null;
+};
+type ModuleGraphNode = {
+  id: string;
+  isEntry: boolean;
+  /** Ids of the modules that statically `import` this one. */
+  importers: string[];
+  /** Ids of the modules that reach this one through `import()`. */
+  dynamicImporters: string[];
+};
+/** A per-locale dictionary chunk, identified from its module id. */
+type DictionaryModule = {
+  key: string;
+  locale: string;
+};
+/**
+ * Builds the parser that recognises a per-locale dictionary chunk emitted in
+ * `dynamic` import mode.
+ *
+ * The layout is read relative to `dynamicDictionariesDir` rather than matched
+ * anywhere in the path, so an application file that happens to sit under its own
+ * `json/<something>/<something>.json` cannot be mistaken for a dictionary.
+ * Everything between the key and the locale is a qualifier dimension
+ * (collections, variants), which is why the middle segments are skipped instead
+ * of being required to be absent.
+ *
+ * @param dynamicDictionariesDir - Absolute, POSIX-normalized dictionaries root.
+ * @returns Parser returning the key and locale, or `null` for any other module.
+ */
+declare const createDictionaryModuleParser: (dynamicDictionariesDir: string) => ((moduleId: string) => DictionaryModule | null);
+/** Turns a boundary module id into a readable chunk-name fragment. */
+declare const toBoundaryName: (moduleId: string) => string;
+/**
+ * Walks up the import graph from a dictionary JSON to the code-split boundaries
+ * that reach it.
+ *
+ * A module pulled in through `import()` — a `React.lazy` section, a split
+ * route — begins its own chunk, so it is the unit whose dictionaries should
+ * travel together: one request per Suspense boundary rather than one per
+ * dictionary. The walk deliberately starts from the JSON's importers rather
+ * than the JSON itself, because *every* dictionary is reached through
+ * `import()` and would otherwise be read as its own boundary.
+ *
+ * @returns Boundary ids reaching this dictionary, empty when the graph is
+ *          unavailable (the module was pruned, or resolution failed).
+ */
+declare const resolveBoundaries: (jsonModuleId: string, context: ChunkingContext) => string[];
+/**
+ * Groups dynamically imported dictionaries by the code-split boundary that
+ * consumes them, so each lazily loaded page or section fetches its content in
+ * a single request instead of one per dictionary.
+ *
+ * Without this, `importMode: 'dynamic'` emits a chunk per dictionary per
+ * locale. A page assembled from many components then issues dozens of ~3 KB
+ * requests, and because each is discovered only once its consumer has
+ * executed, they land in the last wave of the request waterfall — page text
+ * arrives after everything else.
+ *
+ * Switching to `importMode: 'static'` would collapse those requests but inline
+ * every locale into the bundle, which does not scale past a handful of
+ * languages. Grouping keeps the per-locale split and removes the fragmentation.
+ *
+ * Dictionaries reached from more than one boundary are placed in a shared
+ * chunk, so no page ships another page's content and the bytes are not
+ * duplicated across chunks.
+ *
+ * Because a boundary's dictionaries share one chunk, warming that chunk warms
+ * the whole boundary in a single request — which is why the top-level-await
+ * preload (`intlayerPreload`) costs one request per boundary rather than one
+ * per dictionary, without any page loading content belonging to another.
+ *
+ * @param intlayerConfig - Resolved Intlayer configuration.
+ */
+declare const intlayerChunk: (intlayerConfig: IntlayerConfig) => Plugin;
+//#endregion
+export { ChunkingContext, DictionaryModule, ModuleGraphNode, createDictionaryModuleParser, intlayerChunk, resolveBoundaries, toBoundaryName };
+//# sourceMappingURL=intlayerChunkPlugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intlayerChunkPlugin.d.ts","names":[],"sources":["../../src/intlayerChunkPlugin.ts"],"mappings":";;;;;;;;;;KAaY;EACV,gBAAgB,qBAAqB;;KAG3B;EACV;EACA;;EAEA;;EAEA;;;KAIU;EACV;EACA;;;;;;;;;;;;;;;;cAiBW,+BAA4B,qCAEpC,qBAAqB;;cAuCb,iBAAc;;;;;;;;;;;;;;;cAuBd,oBAAiB,sBACR,SACX;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyDE,gBAAa,gBAAoB,mBAAiB"}

package/dist/types/intlayerNitroHandler.d.ts

@@ -40,7 +40,7 @@ type H3EventLike = {
  * and Deno — where `event.node` is `undefined` and `fromNodeMiddleware` crashes with
  * "undefined is not an object (evaluating 'event.node.req')".
  *
- * It bridges h3 v2 events to the Node.js-style `createIntlayerProxyHandler` middleware
+ * It bridges h3 v2 events to the Node.js-style proxy middleware
  * via lightweight IncomingMessage / ServerResponse shims:
  *
  * - **Redirect** (301 / 5xx): builds a Web API `Response` and returns it — Nitro sends

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerNitroHandler.d.ts","names":[],"sources":["../../src/intlayerNitroHandler.ts"],"mappings":";;;;;;;;;KAcK;;;;;WAKM;;;;;;EAMT,KAAK;;;;;WAKI,SAAS;;;;;WAKT;aACE,SAAS;;;;;;;;;;;;;;;;;;;;;;iBAmCA,SAAA,OAAO,cAAc,QAAQ"}
+{"version":3,"file":"intlayerNitroHandler.d.ts","names":[],"sources":["../../src/intlayerNitroHandler.ts"],"mappings":";;;;;;;;;KAyBK;;;;;WAKM;;;;;;EAMT,KAAK;;;;;WAKI,SAAS;;;;;WAKT;aACE,SAAS;;;;;;;;;;;;;;;;;;;;;;iBAmCA,SAAA,OAAO,cAAc,QAAQ"}

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerPlugin.d.ts","names":[],"sources":["../../src/intlayerPlugin.ts"],"mappings":";;;;;;;;;;;;;;KAyCY,wBAAwB;;;;;;;;EAQlC,gBAAgB;;;;;;;;;;;;;;;EAgBhB,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;cA0BF,iBAAc,gBACT,0BACf;;;;;;;;;;;cAuNU,iBAAQ;;;;;;;;;;;;;cAaR,uBAAc"}
+{"version":3,"file":"intlayerPlugin.d.ts","names":[],"sources":["../../src/intlayerPlugin.ts"],"mappings":";;;;;;;;;;;;;;KA2CY,wBAAwB;;;;;;;;EAQlC,gBAAgB;;;;;;;;;;;;;;;EAgBhB,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;cA0BF,iBAAc,gBACT,0BACf;;;;;;;;;;;cAgOU,iBAAQ;;;;;;;;;;;;;cAaR,uBAAc"}

package/dist/types/intlayerPreloadPlugin.d.ts

@@ -0,0 +1,34 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Plugin } from "vite";
+//#region src/intlayerPreloadPlugin.d.ts
+/**
+ * Makes dictionaries load with the chunk that needs them, instead of being
+ * requested once that chunk renders.
+ *
+ * In `importMode: 'dynamic'` a component reads its dictionary through a loader
+ * map and suspends while the matching chunk is fetched. The fetch is only
+ * discovered once the component executes, so it lands at the very end of the
+ * request waterfall and every navigation flashes the pending fallback before
+ * any text appears — the cost that used to push applications towards
+ * `importMode: 'static'`, which inlines every locale into the bundle.
+ *
+ * Starting that fetch from the generated entry point itself moves it forward to
+ * module-evaluation time: it leaves with the chunk that needs it — on a
+ * router's `import()` of a route, including a preload on hover — instead of
+ * waiting for the consuming component to execute. By the time the read happens
+ * the content is usually already there and the render is synchronous.
+ *
+ * The fetch is deliberately not awaited at the top level. Doing so would make
+ * the entry point an async module and hold up every chunk that imports it,
+ * which permanently strands `React.lazy` boundaries resolving during hydration
+ * on their fallback — see `addDynamicEntryPreload`.
+ *
+ * Complements the grouping in `intlayerChunk`: grouping decides how many
+ * requests a boundary makes, this decides when they start.
+ *
+ * @param intlayerConfig - Resolved Intlayer configuration.
+ */
+declare const intlayerPreload: (intlayerConfig: IntlayerConfig) => Plugin;
+//#endregion
+export { intlayerPreload };
+//# sourceMappingURL=intlayerPreloadPlugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intlayerPreloadPlugin.d.ts","names":[],"sources":["../../src/intlayerPreloadPlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDa,kBAAe,gBAAoB,mBAAiB"}

package/dist/types/intlayerProxyHandler.d.ts

@@ -0,0 +1,50 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { IncomingMessage, ServerResponse } from "node:http";
+//#region src/intlayerProxyHandler.d.ts
+/**
+ * A Node.js-compatible Connect middleware function.
+ * Compatible with Vite dev/preview server, Node.js http, Express, and h3's
+ * `fromNodeMiddleware` wrapper for Nitro/TanStack Start production use.
+ */
+type NodeMiddleware = (req: IncomingMessage, res: ServerResponse<IncomingMessage>, next: () => void) => void;
+type IntlayerProxyHandlerOptions = {
+  /**
+   * The resolved Intlayer configuration driving locale detection and routing.
+   */
+  configuration: IntlayerConfig;
+  /**
+   * A function that allows you to ignore specific requests from the intlayer proxy.
+   *
+   * @param req - The incoming request.
+   * @returns A boolean value indicating whether to ignore the request.
+   */
+  ignore?: (req: IncomingMessage) => boolean | undefined;
+  /**
+   * Whether a development or preview server is serving the app.
+   *
+   * It only matters in the proxy's auto mode, where a dev server keeps locale
+   * routing URL-driven by ignoring the stored locale as a redirect source.
+   *
+   * @default false
+   */
+  isDevServer?: boolean;
+};
+/**
+ * Creates the locale-routing middleware from an already-resolved configuration.
+ *
+ * This is the runtime core shared by every environment - dev server, preview
+ * server and the production Nitro server. It deliberately receives the
+ * configuration instead of loading it: loading it would pull
+ * `@intlayer/config/node` - and therefore `esbuild` - into the server bundle,
+ * which then fails to boot wherever `node_modules` is not shipped next to the
+ * build output.
+ *
+ * @param options - The resolved configuration plus optional handler behaviour.
+ * @returns A Connect-compatible `(req, res, next) => void` middleware.
+ *
+ * @see `createIntlayerProxyHandler` for the public, configuration-loading entry point.
+ */
+declare const createProxyHandler: (options: IntlayerProxyHandlerOptions) => NodeMiddleware;
+//#endregion
+export { IntlayerProxyHandlerOptions, NodeMiddleware, createProxyHandler };
+//# sourceMappingURL=intlayerProxyHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intlayerProxyHandler.d.ts","names":[],"sources":["../../src/intlayerProxyHandler.ts"],"mappings":";;;;;;;;KAyEY,kBACV,KAAK,iBACL,KAAK,eAAe,kBACpB;KAGU;;;;EAIV,eAAe;;;;;;;EAOf,UAAU,KAAK;;;;;;;;;EASf;;;;;;;;;;;;;;;;;cAkBW,qBAAkB,SACpB,gCACR"}

package/dist/types/intlayerProxyPlugin.d.ts

@@ -1,6 +1,7 @@
+import { NodeMiddleware } from "./intlayerProxyHandler.js";
 import { GetConfigurationOptions } from "@intlayer/config/node";
 import { Plugin } from "vite";
-import { IncomingMessage, ServerResponse } from "node:http";
+import { IncomingMessage } from "node:http";
 //#region src/intlayerProxyPlugin.d.ts
 type IntlayerProxyPluginOptions = {
   /**
@@ -43,18 +44,11 @@ type IntlayerProxyPluginOptions = {
    */
   isDevServer?: boolean;
 };
-/**
- * A Node.js-compatible Connect middleware function.
- * Compatible with Vite dev/preview server, Node.js http, Express, and h3's
- * `fromNodeMiddleware` wrapper for Nitro/TanStack Start production use.
- */
-type NodeMiddleware = (req: IncomingMessage, res: ServerResponse<IncomingMessage>, next: () => void) => void;
 /**
  * Creates a standalone, framework-agnostic locale-routing middleware.
  *
- * This function contains all the locale detection, redirect, and rewrite logic.
- * It is intentionally separated from the Vite plugin so the same handler can be
- * used in every environment:
+ * It loads the Intlayer configuration and hands it to the runtime handler in
+ * `intlayerProxyHandler`, so it can be used in every environment:
  *
  * - **Dev**: wired up automatically by `intlayerProxy` via `configureServer`
  * - **Preview**: wired up automatically by `intlayerProxy` via `configurePreviewServer`
@@ -71,7 +65,6 @@ type NodeMiddleware = (req: IncomingMessage, res: ServerResponse<IncomingMessage
  *
  * @param options - Plugin-specific options, such as path ignoring and Intlayer configuration overrides.
  * @returns A Connect-compatible `(req, res, next) => void` middleware.
- *
  */
 declare const createIntlayerProxyHandler: (options?: IntlayerProxyPluginOptions) => NodeMiddleware;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerProxyPlugin.d.ts","names":[],"sources":["../../src/intlayerProxyPlugin.ts"],"mappings":";;;;KA0EY;;;;;;;;;;;;;;EAcV,UAAU,KAAK;;;;;;;;;;;EAWf,gBAAgB;;;;;;;;;;;;;;EAchB;;;;;;;KAQG,kBACH,KAAK,iBACL,KAAK,eAAe,kBACpB;;;;;;;;;;;;;;;;;;;;;;;;;cA2BW,6BAA0B,UAC3B,+BACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA27BU,gBAAa,UAAc,+BAA6B;;;;;;;;;;;;;cAuIxD,2BAAkB;;;;;;;;;;;;;cAclB,iCAAwB"}
+{"version":3,"file":"intlayerProxyPlugin.d.ts","names":[],"sources":["../../src/intlayerProxyPlugin.ts"],"mappings":";;;;;KA6BY;;;;;;;;;;;;;;EAcV,UAAU,KAAK;;;;;;;;;;;EAWf,gBAAgB;;;;;;;;;;;;;;EAchB;;;;;;;;;;;;;;;;;;;;;;;;cAyBW,6BAA0B,UAC3B,+BACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgDU,gBAAa,UAAc,+BAA6B;;;;;;;;;;;;;cAuIxD,2BAAkB;;;;;;;;;;;;;cAclB,iCAAwB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-intlayer",
-  "version": "9.3.1",
+  "version": "9.3.3",
   "private": false,
   "description": "A Vite plugin for seamless internationalization (i18n), providing locale detection, redirection, and environment-based configuration",
   "keywords": [
@@ -81,12 +81,12 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/babel": "9.3.1",
-    "@intlayer/config": "9.3.1",
-    "@intlayer/core": "9.3.1",
-    "@intlayer/dictionaries-entry": "9.3.1",
-    "@intlayer/engine": "9.3.1",
-    "@intlayer/types": "9.3.1"
+    "@intlayer/babel": "9.3.2",
+    "@intlayer/config": "9.3.3",
+    "@intlayer/core": "9.3.3",
+    "@intlayer/dictionaries-entry": "9.3.3",
+    "@intlayer/engine": "9.3.2",
+    "@intlayer/types": "9.3.3"
   },
   "devDependencies": {
     "@types/node": "26.2.0",
@@ -96,12 +96,12 @@
     "rimraf": "6.1.3",
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   },
   "peerDependencies": {
     "@babel/core": ">=6.0.0",
-    "@intlayer/svelte-compiler": "9.3.1",
-    "@intlayer/vue-compiler": "9.3.1",
+    "@intlayer/svelte-compiler": "9.3.3",
+    "@intlayer/vue-compiler": "9.3.3",
     "h3": ">=1.0.0",
     "vite": ">=4.0.0"
   },