@torpor/build 1.0.0 → 1.0.2

package/src/server/connect/nodeMessageToNodeResponse.ts

@@ -1,89 +0,0 @@
-import {
-	type IncomingMessage,
-	type OutgoingHttpHeader,
-	type OutgoingHttpHeaders,
-	ServerResponse,
-} from "node:http";
-import { PassThrough, Readable } from "node:stream";
-
-// From https://github.com/vikejs/vike-node/blob/main/packages/vike-node/src/runtime/adapters/createServerResponse.ts
-
-/**
- * Creates a custom ServerResponse object that allows for intercepting and
- * streaming the response.
- *
- * @param incomingMessage The incoming HTTP request message.
- * @returns An object containing the custom ServerResponse and a function that
- * takes a callback to invoke when the response is readable, providing an object
- * with the readable stream, headers and status code.
- */
-export default function nodeMessageToNodeResponse(
-	incomingMessage: IncomingMessage,
-): ServerResponseResponse {
-	const res = new ServerResponse(incomingMessage);
-	const passThrough = new PassThrough();
-	let handled = false;
-
-	const onReadable = (
-		cb: (result: { readable: Readable; headers: OutgoingHttpHeaders; status: number }) => void,
-	) => {
-		const handleReadable = () => {
-			if (handled) return;
-			handled = true;
-			cb({
-				readable: Readable.from(passThrough),
-				headers: res.getHeaders(),
-				status: res.statusCode,
-			});
-		};
-
-		passThrough.once("readable", handleReadable);
-		passThrough.once("end", handleReadable);
-	};
-
-	passThrough.once("finish", () => {
-		res.emit("finish");
-	});
-	passThrough.once("close", () => {
-		res.destroy();
-		res.emit("close");
-	});
-	passThrough.on("drain", () => {
-		res.emit("drain");
-	});
-
-	res.write = passThrough.write.bind(passThrough);
-	res.end = passThrough.end.bind(passThrough) as any;
-
-	res.writeHead = function writeHead(
-		statusCode: number,
-		statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeader[],
-		headers?: OutgoingHttpHeaders | OutgoingHttpHeader[],
-	): ServerResponse {
-		res.statusCode = statusCode;
-		if (typeof statusMessage === "object") {
-			headers = statusMessage;
-			statusMessage = undefined;
-		}
-		if (headers) {
-			for (const [key, value] of Object.entries(headers)) {
-				if (value !== undefined) {
-					res.setHeader(key, value);
-				}
-			}
-		}
-		return res;
-	};
-
-	return {
-		res,
-		onReadable,
-	};
-}
-
-interface ServerResponseResponse {
-	res: ServerResponse;
-	onReadable: (
-		cb: (result: { readable: Readable; headers: OutgoingHttpHeaders; status: number }) => void,
-	) => void;
-}

package/src/server/connect/requestToNodeMessage.ts

@@ -1,29 +0,0 @@
-import { type IncomingMessage } from "node:http";
-import { Readable } from "node:stream";
-
-// From https://github.com/vikejs/vike-node/blob/main/packages/vike-node/src/runtime/adapters/connectToWeb.ts
-
-const DUMMY_BASE_URL = "http://localhost";
-
-/**
- * Creates an IncomingMessage object from a web Request.
- *
- * The request body is intentionally not forwarded: this is only used to wrap
- * Connect-style middlewares (e.g. Vite's dev middleware), which don't read
- * the body. The actual route handler later reads `ev.request.body` directly,
- * and forwarding the body here would consume it and break the handler.
- *
- * @param {Request} request - The web Request object.
- * @returns {IncomingMessage} An IncomingMessage-like object compatible with Node.js HTTP module.
- */
-export default function requestToNodeMessage(request: Request): IncomingMessage {
-	const parsedUrl = new URL(request.url, DUMMY_BASE_URL);
-	const pathAndQuery = (parsedUrl.pathname || "") + (parsedUrl.search || "");
-	const body = Readable.from([]);
-
-	return Object.assign(body, {
-		url: pathAndQuery,
-		method: request.method,
-		headers: Object.fromEntries(request.headers),
-	}) as IncomingMessage;
-}

