nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-121649-98b56dfe

package/dist/node_modules/rendu/dist/index.mjs

@@ -0,0 +1,380 @@
+import { FastResponse } from "srvx";
+
+//#region src/parser.ts
+function parseTemplate(template) {
+	if (!template) return [];
+	template = template.replace(/<script\s+server\s*>([\s\S]*?)<\/script>/gi, (_m, code) => `<?js${code}?>`);
+	template = template.replace(/{{\s*(.+)\s*}}|{{{\s*(.+)\s*}}}/g, (_m, code) => {
+		if (code[0] === "{") return `<?=${code.slice(1, -1).trim()}?>`;
+		return `<?=htmlspecialchars(${code.trim()})?>`;
+	});
+	const tokens = [];
+	const re = /<\?(?:js)?(?<equals>=)?(?<value>[\s\S]*?)\?>/g;
+	let cursor = 0;
+	let match;
+	while (match = re.exec(template)) {
+		const { equals, value } = match.groups || {};
+		const matchStart = match.index;
+		const matchEnd = matchStart + match[0].length;
+		if (matchStart > cursor) {
+			const textContent = template.slice(cursor, matchStart);
+			if (textContent) tokens.push({
+				type: "text",
+				contents: textContent
+			});
+		}
+		if (equals) tokens.push({
+			type: "expr",
+			contents: value || ""
+		});
+		else tokens.push({
+			type: "code",
+			contents: value || ""
+		});
+		cursor = matchEnd;
+	}
+	if (cursor < template.length) {
+		const remainingText = template.slice(cursor);
+		if (remainingText) tokens.push({
+			type: "text",
+			contents: remainingText
+		});
+	}
+	return tokens;
+}
+/**
+* Check if a template string contains template syntax.
+*/
+function hasTemplateSyntax(template) {
+	return /(?:<script\s+server\s*>[\s\S]*?<\/script>)|(?:<\?(?:js)?=?[\s\S]*?\?>)|(?:\{\{[\s\S]*?\}\})/i.test(template);
+}
+
+//#endregion
+//#region src/_runtime.ts
+function runtimeStream(body) {
+	return `const __chunks__ = [];const echo = (chunk) => { __chunks__.push(chunk); };${body};
+function concatStreams(chunks) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async pull(controller) {
+      for (let chunk of chunks) {
+        if (typeof chunk === 'function'){
+          chunk = chunk();
+        }
+        if (chunk instanceof Promise) {
+          chunk = await chunk;
+          if (!chunk) continue;
+          if (chunk instanceof Response){
+              chunk = chunk.body;
+          }
+          if (!(chunk instanceof ReadableStream)) {
+            controller.enqueue(chunk instanceof Uint8Array ? chunk : encoder.encode(chunk));
+            continue;
+          }
+        }
+        if (chunk instanceof ReadableStream) {
+          const reader = chunk.getReader();
+          while (true) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            controller.enqueue(value);
+          }
+          reader.releaseLock();
+        } else {
+          controller.enqueue(chunk instanceof Uint8Array ? chunk : encoder.encode(chunk));
+        }
+      }
+      controller.close();
+    },
+});
+    }
+    return concatStreams(__chunks__);
+`;
+}
+function runtimeText(body) {
+	return `const __chunks__ = [];const echo = (chunk) => { __chunks__.push(chunk); };${body};
+let __out__ = "";
+for(let chunk of __chunks__){
+  if (typeof chunk === 'function'){
+    chunk = chunk();
+  }
+  if (chunk instanceof Promise){
+    chunk = await chunk;
+  }
+  if (chunk instanceof Response){
+    chunk = chunk.body;
+  }
+  if (chunk instanceof ReadableStream){
+    const reader = chunk.getReader();
+    while(true){
+      const {value, done} = await reader.read();
+      if(done) break;
+      __out__ += typeof value === "string" ? value : new TextDecoder().decode(value);
+    }
+    reader.releaseLock();
+  } else {
+    __out__ += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+  }
+}
+return __out__;
+    `;
+}
+
+//#endregion
+//#region src/compiler.ts
+/**
+* Compile a template string into a render function.
+*
+* @example
+* ```ts
+* import { compileTemplate } from "rendu";
+*
+* const template = `
+*   <h1>{{ title }}</h1>
+*   <ul>
+*   <? for (const item of items) { ?>
+*     <li>{{ item }}</li>
+*   <? } ?>
+*   </ul>
+* `;
+*
+* const render = compileTemplate(template, { stream: false });
+*
+* const html = await render({ title: "My List", items: ["Item 1", "Item 2", "Item 3"] });
+* console.log(html);
+* // Output:
+* // <h1>My List</h1>
+* // <ul>
+* //   <li>Item 1</li>
+* //   <li>Item 2</li>
+* //   <li>Item 3</li>
+* // </ul>
+* ```
+*/
+function compileTemplate(template, opts = {}) {
+	const body = compileTemplateToString(template, opts, false);
+	const sourcemaps = opts.filename ? `\n//# sourceURL=${opts.filename}` : "";
+	try {
+		const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+		return new AsyncFunction("__context__", body + sourcemaps);
+	} catch (error) {
+		throw new SyntaxError(`Template syntax error: ${error.message}`, {});
+	}
+}
+/**
+* Compile a template string into a render function code string.
+*
+* **Note:** This function is for advanced use cases where you need the generated code as a string.
+*/
+function compileTemplateToString(template, opts, asyncWrapper) {
+	const parts = [];
+	const tokens = parseTemplate(template);
+	for (const token of tokens) switch (token.type) {
+		case "text":
+			if (opts.preserveLines) for (const line of token.contents.split("\n")) parts.push(`echo(${JSON.stringify(line + "\n")})\n`);
+			else parts.push(`echo(${JSON.stringify(token.contents)})`);
+			break;
+		case "expr":
+			parts.push(`echo(${token.contents})`);
+			break;
+		case "code":
+			parts.push(token.contents);
+			break;
+	}
+	let body = parts.join(opts.preserveLines ? ";" : "\n");
+	body = opts.contextKeys ? `const {${opts.contextKeys.join(",")}}=__context__;${body}` : `with(__context__){${body}}`;
+	body = opts.stream === false ? runtimeText(body) : runtimeStream(body);
+	return asyncWrapper === false ? body : `(async (__context__) => {${body}})`;
+}
+
+//#endregion
+//#region node_modules/.pnpm/cookie-es@2.0.0/node_modules/cookie-es/dist/index.mjs
+function parse(str, options) {
+	if (typeof str !== "string") throw new TypeError("argument str must be a string");
+	const obj = {};
+	const opt = options || {};
+	const dec = opt.decode || decode;
+	let index = 0;
+	while (index < str.length) {
+		const eqIdx = str.indexOf("=", index);
+		if (eqIdx === -1) break;
+		let endIdx = str.indexOf(";", index);
+		if (endIdx === -1) endIdx = str.length;
+		else if (endIdx < eqIdx) {
+			index = str.lastIndexOf(";", eqIdx - 1) + 1;
+			continue;
+		}
+		const key = str.slice(index, eqIdx).trim();
+		if (opt?.filter && !opt?.filter(key)) {
+			index = endIdx + 1;
+			continue;
+		}
+		if (void 0 === obj[key]) {
+			let val = str.slice(eqIdx + 1, endIdx).trim();
+			if (val.codePointAt(0) === 34) val = val.slice(1, -1);
+			obj[key] = tryDecode(val, dec);
+		}
+		index = endIdx + 1;
+	}
+	return obj;
+}
+function decode(str) {
+	return str.includes("%") ? decodeURIComponent(str) : str;
+}
+function tryDecode(str, decode2) {
+	try {
+		return decode2(str);
+	} catch {
+		return str;
+	}
+}
+const fieldContentRegExp = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
+function serialize(name, value, options) {
+	const opt = options || {};
+	const enc = opt.encode || encodeURIComponent;
+	if (typeof enc !== "function") throw new TypeError("option encode is invalid");
+	if (!fieldContentRegExp.test(name)) throw new TypeError("argument name is invalid");
+	const encodedValue = enc(value);
+	if (encodedValue && !fieldContentRegExp.test(encodedValue)) throw new TypeError("argument val is invalid");
+	let str = name + "=" + encodedValue;
+	if (void 0 !== opt.maxAge && opt.maxAge !== null) {
+		const maxAge = opt.maxAge - 0;
+		if (Number.isNaN(maxAge) || !Number.isFinite(maxAge)) throw new TypeError("option maxAge is invalid");
+		str += "; Max-Age=" + Math.floor(maxAge);
+	}
+	if (opt.domain) {
+		if (!fieldContentRegExp.test(opt.domain)) throw new TypeError("option domain is invalid");
+		str += "; Domain=" + opt.domain;
+	}
+	if (opt.path) {
+		if (!fieldContentRegExp.test(opt.path)) throw new TypeError("option path is invalid");
+		str += "; Path=" + opt.path;
+	}
+	if (opt.expires) {
+		if (!isDate(opt.expires) || Number.isNaN(opt.expires.valueOf())) throw new TypeError("option expires is invalid");
+		str += "; Expires=" + opt.expires.toUTCString();
+	}
+	if (opt.httpOnly) str += "; HttpOnly";
+	if (opt.secure) str += "; Secure";
+	if (opt.priority) switch (typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority) {
+		case "low":
+			str += "; Priority=Low";
+			break;
+		case "medium":
+			str += "; Priority=Medium";
+			break;
+		case "high":
+			str += "; Priority=High";
+			break;
+		default: throw new TypeError("option priority is invalid");
+	}
+	if (opt.sameSite) switch (typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite) {
+		case true:
+			str += "; SameSite=Strict";
+			break;
+		case "lax":
+			str += "; SameSite=Lax";
+			break;
+		case "strict":
+			str += "; SameSite=Strict";
+			break;
+		case "none":
+			str += "; SameSite=None";
+			break;
+		default: throw new TypeError("option sameSite is invalid");
+	}
+	if (opt.partitioned) str += "; Partitioned";
+	return str;
+}
+function isDate(val) {
+	return Object.prototype.toString.call(val) === "[object Date]" || val instanceof Date;
+}
+
+//#endregion
+//#region src/render.ts
+/**
+* Renders an HTML template to a Response object.
+*
+* @example
+* ```ts
+* import { compileTemplate, renderToResponse } from "rendu";
+*
+* const render = compileTemplate(template, { stream: true });
+*
+* const response = await renderToResponse(render, { request });
+* ```
+* @param htmlTemplate The compiled HTML template.
+* @param opts Options for rendering.
+* @returns A Response object.
+*/
+async function renderToResponse(htmlTemplate, opts) {
+	const ctx = createRenderContext(opts);
+	const body = await htmlTemplate(ctx);
+	if (body instanceof Response) return body;
+	return new FastResponse(body, {
+		status: ctx.$RESPONSE.status,
+		statusText: ctx.$RESPONSE.statusText,
+		headers: ctx.$RESPONSE.headers
+	});
+}
+const RENDER_CONTEXT_KEYS = [
+	"htmlspecialchars",
+	"setCookie",
+	"redirect",
+	"$REQUEST",
+	"$METHOD",
+	"$URL",
+	"$HEADERS",
+	"$COOKIES",
+	"$RESPONSE"
+];
+function createRenderContext(options) {
+	const url = new URL(options.request?.url || "http://_");
+	const response = {
+		status: 200,
+		statusText: "OK",
+		headers: new Headers({ "Content-Type": "text/html ; charset=utf-8" })
+	};
+	const $COOKIES = lazyCookies(options.request);
+	const setCookie = (name, value, sOpts = {}) => {
+		response.headers.append("Set-Cookie", serialize(name, value, sOpts));
+	};
+	const redirect = (to, status = 302) => {
+		response.status = status;
+		response.headers.set("Location", to);
+	};
+	return {
+		...options.context,
+		htmlspecialchars,
+		setCookie,
+		redirect,
+		$REQUEST: options.request,
+		$METHOD: options.request?.method,
+		$URL: url,
+		$HEADERS: options.request?.headers,
+		$COOKIES,
+		$RESPONSE: response
+	};
+}
+function lazyCookies(req) {
+	if (!req) return {};
+	let parsed;
+	return new Proxy(Object.freeze(Object.create(null)), { get(_, prop) {
+		if (typeof prop !== "string") return void 0;
+		parsed ??= parse(req.headers.get("cookie") || "");
+		return parsed[prop];
+	} });
+}
+function htmlspecialchars(s) {
+	const htmlSpecialCharsMap = {
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#39;"
+	};
+	return String(s).replace(/[&<>"']/g, (c) => htmlSpecialCharsMap[c] || c);
+}
+
+//#endregion
+export { RENDER_CONTEXT_KEYS, compileTemplate, compileTemplateToString, createRenderContext, hasTemplateSyntax, renderToResponse };

package/dist/node_modules/rendu/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "rendu",
+  "version": "0.0.7",
+  "description": "",
+  "repository": "h3js/rendu",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "types": "./dist/index.d.mts",
+  "bin": "./dist/cli.mjs",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier -c .",
+    "lint:fix": "automd && eslint . --fix && prettier -w .",
+    "prepack": "pnpm build",
+    "play": "pnpm rendu playground",
+    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
+    "rendu": "node ./src/cli.ts",
+    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "test:types": "tsc --noEmit --skipLibCheck"
+  },
+  "dependencies": {
+    "srvx": "^0.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.1",
+    "@vitest/coverage-v8": "^4.0.4",
+    "automd": "^0.4.2",
+    "changelogen": "^0.6.2",
+    "cookie-es": "^2.0.0",
+    "eslint": "^9.38.0",
+    "eslint-config-unjs": "^0.5.0",
+    "obuild": "^0.3.0",
+    "prettier": "^3.6.2",
+    "rendu": "^0.0.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.4"
+  },
+  "packageManager": "pnpm@10.19.0"
+}

