@navita/vite-plugin 2.0.5 → 3.0.0-next.0

package/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/index.cjs

@@ -1,158 +1,128 @@
-'use strict';
-
-var fs = require('node:fs');
-var createRenderer = require('@navita/core/createRenderer');
-var css = require('@navita/css');
-
-const VIRTUAL_MODULE_ID = 'virtual:navita.css';
-const RESOLVED_VIRTUAL_MODULE_ID = '\0' + VIRTUAL_MODULE_ID.replace(/.css$/, '');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+let _navita_core_createRenderer = require("@navita/core/createRenderer");
+let _navita_css = require("@navita/css");
+//#region src/index.ts
+const VIRTUAL_MODULE_ID = "virtual:navita.css";
+const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID.replace(/.css$/, "")}`;
 function navita(options) {
-    const importMap = [
-        ...css.importMap,
-        ...options?.importMap || []
-    ];
-    let server;
-    let config;
-    let updateTimer = null;
-    let cssEmitted = false;
-    let isProduction = false;
-    return {
-        enforce: 'pre',
-        name: 'navita',
-        configResolved (_resolvedConfig) {
-            config = _resolvedConfig;
-            isProduction = config.mode === 'production';
-        },
-        configureServer (_server) {
-            server = _server;
-        },
-        buildStart () {
-            if (getRenderer()) {
-                return;
-            }
-            setRenderer(createRenderer.createRenderer({
-                context: config.root,
-                engineOptions: {
-                    enableSourceMaps: !isProduction,
-                    enableDebugIdentifiers: !isProduction,
-                    ...options?.engineOptions || {}
-                },
-                importMap,
-                resolver: async (filepath, request)=>{
-                    const resolved = await this.resolve(request, filepath);
-                    return resolved?.id || null;
-                },
-                readFile: (path)=>{
-                    return fs.promises.readFile(path, 'utf-8');
-                }
-            }));
-        },
-        resolveId (source) {
-            const [id] = source.split('?');
-            if (id.endsWith(VIRTUAL_MODULE_ID)) {
-                return RESOLVED_VIRTUAL_MODULE_ID;
-            }
-        },
-        async load (source) {
-            const [id] = source.split('?');
-            if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-                const css = getRenderer()?.engine.renderCssToString() || '';
-                return {
-                    code: css,
-                    map: {
-                        mappings: ''
-                    }
-                };
-            }
-        },
-        async transform (code, id) {
-            const renderer = getRenderer();
-            if (!renderer || id.includes('node_modules')) {
-                return null;
-            }
-            if (!importMap.map((x)=>x.source).some((value)=>code.indexOf(value) !== -1)) {
-                renderer.clearCache(id);
-                return null;
-            }
-            const { result, sourceMap, dependencies } = await renderer.transformAndProcess({
-                content: code,
-                filePath: id
-            });
-            if (!isProduction) {
-                for (const dependency of dependencies){
-                    this.addWatchFile(dependency);
-                }
-                updateNavitaCSS();
-            }
-            return {
-                code: result,
-                map: sourceMap
-            };
-        },
-        transformIndexHtml: {
-            handler: async ()=>{
-                // If we're building, we don't want to inject the CSS into the HTML.
-                // We'll do this in the `renderChunk` hook instead.
-                if (isProduction) {
-                    return [];
-                }
-                return [
-                    {
-                        tag: 'link',
-                        injectTo: 'head',
-                        attrs: {
-                            rel: 'stylesheet',
-                            href: `/${VIRTUAL_MODULE_ID}`
-                        }
-                    }
-                ];
-            }
-        },
-        renderChunk (_, chunk) {
-            if (cssEmitted) {
-                return;
-            }
-            chunk.viteMetadata.importedCss.add(this.getFileName(this.emitFile({
-                name: 'navita.css',
-                type: 'asset',
-                source: getRenderer()?.engine.renderCssToString()
-            })));
-            cssEmitted = true;
-        }
-    };
-    function updateNavitaCSS() {
-        if (!server) {
-            return;
-        }
-        clearTimeout(updateTimer);
-        updateTimer = setTimeout(()=>{
-            const { moduleGraph, ws } = server;
-            const mod = moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
-            if (mod) {
-                moduleGraph.invalidateModule(mod);
-                ws.send({
-                    type: 'update',
-                    updates: [
-                        {
-                            type: 'css-update',
-                            path: `/${VIRTUAL_MODULE_ID}`,
-                            acceptedPath: `/${VIRTUAL_MODULE_ID}`,
-                            timestamp: Date.now()
-                        }
-                    ]
-                });
-            }
-        }, 20);
-    }
+	const importMap = [..._navita_css.importMap, ...options?.importMap || []];
+	let server;
+	let config;
+	let updateTimer = null;
+	let cssEmitted = false;
+	let isProduction = false;
+	return {
+		enforce: "pre",
+		name: "navita",
+		configResolved(_resolvedConfig) {
+			config = _resolvedConfig;
+			isProduction = config.mode === "production";
+		},
+		configureServer(_server) {
+			server = _server;
+		},
+		buildStart() {
+			if (getRenderer()) return;
+			setRenderer((0, _navita_core_createRenderer.createRenderer)({
+				context: config.root,
+				engineOptions: {
+					enableSourceMaps: !isProduction,
+					enableDebugIdentifiers: !isProduction,
+					...options?.engineOptions || {}
+				},
+				importMap,
+				resolver: async (filepath, request) => {
+					return (await this.resolve(request, filepath))?.id || null;
+				},
+				readFile: (path) => {
+					return node_fs.default.promises.readFile(path, "utf-8");
+				}
+			}));
+		},
+		resolveId(source) {
+			const [id] = source.split("?");
+			if (id.endsWith("virtual:navita.css")) return RESOLVED_VIRTUAL_MODULE_ID;
+		},
+		async load(source) {
+			const [id] = source.split("?");
+			if (id === RESOLVED_VIRTUAL_MODULE_ID) return {
+				code: getRenderer()?.engine.renderCssToString() || "",
+				map: { mappings: "" }
+			};
+		},
+		async transform(code, id) {
+			const renderer = getRenderer();
+			if (!renderer || id.includes("node_modules") || process.env.RWSDK_BUILD_PASS === "linker") return null;
+			if (!importMap.map((x) => x.source).some((value) => code.indexOf(value) !== -1)) {
+				renderer.clearCache(id);
+				return null;
+			}
+			const { result, sourceMap, dependencies } = await renderer.transformAndProcess({
+				content: code,
+				filePath: id
+			});
+			if (!isProduction) {
+				for (const dependency of dependencies) this.addWatchFile(dependency);
+				updateNavitaCSS();
+			}
+			return {
+				code: result,
+				map: sourceMap
+			};
+		},
+		transformIndexHtml: { handler: async () => {
+			if (isProduction) return [];
+			return [{
+				tag: "link",
+				injectTo: "head",
+				attrs: {
+					rel: "stylesheet",
+					href: `/${VIRTUAL_MODULE_ID}`
+				}
+			}];
+		} },
+		renderChunk(_, chunk) {
+			if (cssEmitted) return;
+			chunk.viteMetadata.importedCss.add(this.getFileName(this.emitFile({
+				name: "navita.css",
+				type: "asset",
+				source: getRenderer()?.engine.renderCssToString()
+			})));
+			cssEmitted = true;
+		}
+	};
+	function updateNavitaCSS() {
+		if (!server) return;
+		clearTimeout(updateTimer);
+		updateTimer = setTimeout(() => {
+			const { moduleGraph, ws } = server;
+			const mod = moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
+			if (mod) {
+				moduleGraph.invalidateModule(mod);
+				ws.send({
+					type: "update",
+					updates: [{
+						type: "css-update",
+						path: `/${VIRTUAL_MODULE_ID}`,
+						acceptedPath: `/${VIRTUAL_MODULE_ID}`,
+						timestamp: Date.now()
+					}]
+				});
+			}
+		}, 20);
+	}
 }
-const globalNavitaRendererKey = '__navita_renderer';
+const globalNavitaRendererKey = "__navita_renderer";
 function setRenderer(renderer) {
-    globalThis[globalNavitaRendererKey] = renderer;
+	globalThis[globalNavitaRendererKey] = renderer;
 }
 function getRenderer() {
-    return globalThis[globalNavitaRendererKey];
+	return globalThis[globalNavitaRendererKey];
 }
-
+//#endregion
 exports.VIRTUAL_MODULE_ID = VIRTUAL_MODULE_ID;
 exports.getRenderer = getRenderer;
 exports.navita = navita;

package/index.d.ts

@@ -1,12 +1,13 @@
-import { ImportMap, EngineOptions, Renderer } from '@navita/core/createRenderer';
-import { Plugin } from 'vite';
+import { EngineOptions, ImportMap, Renderer } from "@navita/core/createRenderer";
+import { Plugin } from "vite";
 
+//#region src/index.d.ts
 declare const VIRTUAL_MODULE_ID = "virtual:navita.css";
 interface Options {
-    importMap?: ImportMap;
-    engineOptions?: EngineOptions;
+  importMap?: ImportMap;
+  engineOptions?: EngineOptions;
 }
 declare function navita(options?: Options): Plugin;
 declare function getRenderer(): Renderer | undefined;
-
-export { Options, VIRTUAL_MODULE_ID, getRenderer, navita };
+//#endregion
+export { Options, VIRTUAL_MODULE_ID, getRenderer, navita };

package/index.mjs

@@ -1,154 +1,126 @@
-import fs from 'node:fs';
-import { createRenderer } from '@navita/core/createRenderer';
-import { importMap } from '@navita/css';
-
-const VIRTUAL_MODULE_ID = 'virtual:navita.css';
-const RESOLVED_VIRTUAL_MODULE_ID = '\0' + VIRTUAL_MODULE_ID.replace(/.css$/, '');
+import "node:path";
+import "node:url";
+import.meta.url;
+import fs from "node:fs";
+import { createRenderer } from "@navita/core/createRenderer";
+import { importMap } from "@navita/css";
+//#region src/index.ts
+const VIRTUAL_MODULE_ID = "virtual:navita.css";
+const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID.replace(/.css$/, "")}`;
 function navita(options) {
-    const importMap$1 = [
-        ...importMap,
-        ...options?.importMap || []
-    ];
-    let server;
-    let config;
-    let updateTimer = null;
-    let cssEmitted = false;
-    let isProduction = false;
-    return {
-        enforce: 'pre',
-        name: 'navita',
-        configResolved (_resolvedConfig) {
-            config = _resolvedConfig;
-            isProduction = config.mode === 'production';
-        },
-        configureServer (_server) {
-            server = _server;
-        },
-        buildStart () {
-            if (getRenderer()) {
-                return;
-            }
-            setRenderer(createRenderer({
-                context: config.root,
-                engineOptions: {
-                    enableSourceMaps: !isProduction,
-                    enableDebugIdentifiers: !isProduction,
-                    ...options?.engineOptions || {}
-                },
-                importMap: importMap$1,
-                resolver: async (filepath, request)=>{
-                    const resolved = await this.resolve(request, filepath);
-                    return resolved?.id || null;
-                },
-                readFile: (path)=>{
-                    return fs.promises.readFile(path, 'utf-8');
-                }
-            }));
-        },
-        resolveId (source) {
-            const [id] = source.split('?');
-            if (id.endsWith(VIRTUAL_MODULE_ID)) {
-                return RESOLVED_VIRTUAL_MODULE_ID;
-            }
-        },
-        async load (source) {
-            const [id] = source.split('?');
-            if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-                const css = getRenderer()?.engine.renderCssToString() || '';
-                return {
-                    code: css,
-                    map: {
-                        mappings: ''
-                    }
-                };
-            }
-        },
-        async transform (code, id) {
-            const renderer = getRenderer();
-            if (!renderer || id.includes('node_modules')) {
-                return null;
-            }
-            if (!importMap$1.map((x)=>x.source).some((value)=>code.indexOf(value) !== -1)) {
-                renderer.clearCache(id);
-                return null;
-            }
-            const { result, sourceMap, dependencies } = await renderer.transformAndProcess({
-                content: code,
-                filePath: id
-            });
-            if (!isProduction) {
-                for (const dependency of dependencies){
-                    this.addWatchFile(dependency);
-                }
-                updateNavitaCSS();
-            }
-            return {
-                code: result,
-                map: sourceMap
-            };
-        },
-        transformIndexHtml: {
-            handler: async ()=>{
-                // If we're building, we don't want to inject the CSS into the HTML.
-                // We'll do this in the `renderChunk` hook instead.
-                if (isProduction) {
-                    return [];
-                }
-                return [
-                    {
-                        tag: 'link',
-                        injectTo: 'head',
-                        attrs: {
-                            rel: 'stylesheet',
-                            href: `/${VIRTUAL_MODULE_ID}`
-                        }
-                    }
-                ];
-            }
-        },
-        renderChunk (_, chunk) {
-            if (cssEmitted) {
-                return;
-            }
-            chunk.viteMetadata.importedCss.add(this.getFileName(this.emitFile({
-                name: 'navita.css',
-                type: 'asset',
-                source: getRenderer()?.engine.renderCssToString()
-            })));
-            cssEmitted = true;
-        }
-    };
-    function updateNavitaCSS() {
-        if (!server) {
-            return;
-        }
-        clearTimeout(updateTimer);
-        updateTimer = setTimeout(()=>{
-            const { moduleGraph, ws } = server;
-            const mod = moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
-            if (mod) {
-                moduleGraph.invalidateModule(mod);
-                ws.send({
-                    type: 'update',
-                    updates: [
-                        {
-                            type: 'css-update',
-                            path: `/${VIRTUAL_MODULE_ID}`,
-                            acceptedPath: `/${VIRTUAL_MODULE_ID}`,
-                            timestamp: Date.now()
-                        }
-                    ]
-                });
-            }
-        }, 20);
-    }
+	const importMap$1 = [...importMap, ...options?.importMap || []];
+	let server;
+	let config;
+	let updateTimer = null;
+	let cssEmitted = false;
+	let isProduction = false;
+	return {
+		enforce: "pre",
+		name: "navita",
+		configResolved(_resolvedConfig) {
+			config = _resolvedConfig;
+			isProduction = config.mode === "production";
+		},
+		configureServer(_server) {
+			server = _server;
+		},
+		buildStart() {
+			if (getRenderer()) return;
+			setRenderer(createRenderer({
+				context: config.root,
+				engineOptions: {
+					enableSourceMaps: !isProduction,
+					enableDebugIdentifiers: !isProduction,
+					...options?.engineOptions || {}
+				},
+				importMap: importMap$1,
+				resolver: async (filepath, request) => {
+					return (await this.resolve(request, filepath))?.id || null;
+				},
+				readFile: (path) => {
+					return fs.promises.readFile(path, "utf-8");
+				}
+			}));
+		},
+		resolveId(source) {
+			const [id] = source.split("?");
+			if (id.endsWith("virtual:navita.css")) return RESOLVED_VIRTUAL_MODULE_ID;
+		},
+		async load(source) {
+			const [id] = source.split("?");
+			if (id === RESOLVED_VIRTUAL_MODULE_ID) return {
+				code: getRenderer()?.engine.renderCssToString() || "",
+				map: { mappings: "" }
+			};
+		},
+		async transform(code, id) {
+			const renderer = getRenderer();
+			if (!renderer || id.includes("node_modules") || process.env.RWSDK_BUILD_PASS === "linker") return null;
+			if (!importMap$1.map((x) => x.source).some((value) => code.indexOf(value) !== -1)) {
+				renderer.clearCache(id);
+				return null;
+			}
+			const { result, sourceMap, dependencies } = await renderer.transformAndProcess({
+				content: code,
+				filePath: id
+			});
+			if (!isProduction) {
+				for (const dependency of dependencies) this.addWatchFile(dependency);
+				updateNavitaCSS();
+			}
+			return {
+				code: result,
+				map: sourceMap
+			};
+		},
+		transformIndexHtml: { handler: async () => {
+			if (isProduction) return [];
+			return [{
+				tag: "link",
+				injectTo: "head",
+				attrs: {
+					rel: "stylesheet",
+					href: `/${VIRTUAL_MODULE_ID}`
+				}
+			}];
+		} },
+		renderChunk(_, chunk) {
+			if (cssEmitted) return;
+			chunk.viteMetadata.importedCss.add(this.getFileName(this.emitFile({
+				name: "navita.css",
+				type: "asset",
+				source: getRenderer()?.engine.renderCssToString()
+			})));
+			cssEmitted = true;
+		}
+	};
+	function updateNavitaCSS() {
+		if (!server) return;
+		clearTimeout(updateTimer);
+		updateTimer = setTimeout(() => {
+			const { moduleGraph, ws } = server;
+			const mod = moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
+			if (mod) {
+				moduleGraph.invalidateModule(mod);
+				ws.send({
+					type: "update",
+					updates: [{
+						type: "css-update",
+						path: `/${VIRTUAL_MODULE_ID}`,
+						acceptedPath: `/${VIRTUAL_MODULE_ID}`,
+						timestamp: Date.now()
+					}]
+				});
+			}
+		}, 20);
+	}
 }