package/src/server/contentType.ts

@@ -1,85 +0,0 @@
-// From https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types/Common_types
-
-export default function contentType(extension: string): string {
-	return types[extension] || "application/octet-stream";
-}
-
-const types: Record<string, string> = {
-	".aac": "audio/aac",
-	".abw": "application/x-abiword",
-	".apng": "image/apng",
-	".arc": "application/x-freearc",
-	".avif": "image/avif",
-	".avi": "video/x-msvideo",
-	".azw": "application/vnd.amazon.ebook",
-	".bin": "application/octet-stream",
-	".bmp": "image/bmp",
-	".bz": "application/x-bzip",
-	".bz2": "application/x-bzip2",
-	".cda": "application/x-cdf",
-	".csh": "application/x-csh",
-	".css": "text/css",
-	".csv": "text/csv",
-	".doc": "application/msword",
-	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-	".eot": "application/vnd.ms-fontobject",
-	".epub": "application/epub+zip",
-	".gz": "application/gzip",
-	".gif": "image/gif",
-	".htm": "text/html",
-	".html": "text/html",
-	".ico": "image/vnd.microsoft.icon",
-	".ics": "text/calendar",
-	".jar": "application/java-archive",
-	".jpeg": "image/jpeg",
-	".jpg": "image/jpeg",
-	".js": "text/javascript",
-	".json": "application/json",
-	".jsonld": "application/ld+json",
-	".mid": "audio/midi",
-	".midi": "audio/midi",
-	".mjs": "text/javascript",
-	".mp3": "audio/mpeg",
-	".mp4": "video/mp4",
-	".mpeg": "video/mpeg",
-	".mpkg": "application/vnd.apple.installer+xml",
-	".odp": "application/vnd.oasis.opendocument.presentation",
-	".ods": "application/vnd.oasis.opendocument.spreadsheet",
-	".odt": "application/vnd.oasis.opendocument.text",
-	".oga": "audio/ogg",
-	".ogv": "video/ogg",
-	".ogx": "application/ogg",
-	".opus": "audio/ogg",
-	".otf": "font/otf",
-	".png": "image/png",
-	".pdf": "application/pdf",
-	".php": "application/x-httpd-php",
-	".ppt": "application/vnd.ms-powerpoint",
-	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-	".rar": "application/vnd.rar",
-	".rtf": "application/rtf",
-	".sh": "application/x-sh",
-	".svg": "image/svg+xml",
-	".tar": "application/x-tar",
-	".tif": "image/tiff",
-	".tiff": "image/tiff",
-	".ts": "video/mp2t",
-	".ttf": "font/ttf",
-	".txt": "text/plain",
-	".vsd": "application/vnd.visio",
-	".wav": "audio/wav",
-	".weba": "audio/webm",
-	".webm": "video/webm",
-	".webp": "image/webp",
-	".woff": "font/woff",
-	".woff2": "font/woff2",
-	".xhtml": "application/xhtml+xml",
-	".xls": "application/vnd.ms-excel",
-	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-	".xml": "application/xml",
-	".xul": "application/vnd.mozilla.xul+xml",
-	".zip": "application/zip",
-	".3gp": "video/3gpp",
-	".3g2": "video/3gpp2",
-	".7z": "application/x-7z-compressed",
-};

package/src/server/types/HttpMethod.ts

@@ -1,12 +0,0 @@
-type HttpMethod =
-	| "GET"
-	| "HEAD"
-	| "PATCH"
-	| "POST"
-	| "PUT"
-	| "DELETE"
-	| "OPTIONS"
-	| "CONNECT"
-	| "TRACE";
-
-export default HttpMethod;

package/src/server/types/MiddlewareFunction.ts

