@anchorlib/vite-ssr 1.0.0-beta.24

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,30 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+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 __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __commonJS, __require, __toESM };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { Plugin } from "vite";
+
+//#region src/index.d.ts
+type ViteSSROptions = {
+  /** Path to the router module. Must `export default` a `Router` instance. */
+  router: string;
+  /** Path to the root layout module. Must `export default` a `RouteComponent`. */
+  layout: string;
+  /**
+   * Path to the renderer module (e.g., `'@anchorlib/react/ssr'`).
+   * Must export `createSSR(router, layout) => SSRRenderer`.
+   */
+  renderer: string;
+  /**
+   * IRPC configuration. If provided, POST requests to the transport
+   * endpoint are routed through the HTTPRouter.
+   */
+  irpc?: {
+    /** IRPC instance. String loads `export default`, object loads a named export. */
+    module: ModuleRef;
+    /** HTTP Transport instance. */
+    transport: ModuleRef;
+    /** WebSocket Transport instance (optional). */
+    wsTransport?: ModuleRef;
+    /** Handler modules to load (e.g., ['./src/pages/constructor.ts']). */
+    handlers?: string[];
+  };
+  /** Placeholder for rendered head. Defaults to `<!--ssr-head-->`. */
+  headTag?: string;
+  /** Placeholder for rendered body. Defaults to `<!--ssr-outlet-->`. */
+  bodyTag?: string;
+};
+/** A module reference — string for default export, object for named export. */
+type ModuleRef = string | {
+  path: string;
+  name: string;
+};
+/**
+ * Vite plugin for Anchor SSR.
+ *
+ * Replaces manual `server.ts` and `entry-server.tsx` with a single plugin call.
+ * Handles SSR renderer construction, IRPC routing, request isolation,
+ * abort signal propagation, and template transformation.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { airSSR } from '@anchorlib/vite-ssr';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     airSSR({
+ *       router: './src/lib/router.ts',
+ *       layout: './src/pages/layout.tsx',
+ *       renderer: '@anchorlib/react/ssr',
+ *       irpc: {
+ *         module: './src/lib/irpc.ts',
+ *         transport: './src/lib/transport.ts',
+ *         handlers: ['./src/pages/constructor.ts'],
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function airSSR(options: ViteSSROptions): Plugin;
+//#endregion
+export { ViteSSROptions, airSSR };

package/dist/index.js

@@ -0,0 +1,186 @@
+import { sendWebResponse, toWebRequest } from "./utils.js";
+import fs from "node:fs";
+import path from "node:path";
+import { decodeCookies, getContext, setCookieContext } from "@anchorlib/core";
+
+//#region src/index.ts
+/**
+* Vite plugin for Anchor SSR.
+*
+* Replaces manual `server.ts` and `entry-server.tsx` with a single plugin call.
+* Handles SSR renderer construction, IRPC routing, request isolation,
+* abort signal propagation, and template transformation.
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { airSSR } from '@anchorlib/vite-ssr';
+*
+* export default defineConfig({
+*   plugins: [
+*     airSSR({
+*       router: './src/lib/router.ts',
+*       layout: './src/pages/layout.tsx',
+*       renderer: '@anchorlib/react/ssr',
+*       irpc: {
+*         module: './src/lib/irpc.ts',
+*         transport: './src/lib/transport.ts',
+*         handlers: ['./src/pages/constructor.ts'],
+*       },
+*     }),
+*   ],
+* });
+* ```
+*/
+function airSSR(options) {
+	const { router: routerPath, layout: layoutPath, renderer: rendererPath, irpc: irpcConfig, headTag = "<!--ssr-head-->", bodyTag = "<!--ssr-outlet-->" } = options;
+	let router;
+	let templatePath;
+	let rendererFactory;
+	return {
+		name: "air-ssr",
+		configureServer(server) {
+			templatePath = path.resolve(server.config.root, "index.html");
+			const ready = (async () => {
+				await server.ssrLoadModule("@irpclib/irpc/server").catch(() => {});
+				rendererFactory = (await server.ssrLoadModule(rendererPath)).createSSR;
+				if (irpcConfig) {
+					router = await initRouter(server, irpcConfig);
+					if (irpcConfig.wsTransport) await initWsRouter(server, irpcConfig);
+					const { IRPC_STORE } = await server.ssrLoadModule("@irpclib/irpc");
+					IRPC_STORE.subscribe(() => {
+						IRPC_STORE.print();
+					});
+				}
+			})();
+			return () => {
+				server.middlewares.use(async (req, res, next) => {
+					await ready;
+					const controller = new AbortController();
+					req.on("close", () => controller.abort());
+					try {
+						const url = req.originalUrl ?? req.url ?? "/";
+						if (router && req.method === "POST" && url.startsWith(router.transport.endpoint)) {
+							if (irpcConfig?.handlers) for (const handler of irpcConfig.handlers) await server.ssrLoadModule(handler);
+							const request = toWebRequest(req, controller);
+							const cookie$1 = req.headers.cookie ?? "";
+							await sendWebResponse(res, await router.resolve(request, [["cookie", cookie$1]]));
+							return;
+						}
+						if (url.includes(".")) return next();
+						let template = fs.readFileSync(templatePath, "utf-8");
+						template = await server.transformIndexHtml(url, template);
+						const { default: pageRouter } = await server.ssrLoadModule(routerPath);
+						const { default: RootLayout } = await server.ssrLoadModule(layoutPath);
+						const render = await rendererFactory(pageRouter, RootLayout);
+						const cookie = req.headers.cookie ?? "";
+						let ssrResult;
+						if (router) {
+							const cookieJar = decodeCookies(cookie);
+							ssrResult = await router.isolate(() => render(url, cookie, void 0, controller, true), controller, [["cookie", cookie]], () => {
+								setCookieContext(cookieJar);
+							});
+						} else ssrResult = await render(url, cookie, void 0, controller);
+						const { html, head, status, redirect, cookies } = ssrResult;
+						if (redirect) {
+							res.writeHead(302, { Location: redirect });
+							res.end();
+							return;
+						}
+						const headers = { "Content-Type": "text/html" };
+						if (cookies?.length) headers["Set-Cookie"] = cookies;
+						const page = template.replace(headTag, head).replace(bodyTag, html);
+						res.writeHead(status ?? 200, headers);
+						res.end(page);
+					} catch (error) {
+						next(error);
+					}
+				});
+			};
+		}
+	};
+}
+/**
+* Loads an export from a module reference.
+* String path loads the default export; { path, name } loads a named export.
+*/
+async function loadExport(server, ref) {
+	if (typeof ref === "string") return (await server.ssrLoadModule(ref)).default;
+	return (await server.ssrLoadModule(ref.path))[ref.name];
+}
+/**
+* Initializes the IRPC HTTP router by loading the module and handlers.
+*/
+async function initRouter(server, config) {
+	try {
+		const irpc = await loadExport(server, config.module);
+		const transport = await loadExport(server, config.transport);
+		if (!irpc || !transport) {
+			server.config.logger.warn("[air-ssr] IRPC module and transport are required.");
+			return;
+		}
+		if (config.handlers) for (const handler of config.handlers) await server.ssrLoadModule(handler);
+		const { HTTPRouter } = await server.ssrLoadModule("@irpclib/http/router");
+		const router = new HTTPRouter(irpc, transport);
+		router.use(() => {
+			setCookieContext(decodeCookies(getContext("cookie", "")));
+		});
+		server.config.logger.info(`[air-ssr] IRPC HTTP router initialized at ${transport.endpoint}`);
+		return router;
+	} catch (error) {
+		server.config.logger.error("[air-ssr] Failed to initialize IRPC HTTP router:");
+		server.config.logger.error(String(error));
+		return;
+	}
+}
+/**
+* Initializes the IRPC WebSocket router and attaches it to the Vite dev server.
+*
+* Creates a WebSocketServer on the same HTTP server (noServer mode),
+* intercepts upgrade requests at the WS transport endpoint, and routes
+* messages through WebSocketRouter.
+*/
+async function initWsRouter(server, config) {
+	if (!config.wsTransport) return;
+	try {
+		const irpc = await loadExport(server, config.module);
+		const wsTransport = await loadExport(server, config.wsTransport);
+		if (!irpc || !wsTransport) {
+			server.config.logger.warn("[air-ssr] IRPC module and wsTransport are required for WebSocket.");
+			return;
+		}
+		const { WebSocketRouter } = await server.ssrLoadModule("@irpclib/ws/router");
+		const wsRouter = new WebSocketRouter(irpc, wsTransport);
+		wsRouter.use(() => {
+			setCookieContext(decodeCookies(getContext("cookie", "")));
+		});
+		const endpoint = wsTransport.endpoint;
+		const { WebSocketServer } = await import("./node_modules/.bun/ws@8.21.0/node_modules/ws/wrapper.js");
+		const wss = new WebSocketServer({ noServer: true });
+		server.httpServer?.on("upgrade", (req, socket, head) => {
+			if (req.url === endpoint) wss.handleUpgrade(req, socket, head, (ws) => {
+				wss.emit("connection", ws, req);
+			});
+		});
+		wss.on("connection", (ws, req) => {
+			const cookie = req.headers.cookie ?? "";
+			ws.on("message", async (data) => {
+				if (config.handlers) for (const handler of config.handlers) await server.ssrLoadModule(handler);
+				const message = data instanceof ArrayBuffer ? data : data.toString();
+				await wsRouter.resolve(message, ws, [["cookie", cookie]]);
+			});
+			ws.on("close", () => {
+				wsRouter.disconnect();
+			});
+		});
+		server.config.logger.info(`[air-ssr] IRPC WebSocket router initialized at ${endpoint}`);
+		return wsRouter;
+	} catch (error) {
+		server.config.logger.error("[air-ssr] Failed to initialize IRPC WebSocket router:");
+		server.config.logger.error(String(error));
+		return;
+	}
+}
+
+//#endregion
+export { airSSR };