-const globalNavitaRendererKey = '__navita_renderer';
+const globalNavitaRendererKey = "__navita_renderer";
 function setRenderer(renderer) {
-    globalThis[globalNavitaRendererKey] = renderer;
+	globalThis[globalNavitaRendererKey] = renderer;
 }
 function getRenderer() {
-    return globalThis[globalNavitaRendererKey];
+	return globalThis[globalNavitaRendererKey];
 }
-
+//#endregion
 export { VIRTUAL_MODULE_ID, getRenderer, navita };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navita/vite-plugin",
-  "version": "2.0.5",
+  "version": "3.0.0-next.0",
   "description": "Navita Vite Plugin",
   "keywords": [
     "vite",
@@ -19,11 +19,16 @@
       "import": "./remix.mjs",
       "require": "./remix.cjs",
       "types": "./remix.d.ts"
+    },
+    "./rwsdk": {
+      "import": "./rwsdk.mjs",
+      "require": "./rwsdk.cjs",
+      "types": "./rwsdk.d.ts"
     }
   },
   "dependencies": {
-    "@navita/core": "1.0.1",
-    "@navita/css": "0.2.1"
+    "@navita/core": "3.0.0-next.0",
+    "@navita/css": "3.0.0-next.0"
   },
   "license": "MIT",
   "author": "Eagerpatch",