@@ -1,22 +0,0 @@
-import ServerEvent from "../ServerEvent";
-
-type MiddlewareFunction = {
-	/**
-	 * Called before the route handler. Middleware are run in the order they
-	 * were added. Return a Response to short-circuit the request; the
-	 * remaining middleware and the route handler are then skipped.
-	 */
-	enter?: (ev: ServerEvent) => Response | void | Promise<Response | void>;
-	/**
-	 * Called after the route handler (even if it threw), in reverse order.
-	 * Return a Response to replace the response. Middleware that were skipped
-	 * by a short-circuit don't get their exit hook run.
-	 *
-	 * If the route handler (or a later enter hook) threw, the error is
-	 * available as `ev.error`; returning a Response handles the error and
-	 * stops it from propagating.
-	 */
-	exit?: (ev: ServerEvent) => Response | void | Promise<Response | void>;
-};
-
-export default MiddlewareFunction;

package/src/server/types/ServerFunction.ts

@@ -1,7 +0,0 @@
-import ServerEvent from "../ServerEvent";
-
-type ServerFunction = (
-	e: ServerEvent,
-) => Response | undefined | void | Promise<Response | undefined | void>;
-
-export default ServerFunction;

package/src/server.ts

@@ -1,7 +0,0 @@
-import CookieHelper from "./server/CookieHelper";
-import HeaderHelper from "./server/HeaderHelper";
-import Server from "./server/Server";
-import ServerEvent from "./server/ServerEvent";
-import connectMiddleware from "./server/connect/connectMiddleware";
-
-export { Server, ServerEvent, CookieHelper, HeaderHelper, connectMiddleware };

package/src/site/Router.ts