package/dist/utils.d.ts

@@ -0,0 +1,27 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/utils.d.ts
+
+/**
+ * Converts a Node.js IncomingMessage into a Web Standard Request.
+ *
+ * Wires the AbortController so that `req.on('close')` (client disconnect)
+ * propagates as `request.signal.aborted`, enabling IRPC stream cleanup.
+ *
+ * @param req - The incoming Node.js HTTP request.
+ * @param controller - AbortController to wire to the request signal.
+ * @returns A Web Standard Request.
+ */
+declare function toWebRequest(req: IncomingMessage, controller: AbortController): Request;
+/**
+ * Pipes a Web Standard Response back into a Node.js ServerResponse.
+ *
+ * Handles both streaming and non-streaming responses. For streaming responses,
+ * pipes the ReadableStream with proper backpressure handling.
+ *
+ * @param res - The Node.js ServerResponse to write to.
+ * @param response - The Web Standard Response to send.
+ */
+declare function sendWebResponse(res: ServerResponse, response: Response): Promise<void>;
+//#endregion
+export { sendWebResponse, toWebRequest };

package/dist/utils.js

@@ -0,0 +1,54 @@
+import { Readable } from "node:stream";
+
+//#region src/utils.ts
+/**
+* Converts a Node.js IncomingMessage into a Web Standard Request.
+*
+* Wires the AbortController so that `req.on('close')` (client disconnect)
+* propagates as `request.signal.aborted`, enabling IRPC stream cleanup.
+*
+* @param req - The incoming Node.js HTTP request.
+* @param controller - AbortController to wire to the request signal.
+* @returns A Web Standard Request.
+*/
+function toWebRequest(req, controller) {
+	const { method = "GET", headers, url = "/" } = req;
+	const origin = `http://${headers.host ?? "localhost"}`;
+	const fullUrl = new URL(url, origin).href;
+	const isBodyMethod = method !== "GET" && method !== "HEAD";
+	return new Request(fullUrl, {
+		method,
+		headers,
+		body: isBodyMethod ? Readable.toWeb(req) : void 0,
+		signal: controller.signal,
+		duplex: "half"
+	});
+}
+/**
+* Pipes a Web Standard Response back into a Node.js ServerResponse.
+*
+* Handles both streaming and non-streaming responses. For streaming responses,
+* pipes the ReadableStream with proper backpressure handling.
+*
+* @param res - The Node.js ServerResponse to write to.
+* @param response - The Web Standard Response to send.
+*/
+async function sendWebResponse(res, response) {
+	response.headers.forEach((value, key) => {
+		if (key.toLowerCase() !== "content-encoding") res.setHeader(key, value);
+	});
+	res.writeHead(response.status, response.statusText);
+	if (response.body) {
+		const readable = Readable.fromWeb(response.body);
+		readable.pipe(res);
+		res.on("close", () => {
+			if (!readable.destroyed) readable.destroy();
+		});
+	} else {
+		const text = await response.text();
+		res.end(text);
+	}
+}
+
+//#endregion
+export { sendWebResponse, toWebRequest };

