vite-intlayer 8.12.1 → 8.12.3

package/dist/types/index.d.ts

@@ -2,6 +2,6 @@ import { IntlayerCompilerOptions, intlayerCompiler } from "./IntlayerCompilerPlu
 import { intlayerMinify } from "./intlayerMinifyPlugin.js";
 import { intlayerOptimize } from "./intlayerOptimizePlugin.js";
 import { intLayerPlugin, intlayer, intlayerPlugin } from "./intlayerPlugin.js";
-import { intLayerMiddlewarePlugin, intlayerMiddleware, intlayerProxy } from "./intlayerProxyPlugin.js";
+import { createIntlayerProxyHandler, intLayerMiddlewarePlugin, intlayerMiddleware, intlayerProxy } from "./intlayerProxyPlugin.js";
 import { intlayerPrune } from "./intlayerPrunePlugin.js";
-export { IntlayerCompilerOptions, intLayerMiddlewarePlugin, intLayerPlugin, intlayer, intlayerCompiler, intlayerMiddleware, intlayerMinify, intlayerOptimize, intlayerPlugin, intlayerProxy, intlayerPrune };
+export { IntlayerCompilerOptions, createIntlayerProxyHandler, intLayerMiddlewarePlugin, intLayerPlugin, intlayer, intlayerCompiler, intlayerMiddleware, intlayerMinify, intlayerOptimize, intlayerPlugin, intlayerProxy, intlayerPrune };

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerMinifyPlugin.d.ts","names":[],"sources":["../../src/intlayerMinifyPlugin.ts"],"mappings":";;;;;;;AAiIA;;;;;;;;;;;;;;AAGe;;;;;;;;;;;;;;;;cAHF,cAAA,GACX,cAAA,EAAgB,cAAA,EAChB,YAAA,EAAc,YAAA,YACb,YAAA"}
+{"version":3,"file":"intlayerMinifyPlugin.d.ts","names":[],"sources":["../../src/intlayerMinifyPlugin.ts"],"mappings":";;;;;;;AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,GACX,cAAA,EAAgB,cAAA,EAChB,YAAA,EAAc,YAAA,YACb,YAAA"}

package/dist/types/intlayerNitroHandler.d.ts