package/dist/presets/_nitro/runtime/nitro-dev.d.mts

@@ -1 +1,2 @@
 import "#nitro-internal-pollyfills";
+export {};

package/dist/presets/_nitro/runtime/nitro-dev.mjs

@@ -1,62 +1,68 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { trapUnhandledNodeErrors } from "nitro/runtime/internal";
 import { startScheduleRunner } from "nitro/runtime/internal";
 import { Server } from "node:http";
-import nodeCrypto from "node:crypto";
 import { parentPort, threadId } from "node:worker_threads";
 import wsAdapter from "crossws/adapters/node";
 import { toNodeHandler } from "srvx/node";
 import { getSocketAddress, isSocketSupported } from "get-port-please";
-if (!globalThis.crypto) {
-  globalThis.crypto = nodeCrypto;
-}
+// Trap unhandled errors
 trapUnhandledNodeErrors();
+// Listen for shutdown signal from runner
 parentPort?.on("message", (msg) => {
-  if (msg && msg.event === "shutdown") {
-    shutdown();
-  }
+	if (msg && msg.event === "shutdown") {
+		shutdown();
+	}
 });
 const nitroApp = useNitroApp();
+const nitroHooks = useNitroHooks();
 const server = new Server(toNodeHandler(nitroApp.fetch));
 let listener;
 listen().catch((error) => {
-  console.error("Dev worker failed to listen:", error);
-  return shutdown();
+	console.error("Dev worker failed to listen:", error);
+	return shutdown();
 });