package/package.json

@@ -0,0 +1,70 @@
+{
+  "type": "module",
+  "name": "@anchorlib/vite-ssr",
+  "version": "1.0.0-beta.24",
+  "description": "Vite plugin that handles SSR rendering and IRPC routing for AIR Stack applications",
+  "keywords": ["vite", "ssr", "anchor", "irpc"],
+  "author": "Nanang Mahdaen El Agung <mahdaen@gmail.com>",
+  "homepage": "https://github.com/beerush-id/anchor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/beerush-id/anchor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/beerush-id/anchor/issues"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "directories": {
+    "dist": "./dist"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@anchorlib/core": "^1.0.0-beta.24",
+    "@irpclib/http": "^1.0.0-beta.24",
+    "@irpclib/irpc": "^1.0.0-beta.24",
+    "@irpclib/ws": "^1.0.0-beta.24",
+    "typescript": "^5.9.3",
+    "vite": ">=5"
+  },
+  "peerDependenciesMeta": {
+    "@anchorlib/core": {
+      "optional": true
+    },
+    "@irpclib/irpc": {
+      "optional": true
+    },
+    "@irpclib/http": {
+      "optional": true
+    },
+    "@irpclib/ws": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.3",
+    "@types/ws": "latest",
+    "publint": "0.3.15",
+    "rimraf": "6.0.1",
+    "tsdown": "0.15.9",
+    "vite": "8.0.10",
+    "ws": "latest"
+  },
+  "scripts": {
+    "dev": "rimraf dist && tsdown --watch ./src",
+    "clean": "rimraf dist",
+    "build": "rimraf dist && tsdown && publint",
+    "prepublish": "rimraf dist && tsdown && publint",
+    "format": "biome format --write"
+  }
+}