@@ -0,0 +1,57 @@
+//#region src/intlayerNitroHandler.d.ts
+/**
+ * Minimal duck-type for h3 v2's H3Event.
+ *
+ * We intentionally avoid importing from 'h3' to keep this file runtime-agnostic —
+ * Nitro bundles h3 internally and provides the populated event at runtime. Using a
+ * structural type here means the file compiles without h3 in devDependencies and
+ * works with any h3 v2-compatible runtime (Bun, Deno, Node).
+ */
+type H3EventLike = {
+  /**
+   * pathname + search — a computed getter on H3Event:
+   * `return this.url.pathname + this.url.search`
+   */
+  readonly path: string;
+  /**
+   * Full URL object — a **plain property** (not a getter) on H3Event, safe to
+   * replace for internal URL rewrites. After assignment, `event.path` will
+   * automatically reflect the new pathname + search via the getter.
+   */
+  url: URL;
+  /**
+   * Web Fetch API Headers — always populated in h3 v2 regardless of preset
+   * (Node, Bun, Deno). Use `.get(name)` instead of bracket-access.
+   */
+  readonly headers: Headers;
+  /**
+   * Lazy response object — created on first access; its `headers` carry outgoing
+   * response headers (e.g. Set-Cookie) that h3 merges into the HTTP response.
+   */
+  readonly res: {
+    readonly headers: Headers;
+  };
+};
+/**
+ * Native h3 v2 event handler for Nitro production servers (TanStack Start, Nuxt, etc.).
+ *
+ * Unlike `fromNodeMiddleware` (h3 v1 API), this handler uses the Web Fetch API event
+ * model exclusively and is therefore compatible with ALL Nitro presets — including Bun
+ * 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
+ * via lightweight IncomingMessage / ServerResponse shims:
+ *
+ * - **Redirect** (301 / 5xx): builds a Web API `Response` and returns it — Nitro sends
+ *   the correct HTTP response to the browser.
+ * - **Rewrite** (`next()` + modified `req.url`): replaces `event.url` with the rewritten
+ *   URL so `event.path` (a getter) returns the new pathname for downstream handlers and
+ *   the Nitro router.
+ * - **Pass-through** (`next()`, URL unchanged): returns `undefined` — Nitro proceeds to
+ *   the next handler / route.
+ */
+declare const _default: (event: H3EventLike) => Promise<Response | void>;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=intlayerNitroHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intlayerNitroHandler.d.ts","names":[],"sources":["../../src/intlayerNitroHandler.ts"],"mappings":";;;;;;;;;KAcK,WAAA;EAKM;;;;EAAA,SAAA,IAAA;EAgBA;;;;;EAVT,GAAA,EAAK,GAAA;EA0C4D;;;;EAAA,SArCxD,OAAA,EAAS,OAAA;EAqC8B;;;;EAAA,SAhCvC,GAAA;IAAA,SACE,OAAA,EAAS,OAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;cAAO,QAAA,GA+BP,KAAA,EAAO,WAAA,KAAc,OAAA,CAAQ,QAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerOptimizePlugin.d.ts","names":[],"sources":["../../src/intlayerOptimizePlugin.ts"],"mappings":";;;;;;;AAsDA;;;;;;;;;;;;;;;;AAGuB;;;;cAHV,gBAAA,GACX,cAAA,EAAgB,cAAA,EAChB,YAAA,EAAc,YAAA,YACb,OAAA,CAAQ,YAAA"}
+{"version":3,"file":"intlayerOptimizePlugin.d.ts","names":[],"sources":["../../src/intlayerOptimizePlugin.ts"],"mappings":";;;;;;;AAuDA;;;;;;;;;;;;;;;;;;;;cAAa,gBAAA,GACX,cAAA,EAAgB,cAAA,EAChB,YAAA,EAAc,YAAA,YACb,OAAA,CAAQ,YAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerPlugin.d.ts","names":[],"sources":["../../src/intlayerPlugin.ts"],"mappings":";;;;;;AA6CA;;;;;;;;AAwJC;AAYD;;;;;;;;AAAsC;AAatC;;;cAjLa,cAAA,GACX,aAAA,GAAgB,uBAAA,KACf,YAsJF;;;;;AAyB2C;;;;;;cAb/B,QAAA,GAAQ,aAAA,GAnKH,uBAAA,KACf,YAkKmC;;;;;;;;;;;;;cAazB,cAAA,GAAc,aAAA,GAhLT,uBAAA,KACf,YA+KyC"}
+{"version":3,"file":"intlayerPlugin.d.ts","names":[],"sources":["../../src/intlayerPlugin.ts"],"mappings":";;;;;;AA6CA;;;;;;;;;AAoKA;;;;;;;;;AAaA;;;cAjLa,cAAA,GACX,aAAA,GAAgB,uBAAA,KACf,YAAA;;;;;;;;;;;cAkKU,QAAA,GAAQ,aAAA,GAnKH,uBAAA,KACf,YAAA;;;;;;;;;;;;;cA+KU,cAAA,GAAc,aAAA,GAhLT,uBAAA,KACf,YAAA"}

package/dist/types/intlayerProxyPlugin.d.ts

@@ -1,6 +1,6 @@
 import { GetConfigurationOptions } from "@intlayer/config/node";
 import { Plugin } from "vite";