+// https://crossws.unjs.io/adapters/node
 if (import.meta._websocket) {
-  const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
-  server.on("upgrade", handleUpgrade);
+	// @ts-expect-error
+	const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
+	server.on("upgrade", handleUpgrade);
 }
+// Scheduled tasks
 if (import.meta._tasks) {
-  startScheduleRunner();
+	startScheduleRunner();
 }
+// --- utils ---
 async function listen() {
-  const listenAddr = await isSocketSupported() ? getSocketAddress({
-    name: `nitro-dev-${threadId}`,
-    pid: true,
-    random: true
-  }) : { port: 0, host: "localhost" };
-  return new Promise((resolve, reject) => {
-    try {
-      listener = server.listen(listenAddr, () => {
-        const address = server.address();
-        parentPort?.postMessage({
-          event: "listen",
-          address: typeof address === "string" ? { socketPath: address } : { host: "localhost", port: address?.port }
-        });
-        resolve();
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
+	const listenAddr = await isSocketSupported() ? getSocketAddress({
+		name: `nitro-dev-${threadId}`,
+		pid: true,
+		random: true
+	}) : {
+		port: 0,
+		host: "localhost"
+	};
+	return new Promise((resolve, reject) => {
+		try {
+			listener = server.listen(listenAddr, () => {
+				const address = server.address();
+				parentPort?.postMessage({
+					event: "listen",
+					address: typeof address === "string" ? { socketPath: address } : {
+						host: "localhost",
+						port: address?.port
+					}
+				});
+				resolve();
+			});
+		} catch (error) {
+			reject(error);
+		}
+	});
 }
 async function shutdown() {
-  server.closeAllConnections?.();
-  await Promise.all([
-    new Promise((resolve) => listener?.close(resolve)),
-    nitroApp.hooks.callHook("close").catch(console.error)
-  ]);
-  parentPort?.postMessage({ event: "exit" });
+	server.closeAllConnections?.();
+	await Promise.all([new Promise((resolve) => listener?.close(resolve)), nitroHooks.callHook("close")]).catch(console.error);
+	parentPort?.postMessage({ event: "exit" });
 }

package/dist/presets/_nitro/runtime/nitro-prerenderer.d.mts

@@ -1,3 +1,3 @@
 import "#nitro-internal-pollyfills";
-export declare const appFetch: any;
-export declare const closePrerenderer: () => any;
+export declare const appFetch: unknown;
+export declare const closePrerenderer: unknown;

package/dist/presets/_nitro/runtime/nitro-prerenderer.mjs

@@ -1,18 +1,15 @@
 import "#nitro-internal-pollyfills";
 import consola from "consola";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { trapUnhandledNodeErrors } from "nitro/runtime/internal";
 const nitroApp = useNitroApp();
-export const appFetch = nitroApp.fetch;
-export const closePrerenderer = () => nitroApp.hooks.callHook("close");
-nitroApp.hooks.hook("error", (error, context) => {
-  if (!error.unhandled && error.status >= 500 && context.event?.req?.headers instanceof Headers && context.event.req.headers.get("x-nitro-prerender")) {
-    consola.error(
-      `[prerender error]`,
-      `[${context.event.req.method}]`,
-      `[${context.event.req.url}]`,
-      error
-    );
-  }
+const nitroHooks = useNitroHooks();
+export const appFetch = nitroApp.request;
+export const closePrerenderer = () => nitroHooks.callHook("close");
+nitroHooks.hook("error", (error, context) => {
+	if (!error.unhandled && error.status >= 500 && context.event?.req?.headers instanceof Headers && context.event.req.headers.get("x-nitro-prerender")) {
+		consola.error(`[prerender error]`, `[${context.event.req.method}]`, `[${context.event.req.url}]`, error);
+	}
 });
+// Trap unhandled errors
 trapUnhandledNodeErrors();

package/dist/presets/_nitro/runtime/service-worker.d.mts

@@ -1 +1,2 @@
 import "#nitro-internal-pollyfills";
+export {};

package/dist/presets/_nitro/runtime/service-worker.mjs

@@ -2,20 +2,23 @@ import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
 import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
 const nitroApp = useNitroApp();
+// @ts-expect-error
 addEventListener("fetch", (event) => {
-  const url = new URL(event.request.url);
-  if (isPublicAssetURL(url.pathname) || url.pathname.includes("/_server/")) {
-    return;
-  }
-  const req = event.request;
-  req.runtime ??= { name: "service-worker" };
-  req.runtime.serviceWorker ??= { event };
-  req.waitUntil = event.waitUntil.bind(event);
-  event.respondWith(nitroApp.fetch(req));
+	const url = new URL(event.request.url);
+	if (isPublicAssetURL(url.pathname) || url.pathname.includes("/_server/")) {
+		return;
+	}
+	// srvx compatibility
+	const req = event.request;
+	req.runtime ??= { name: "service-worker" };
+	// @ts-expect-error (add to srvx types)
+	req.runtime.serviceWorker ??= { event };
+	req.waitUntil = event.waitUntil.bind(event);
+	event.respondWith(nitroApp.fetch(req));
 });
 self.addEventListener("install", () => {
-  self.skipWaiting();
+	self.skipWaiting();
 });
 self.addEventListener("activate", (event) => {
-  event.waitUntil(self.clients.claim());
+	event.waitUntil(self.clients.claim());
 });

package/dist/presets/aws-amplify/runtime/aws-amplify.d.mts

@@ -1 +1,2 @@
 import "#nitro-internal-pollyfills";
+export {};

package/dist/presets/aws-amplify/runtime/aws-amplify.mjs

@@ -4,10 +4,11 @@ import { Server } from "node:http";
 import { toNodeHandler } from "srvx/node";
 const nitroApp = useNitroApp();
 const server = new Server(toNodeHandler(nitroApp.fetch));
+// @ts-ignore
 server.listen(3e3, (err) => {
-  if (err) {
-    console.error(err);
-  } else {
-    console.log(`Listening on http://localhost:3000 (AWS Amplify Hosting)`);
-  }
+	if (err) {
+		console.error(err);
+	} else {
+		console.log(`Listening on http://localhost:3000 (AWS Amplify Hosting)`);
+	}
 });

package/dist/presets/aws-lambda/runtime/_utils.d.mts

@@ -1,18 +1,13 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventV2 } from "aws-lambda";
 import type { ServerRequest } from "srvx";
+// Incoming (AWS => Web)
 export declare function awsRequest(event: APIGatewayProxyEvent | APIGatewayProxyEventV2, context: unknown): ServerRequest;
-export declare function awsResponseHeaders(response: Response): {
-    headers: any;
-    cookies: string[];
-    multiValueHeaders: {
-        "set-cookie": string[];
-    };
-} | {
-    headers: any;
-    cookies?: undefined;
-    multiValueHeaders?: undefined;
-};
+// Outgoing (Web => AWS)
+export declare function awsResponseHeaders(response: Response);
+// AWS Lambda proxy integrations requires base64 encoded buffers
+// binaryMediaTypes should be */*
+// see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html
 export declare function awsResponseBody(response: Response): Promise<{
-    body: string;
-    isBase64Encoded?: boolean;
+	body: string;
+	isBase64Encoded?: boolean;
 }>;