package/readme.md

@@ -0,0 +1,57 @@
+# @anchorlib/vite-ssr
+
+Vite plugin that handles SSR rendering and IRPC routing for AIR Stack applications.
+
+## Features
+
+- **SSR + IRPC** — Server-side rendering and RPC handling in one plugin
+- **Zero Boilerplate** — No manual server entry or renderer wiring needed
+- **Request Isolation** — Cookies, abort signals, and hooks scoped per request
+- **Hot Module Replacement** — Edit handlers and components without restarting the server
+- **Framework Agnostic** — Works with any renderer that exports `createSSR`
+
+## Installation
+
+```bash
+npm install @anchorlib/vite-ssr
+```
+
+## Usage
+
+```ts
+// vite.config.ts
+import { airSSR } from '@anchorlib/vite-ssr';
+
+export default defineConfig({
+  plugins: [
+    react(),
+    airSSR({
+      router: './src/lib/router.ts',
+      layout: './src/pages/layout.tsx',
+      renderer: '@anchorlib/react/ssr',
+      irpc: {
+        module: './src/lib/module.ts',
+        handlers: ['./src/pages/constructor.ts'],
+      },
+    }),
+  ],
+});
+```
+
+### Options
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| `router` | Yes | Path to the router module. Must `export default` a `Router` instance. |
+| `layout` | Yes | Path to the root layout module. Must `export default` a `RouteComponent`. |
+| `renderer` | Yes | Path to the renderer module (e.g., `'@anchorlib/react/ssr'`). Must export `createSSR`. |
+| `irpc.module` | No | IRPC instance. String for default export, `{ path, name }` for named export. |
+| `irpc.transport` | No | HTTP Transport instance. Same format as `module`. |
+| `irpc.wsTransport` | No | WebSocket Transport instance. Same format as `module`. |
+| `irpc.handlers` | No | Handler modules to load (e.g., `['./src/pages/constructor.ts']`). |
+| `headTag` | No | Placeholder for rendered head. Defaults to `<!--ssr-head-->`. |
+| `bodyTag` | No | Placeholder for rendered body. Defaults to `<!--ssr-outlet-->`. |
+
+## License
+
+MIT