-import { IncomingMessage } from "node:http";
+import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/intlayerProxyPlugin.d.ts
 type IntlayerProxyPluginOptions = {
@@ -20,10 +20,59 @@ type IntlayerProxyPluginOptions = {
   ignore?: (req: IncomingMessage) => boolean | undefined;
 };
 /**
- * Vite plugin that provides a development middleware for locale-based routing.
+ * 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:
+ *
+ * - **Dev**: wired up automatically by `intlayerProxy` via `configureServer`
+ * - **Preview**: wired up automatically by `intlayerProxy` via `configurePreviewServer`
+ * - **Production (Nitro / TanStack Start)**: create `server/middleware/intlayerProxy.ts`:
+ *
+ * @example
+ * ```ts
+ * // server/middleware/intlayerProxy.ts
+ * import { fromNodeMiddleware } from 'h3';
+ * import { createIntlayerProxyHandler } from 'vite-intlayer';
  *
- * This plugin mimics the behavior of the Intlayer middleware in Next.js,
- * handling locale detection, redirects, and rewrites during development.
+ * export default fromNodeMiddleware(createIntlayerProxyHandler());
+ * ```
+ *
+ * @param configOptions - Optional Intlayer configuration overrides.
+ * @param options - Plugin-specific options, such as path ignoring.
+ * @returns A Connect-compatible `(req, res, next) => void` middleware.
+ */
+declare const createIntlayerProxyHandler: (configOptions?: GetConfigurationOptions, options?: IntlayerProxyPluginOptions) => NodeMiddleware;
+/**
+ * Vite plugin that provides locale-based routing middleware for **all environments**:
+ * development, preview, and production SSR (Nitro / TanStack Start).
+ *
+ * - **Dev** (`vite dev`): registered via `configureServer`.
+ * - **Preview** (`vite preview`): registered via `configurePreviewServer`.
+ * - **Production Nitro** (`vite build`): automatically injected via the `.nitro` module
+ *   property that `nitro/vite` reads and pushes into `nitroConfig.modules`. The module
+ *   registers `intlayerNitroHandler` as a Nitro server middleware — no extra user config
+ *   needed.
+ *
+ * If you need custom config options or an `ignore` predicate in production, bypass
+ * auto-injection and create a server middleware file manually:
+ *
+ * ```ts
+ * // server/middleware/intlayerProxy.ts
+ * import { fromNodeMiddleware } from 'h3';
+ * import { createIntlayerProxyHandler } from 'vite-intlayer';
+ *
+ * export default fromNodeMiddleware(
+ *   createIntlayerProxyHandler(myConfig, { ignore: (req) => req.url?.startsWith('/api') })
+ * );
+ * ```
  *
  * @param configOptions - Optional configuration for Intlayer.
  * @param options - Plugin-specific options, like ignoring certain paths.
@@ -56,7 +105,7 @@ declare const intlayerMiddleware: (configOptions?: GetConfigurationOptions, opti
  * @deprecated Rename to intlayerProxy instead
  *
  * A Vite plugin that integrates a logic similar to the Next.js intlayer middleware.
-
+ *
  * ```ts
  * // Example usage of the plugin in a Vite configuration
  * export default defineConfig({
@@ -66,5 +115,5 @@ declare const intlayerMiddleware: (configOptions?: GetConfigurationOptions, opti
  */
 declare const intLayerMiddlewarePlugin: (configOptions?: GetConfigurationOptions, options?: IntlayerProxyPluginOptions) => Plugin;
 //#endregion
-export { intLayerMiddlewarePlugin, intlayerMiddleware, intlayerProxy };
+export { createIntlayerProxyHandler, intLayerMiddlewarePlugin, intlayerMiddleware, intlayerProxy };
 //# sourceMappingURL=intlayerProxyPlugin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerProxyPlugin.d.ts","names":[],"sources":["../../src/intlayerProxyPlugin.ts"],"mappings":";;;;;KA2BK,0BAAA;;AAFuC;;;;;;;;AAgBZ;AAsBhC;;;EAtBE,MAAA,IAAU,GAAA,EAAK,eAAe;AAAA;;;;;;;;;;AAyvB/B;AAcD;;;;;;;;;cAjvBa,aAAA,GACX,aAAA,GAAgB,uBAAA,EAChB,OAAA,GAAU,0BAAA,KACT,MAAA;;;;;AA8uB4C;AAc/C;;;;;;;cAda,kBAAA,GAAkB,aAAA,GAhvBb,uBAAA,EAAuB,OAAA,GAC7B,0BAAA,KACT,MAAA;;;;;;;AA4vBkD;;;;;;cAAxC,wBAAA,GAAwB,aAAA,GA9vBnB,uBAAA,EAAuB,OAAA,GAC7B,0BAAA,KACT,MAAA"}
+{"version":3,"file":"intlayerProxyPlugin.d.ts","names":[],"sources":["../../src/intlayerProxyPlugin.ts"],"mappings":";;;;;KAwBK,0BAAA;;AAFuC;;;;;;;;;AAgBZ;;;EAA9B,MAAA,IAAU,GAAA,EAAK,eAAA;AAAA;;;;;;KAQZ,cAAA,IACH,GAAA,EAAK,eAAA,EACL,GAAA,EAAK,cAAA,CAAe,eAAA,GACpB,IAAA;;;;;;AA2BF;;;;;;;;;;;;;;;AAowBA;;;;cApwBa,0BAAA,GACX,aAAA,GAAgB,uBAAA,EAChB,OAAA,GAAU,0BAAA,KACT,cAAA;;;;;;;;;;;AAq1BH;;;;;;;;;;;;;;;AAcA;;;;;;;;;;;;cAlGa,aAAA,GACX,aAAA,GAAgB,uBAAA,EAChB,OAAA,GAAU,0BAAA,KACT,MAAA;;;;;;;;;;;;;cAiFU,kBAAA,GAAkB,aAAA,GAnFb,uBAAA,EAAuB,OAAA,GAC7B,0BAAA,KACT,MAAA;;;;;;;;;;;;;cA+FU,wBAAA,GAAwB,aAAA,GAjGnB,uBAAA,EAAuB,OAAA,GAC7B,0BAAA,KACT,MAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerPrunePlugin.d.ts","names":[],"sources":["../../src/intlayerPrunePlugin.ts"],"mappings":";;;;;;;AA4MA;;;;;;;;;;;;;;AAGe;;;;;;;;;;;cAHF,aAAA,GACX,cAAA,EAAgB,cAAA,EAChB,YAAA,EAAc,YAAA,KACb,YAAA"}
+{"version":3,"file":"intlayerPrunePlugin.d.ts","names":[],"sources":["../../src/intlayerPrunePlugin.ts"],"mappings":";;;;;;;AA4MA;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,aAAA,GACX,cAAA,EAAgB,cAAA,EAChB,YAAA,EAAc,YAAA,KACb,YAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"intlayerVueAsyncPlugin.d.ts","names":[],"sources":["../../src/intlayerVueAsyncPlugin.ts"],"mappings":";;;;cAGa,sBAAA,GACX,aAAA,EAAe,cAAA,EACf,SAAA,eACC,YA2DF"}
+{"version":3,"file":"intlayerVueAsyncPlugin.d.ts","names":[],"sources":["../../src/intlayerVueAsyncPlugin.ts"],"mappings":";;;;cAGa,sBAAA,GACX,aAAA,EAAe,cAAA,EACf,SAAA,eACC,YAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"pruneContext.d.ts","names":[],"sources":["../../src/pruneContext.ts"],"mappings":";;;cAQa,kBAAA,QAAyB,YASpC"}
+{"version":3,"file":"pruneContext.d.ts","names":[],"sources":["../../src/pruneContext.ts"],"mappings":";;;cAQa,kBAAA,QAAyB,YAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-intlayer",
-  "version": "8.12.1",
+  "version": "8.12.3",
   "private": false,
   "description": "A Vite plugin for seamless internationalization (i18n), providing locale detection, redirection, and environment-based configuration",
   "keywords": [
@@ -42,6 +42,11 @@
       "import": "./dist/esm/index.mjs",
       "default": "./dist/esm/index.mjs"
     },
+    "./nitro-handler": {
+      "types": "./dist/types/intlayerNitroHandler.d.ts",
+      "import": "./dist/esm/intlayerNitroHandler.mjs",
+      "default": "./dist/esm/intlayerNitroHandler.mjs"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/esm/index.mjs",
@@ -76,27 +81,28 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/babel": "8.12.1",
-    "@intlayer/chokidar": "8.12.1",
-    "@intlayer/config": "8.12.1",
-    "@intlayer/core": "8.12.1",
-    "@intlayer/dictionaries-entry": "8.12.1",
-    "@intlayer/types": "8.12.1"
+    "@intlayer/babel": "8.12.3",
+    "@intlayer/chokidar": "8.12.3",
+    "@intlayer/config": "8.12.3",
+    "@intlayer/core": "8.12.3",
+    "@intlayer/dictionaries-entry": "8.12.3",
+    "@intlayer/types": "8.12.3"
   },
   "devDependencies": {
-    "@types/node": "25.9.1",
+    "@types/node": "25.9.2",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.1",
+    "tsdown": "0.21.10",
     "typescript": "6.0.3",
     "vitest": "4.1.8"
   },
   "peerDependencies": {
     "@babel/core": ">=6.0.0",
-    "@intlayer/svelte-compiler": "8.12.1",
-    "@intlayer/vue-compiler": "8.12.1",
+    "@intlayer/svelte-compiler": "8.12.3",
+    "@intlayer/vue-compiler": "8.12.3",
+    "h3": ">=1.0.0",
     "vite": ">=4.0.0"
   },
   "peerDependenciesMeta": {
@@ -108,6 +114,9 @@
     },
     "@intlayer/vue-compiler": {
       "optional": true
+    },
+    "h3": {
+      "optional": true
     }
   },
   "engines": {