package/remix.cjs

@@ -1,85 +1,52 @@
-'use strict';
-
-var crypto = require('node:crypto');
-var index = require('./index.cjs');
-
-function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
-
-const VIRTUAL_MODULE_IDS = [
-    '\0virtual:remix/server-build',
-    '\0virtual:react-router/server-build'
-];
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_index = require("./index.cjs");
+let node_crypto = require("node:crypto");
+node_crypto = require_runtime.__toESM(node_crypto);
+//#region src/remix.ts
+const VIRTUAL_MODULE_IDS = ["\0virtual:remix/server-build", "\0virtual:react-router/server-build"];
 let cssFileName;
 function navitaRemix(options) {
-    let isProduction = false;
-    let hasEmittedCss = false;
-    const { renderChunk, ...navitaVite } = index.navita(options);
-    return [
-        navitaVite,
-        {
-            name: 'navita-remix',
-            configResolved (config) {
-                isProduction = config.mode === 'production';
-            },
-            transform (code, id) {
-                if (isProduction || !VIRTUAL_MODULE_IDS.includes(id)) {
-                    return;
-                }
-                return `${code}\n${SERVER_BUILD_EXTENSION}`;
-            },
-            renderChunk (_, chunk, options) {
-                const isServerChunk = options.dir.endsWith('/server');
-                const isClientChunk = options.dir.endsWith('/client');
-                if (isClientChunk && chunk.name === "root") {
-                    // Generate a random name for the CSS file.
-                    // Vite uses a file hash as the name, but since the client build will finish before
-                    // the server build, we need to generate a random name for the CSS file.
-                    // Ideally we could use a hash, but since the server might contain more styles than the client, we need to do it like this.
-                    const random = crypto__namespace.randomBytes(30).toString("base64").replace(/[^a-zA-Z0-9]/g, "").slice(0, 8);
-                    cssFileName = `assets/navita-${random}.css`;
-                    chunk.viteMetadata.importedCss.add(cssFileName);
-                    return;
-                }
-                if (isServerChunk && !hasEmittedCss) {
-                    // In the server-build, we'll generate the CSS and emit it as an asset.
-                    // Remix/react-router will then move it to the client assets.
-                    this.emitFile({
-                        fileName: cssFileName,
-                        name: 'navita.css',
-                        type: 'asset',
-                        source: index.getRenderer()?.engine.renderCssToString()
-                    });
-                    hasEmittedCss = true;
-                }
-            }
-        }
-    ];
+	let isProduction = false;
+	let hasEmittedCss = false;
+	const navitaVite = require_index.navita(options);
+	delete navitaVite.renderChunk;
+	return [navitaVite, {
+		name: "navita-remix",
+		configResolved(config) {
+			isProduction = config.mode === "production";
+		},
+		transform(code, id) {
+			if (isProduction || !VIRTUAL_MODULE_IDS.includes(id)) return;
+			return `${code}\n${SERVER_BUILD_EXTENSION}`;
+		},
+		renderChunk(_, chunk, options) {
+			const isServerChunk = options.dir.endsWith("/server");
+			if (options.dir.endsWith("/client") && chunk.name === "root") {
+				cssFileName = `assets/navita-${node_crypto.randomBytes(30).toString("base64").replace(/[^a-zA-Z0-9]/g, "").slice(0, 8)}.css`;
+				chunk.viteMetadata.importedCss.add(cssFileName);
+				return;
+			}
+			if (isServerChunk && !hasEmittedCss) {
+				this.emitFile({
+					fileName: cssFileName,
+					name: "navita.css",
+					type: "asset",
+					source: require_index.getRenderer()?.engine.renderCssToString()
+				});
+				hasEmittedCss = true;
+			}
+		}
+	}];
 }
 const SERVER_BUILD_EXTENSION = `
   routes.root.module = {
     ...route0,
     links: () => [
       ...(route0.links ? route0.links() : []),
-      { rel: 'stylesheet', href: '/${index.VIRTUAL_MODULE_ID}' },
+      { rel: 'stylesheet', href: '/${require_index.VIRTUAL_MODULE_ID}' },
     ],
   };
 `;