@@ -1,175 +0,0 @@
-import type LayoutHandler from "../types/LayoutHandler";
-import type ManifestRoute from "../types/ManifestRoute";
-import type RouteHandler from "../types/RouteHandler";
-import PathTrie from "../utils/pathTrie";
-
-/**
- * A router that handles file routes with layouts, hooks, etc.
- */
-export default class Router {
-	routes: Route[] = [];
-	// Match index for the routes above. The routes list is kept for
-	// introspection (layouts/hooks lookup, client nav, tests); the trie is
-	// what `match` walks.
-	#trie = new PathTrie<Route>();
-
-	constructor() {}
-
-	//add(path: string, file: string) {
-	//	// TODO: Call the specific addX method based on the file path
-	//	this.addPage(route, file);
-	//}
-
-	addPages(routes: ManifestRoute[]): this {
-		for (let r of routes) {
-			this.addPage(r.path, r.type, r.endPoint, r.subFolder);
-		}
-		return this;
-	}
-
-	// TODO: Allow calling with the endpoint itself, so that you can setup an app with no scaffold
-	addPage(path: string, type: number, endPoint: () => Promise<any>, subFolder?: string): this {
-		let route = new Route(path, {
-			path,
-			type,
-			endPoint,
-			subFolder,
-		});
-		this.routes.push(route);
-		this.#trie.insert(path, route);
-		this.#sortRoutes();
-		return this;
-	}
-
-	/*
-	loadPage(ev: ServerEvent, file: string): Response {
-		let page = this.pages.get(file);
-		if (!page) {
-			page = {};
-			this.pages.set(file, page);
-		}
-	}
-	*/
-
-	match(path: string, query: URLSearchParams): RouteMatch | undefined {
-		let found = this.#trie.match(path);
-		if (found) {
-			let route = found.value;
-			// Lazy load server endpoints and layouts
-			if (!route.handler.loaded) {
-				this.#loadHandler(route.handler, route.path);
-			}
-
-			return {
-				handler: route.handler,
-				params: found.params,
-				query,
-			};
-		}
-	}
-
-	#loadHandler(handler: RouteHandler, path: string) {
-		handler.layouts = this.#findLayouts(path, handler);
-		handler.serverEndPoint = this.#findServer(path);
-		handler.serverHooks = this.#findServerHooks(handler);
-	}
-
-	#findLayouts(path: string, handler: RouteHandler): LayoutHandler[] | undefined {
-		let layouts: LayoutHandler[] = [];
-		let parts = path
-			// Strip the trailing`~/server` (so we don't look for `~/server/_layout`
-			// which will never exist)
-			.replace(/\/~server$/, "")
-			// The path will always start with / so splitting e.g. `/first/second`
-			// will result in ['', 'first', 'second'] and checks for `/_layout`,
-			// `/first/_layout` and `/second/_layout`
-			.split("/");
-		let basePath = "";
-		for (let i = 0; i < parts.length; i++) {
-			if (i > 0) {
-				basePath += "/" + parts[i];
-			}
-			const layoutPath = basePath + "/_layout";
-			const layoutRoute = this.routes.find((r) => r.path === layoutPath);
-			if (layoutRoute && layoutRoute.handler.subFolder === handler.subFolder) {
-				layouts.push({
-					path: layoutPath,
-					endPoint: layoutRoute.handler.endPoint,
-					serverEndPoint: this.#findServer(layoutPath),
-				});
-			}
-		}
-		return layouts.length ? layouts : undefined;
-	}
-
-	#findServer(path: string): (() => Promise<any>) | undefined {
-		const serverPath = path.replace(/\/$/, "") + "/~server";
-		const serverRoute = this.routes.find((r) => r.path === serverPath);
-		return serverRoute && serverRoute.handler.endPoint;
-	}
-
-	#findServerHooks(handler: RouteHandler): (() => Promise<any>)[] | undefined {
-		// Collect the hooks from the root down to the route path, like
-		// layouts. Only hooks with the same subFolder are included, so that
-		// e.g. an `api` set of routes can have its own hooks
-		const hooks: (() => Promise<any>)[] = [];
-		let parts = handler.path
-			// Strip the trailing `~server` (so we don't look for
-			// `~server/_hook/~server` which will never exist)
-			.replace(/\/~server$/, "")
-			// The path will always start with / so splitting e.g.
-			// `/first/second` will result in ['', 'first', 'second'] and
-			// checks for `/_hook/~server`, `/first/_hook/~server` and
-			// `/second/_hook/~server`
-			.split("/");
-		let basePath = "";
-		for (let i = 0; i < parts.length; i++) {
-			if (i > 0) {
-				basePath += "/" + parts[i];
-			}
-			const hookPath = basePath + "/_hook/~server";
-			const hookRoute = this.routes.find((r) => r.path === hookPath);
-			if (hookRoute && hookRoute.handler.subFolder === handler.subFolder) {
-				hooks.push(hookRoute.handler.endPoint);
-			}
-		}
-		return hooks.length ? hooks : undefined;
-	}
-
-	// HACK: We're doing this here as well as in Site, so that you can use the
-	// Router externally without Site
-	#sortRoutes() {
-		this.routes = this.routes.sort((a, b) => {
-			// Sort [param]s after paths
-			// There might be a quicker/easier way to do this
-			for (let i = 0; i < Math.min(a.path.length, b.path.length); i++) {
-				if (a.path[i] === "[" && b.path[i] !== "[") {
-					return 1;
-				} else if (b.path[i] === "[" && a.path[i] !== "[") {
-					return -1;
-				} else if (a.path[i] === b.path[i]) {
-					// Keep going...
-				} else {
-					return a.path[i].localeCompare(b.path[i]);
-				}
-			}
-			return a.path.length - b.path.length;
-		});
-	}
-}
-
-class Route {
-	path: string;
-	handler: RouteHandler;
-
-	constructor(path: string, handler: RouteHandler) {
-		this.path = path;
-		this.handler = handler;
-	}
-}
-
-interface RouteMatch {
-	handler: RouteHandler;
-	params?: Record<string, string>;
-	query: URLSearchParams;
-}