-
+//#endregion
 exports.navitaRemix = navitaRemix;

package/remix.d.ts

@@ -1,7 +1,7 @@
-import { Plugin } from 'vite';
-import { Options } from './index.js';
-import '@navita/core/createRenderer';
+import { Options } from "./index.js";
+import { Plugin } from "vite";
 
+//#region src/remix.d.ts
 declare function navitaRemix(options?: Options): Plugin[];
-
-export { navitaRemix };
+//#endregion
+export { navitaRemix };

package/remix.mjs

@@ -1,55 +1,43 @@
-import * as crypto from 'node:crypto';
-import { navita, getRenderer, VIRTUAL_MODULE_ID } from './index.mjs';
-
-const VIRTUAL_MODULE_IDS = [
-    '\0virtual:remix/server-build',
-    '\0virtual:react-router/server-build'
-];
+import "node:path";
+import "node:url";
+import.meta.url;
+import { VIRTUAL_MODULE_ID, getRenderer, navita } from "./index.mjs";
+import * as crypto from "node:crypto";
+//#region src/remix.ts
+const VIRTUAL_MODULE_IDS = ["\0virtual:remix/server-build", "\0virtual:react-router/server-build"];
 let cssFileName;
 function navitaRemix(options) {
-    let isProduction = false;
-    let hasEmittedCss = false;
-    const { renderChunk, ...navitaVite } = navita(options);
-    return [
-        navitaVite,
-        {
-            name: 'navita-remix',
-            configResolved (config) {
-                isProduction = config.mode === 'production';
-            },
-            transform (code, id) {
-                if (isProduction || !VIRTUAL_MODULE_IDS.includes(id)) {
-                    return;
-                }
-                return `${code}\n${SERVER_BUILD_EXTENSION}`;
-            },
-            renderChunk (_, chunk, options) {
-                const isServerChunk = options.dir.endsWith('/server');
-                const isClientChunk = options.dir.endsWith('/client');
-                if (isClientChunk && chunk.name === "root") {
-                    // Generate a random name for the CSS file.
-                    // Vite uses a file hash as the name, but since the client build will finish before
-                    // the server build, we need to generate a random name for the CSS file.
-                    // Ideally we could use a hash, but since the server might contain more styles than the client, we need to do it like this.
-                    const random = crypto.randomBytes(30).toString("base64").replace(/[^a-zA-Z0-9]/g, "").slice(0, 8);
-                    cssFileName = `assets/navita-${random}.css`;
-                    chunk.viteMetadata.importedCss.add(cssFileName);
-                    return;
-                }
-                if (isServerChunk && !hasEmittedCss) {
-                    // In the server-build, we'll generate the CSS and emit it as an asset.
-                    // Remix/react-router will then move it to the client assets.
-                    this.emitFile({
-                        fileName: cssFileName,
-                        name: 'navita.css',
-                        type: 'asset',
-                        source: getRenderer()?.engine.renderCssToString()
-                    });
-                    hasEmittedCss = true;
-                }
-            }
-        }
-    ];
+	let isProduction = false;
+	let hasEmittedCss = false;
+	const navitaVite = navita(options);
+	delete navitaVite.renderChunk;
+	return [navitaVite, {
+		name: "navita-remix",
+		configResolved(config) {
+			isProduction = config.mode === "production";
+		},
+		transform(code, id) {
+			if (isProduction || !VIRTUAL_MODULE_IDS.includes(id)) return;
+			return `${code}\n${SERVER_BUILD_EXTENSION}`;
+		},
+		renderChunk(_, chunk, options) {
+			const isServerChunk = options.dir.endsWith("/server");
+			if (options.dir.endsWith("/client") && chunk.name === "root") {
+				cssFileName = `assets/navita-${crypto.randomBytes(30).toString("base64").replace(/[^a-zA-Z0-9]/g, "").slice(0, 8)}.css`;
+				chunk.viteMetadata.importedCss.add(cssFileName);
+				return;
+			}
+			if (isServerChunk && !hasEmittedCss) {
+				this.emitFile({
+					fileName: cssFileName,
+					name: "navita.css",
+					type: "asset",
+					source: getRenderer()?.engine.renderCssToString()
+				});
+				hasEmittedCss = true;
+			}
+		}
+	}];
 }
 const SERVER_BUILD_EXTENSION = `
   routes.root.module = {
@@ -60,5 +48,5 @@ const SERVER_BUILD_EXTENSION = `
     ],
   };
 `;
-
+//#endregion
 export { navitaRemix };

package/rwsdk.cjs

@@ -0,0 +1,60 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_index = require("./index.cjs");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+//#region src/rwsdk.ts
+function navitaRwsdk(options) {
+	let projectRootDir;
+	let base;
+	return [require_index.navita(options), {
+		name: "navita-rwsdk",
+		enforce: "post",
+		configResolved(config) {
+			projectRootDir = config.root;
+			base = config.base;
+		},
+		async renderChunk(code) {
+			if (this.environment?.name !== "worker" || process.env.RWSDK_BUILD_PASS !== "linker") return null;
+			const manifestPath = node_path.resolve(projectRootDir, "dist", "client", ".vite", "manifest.json");
+			let manifestContent;
+			try {
+				manifestContent = await node_fs_promises.readFile(manifestPath, "utf-8");
+			} catch {
+				console.warn("[navita-rwsdk] Could not read client manifest, skipping CSS replacement");
+				return null;
+			}
+			const manifest = JSON.parse(manifestContent);
+			let navitaCssPath = null;
+			for (const [key, value] of Object.entries(manifest)) {
+				if (key.includes("navita") && key.endsWith(".css")) {
+					navitaCssPath = (base || "/") + value.file;
+					break;
+				}
+				if (value.css) {
+					for (const cssFile of value.css) if (cssFile.includes("navita")) {
+						navitaCssPath = (base || "/") + cssFile;
+						break;
+					}
+					if (navitaCssPath) break;
+				}
+			}
+			if (!navitaCssPath) {
+				console.warn("[navita-rwsdk] Could not find navita CSS in manifest");
+				return null;
+			}
+			let newCode = code;
+			newCode = newCode.replaceAll(`/${require_index.VIRTUAL_MODULE_ID}`, navitaCssPath);
+			newCode = newCode.replaceAll(require_index.VIRTUAL_MODULE_ID, navitaCssPath);
+			if (newCode !== code) return {
+				code: newCode,
+				map: null
+			};
+			return null;
+		}
+	}];
+}
+//#endregion
+exports.navitaRwsdk = navitaRwsdk;

package/rwsdk.d.ts

@@ -0,0 +1,7 @@
+import { Options } from "./index.js";
+import { Plugin } from "vite";
+
+//#region src/rwsdk.d.ts
+declare function navitaRwsdk(options?: Options): Plugin[];
+//#endregion
+export { navitaRwsdk };

package/rwsdk.mjs

@@ -0,0 +1,59 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { VIRTUAL_MODULE_ID, navita } from "./index.mjs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+//#region src/rwsdk.ts
+function navitaRwsdk(options) {
+	let projectRootDir;
+	let base;
+	return [navita(options), {
+		name: "navita-rwsdk",
+		enforce: "post",
+		configResolved(config) {
+			projectRootDir = config.root;
+			base = config.base;
+		},
+		async renderChunk(code) {
+			if (this.environment?.name !== "worker" || process.env.RWSDK_BUILD_PASS !== "linker") return null;
+			const manifestPath = path.resolve(projectRootDir, "dist", "client", ".vite", "manifest.json");
+			let manifestContent;
+			try {
+				manifestContent = await fsp.readFile(manifestPath, "utf-8");
+			} catch {
+				console.warn("[navita-rwsdk] Could not read client manifest, skipping CSS replacement");
+				return null;
+			}
+			const manifest = JSON.parse(manifestContent);
+			let navitaCssPath = null;
+			for (const [key, value] of Object.entries(manifest)) {
+				if (key.includes("navita") && key.endsWith(".css")) {
+					navitaCssPath = (base || "/") + value.file;
+					break;
+				}
+				if (value.css) {
+					for (const cssFile of value.css) if (cssFile.includes("navita")) {
+						navitaCssPath = (base || "/") + cssFile;
+						break;
+					}
+					if (navitaCssPath) break;
+				}
+			}
+			if (!navitaCssPath) {
+				console.warn("[navita-rwsdk] Could not find navita CSS in manifest");
+				return null;
+			}
+			let newCode = code;
+			newCode = newCode.replaceAll(`/${VIRTUAL_MODULE_ID}`, navitaCssPath);
+			newCode = newCode.replaceAll(VIRTUAL_MODULE_ID, navitaCssPath);
+			if (newCode !== code) return {
+				code: newCode,
+				map: null
+			};
+			return null;
+		}
+	}];
+}
+//#endregion
+export { navitaRwsdk };