@torpor/build 1.0.0 → 1.0.1

package/src/types/StandardSchema.ts

@@ -1,109 +0,0 @@
-/**
- * The Standard Schema interface, per the spec at https://standardschema.dev.
- *
- * It is implemented by Zod, Valibot, ArkType, Effect Schema and others, so
- * endpoints can validate request bodies with whichever library they prefer
- * without this package depending on any of them.
- */
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-	readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-
-export declare namespace StandardSchemaV1 {
-	/** The Standard Schema props interface. */
-	export interface Props<Input = unknown, Output = Input> {
-		/**
-		 * The Standard Schema version.
-		 */
-		readonly version: 1;
-		/**
-		 * The vendor name of the schema library.
-		 */
-		readonly vendor: string;
-		/**
-		 * Validates unknown input values and returns the parsed output.
-		 */
-		readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-		/**
-		 * Inferred types associated with the schema.
-		 */
-		readonly types?: Types<Input, Output> | undefined;
-	}
-
-	/**
-	 * The result of a validation: a success with a value, or a failure with
-	 * issues.
-	 */
-	export type Result<Output> = SuccessResult<Output> | FailureResult;
-
-	/**
-	 * The result of a successful validation.
-	 */
-	export interface SuccessResult<Output> {
-		/**
-		 * The typed output value.
-		 */
-		readonly value: Output;
-		/**
-		 * Only set when there are issues, so a success can be tested with
-		 * `if (result.issues)`.
-		 */
-		readonly issues?: undefined;
-	}
-
-	/**
-	 * The result of a failed validation.
-	 */
-	export interface FailureResult {
-		/**
-		 * The issues detected during validation.
-		 */
-		readonly issues: ReadonlyArray<Issue>;
-	}
-
-	/**
-	 * An issue encountered during validation.
-	 */
-	export interface Issue {
-		/**
-		 * The error message.
-		 */
-		readonly message: string;
-		/**
-		 * The path to the property the issue belongs to.
-		 */
-		readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-	}
-
-	/**
-	 * A segment of the path to an issue.
-	 */
-	export interface PathSegment {
-		/**
-		 * The key of the property.
-		 */
-		readonly key: PropertyKey;
-	}
-
-	/**
-	 * The input and output types inferred from a schema.
-	 */
-	export interface Types<Input = unknown, Output = Input> {
-		readonly input: Input;
-		readonly output: Output;
-	}
-
-	/**
-	 * Infers the input type of a schema.
-	 */
-	export type InferInput<Schema extends StandardSchemaV1> = NonNullable<
-		Schema["~standard"]["types"]
-	>["input"];
-
-	/**
-	 * Infers the output type of a schema.
-	 */
-	export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<
-		Schema["~standard"]["types"]
-	>["output"];
-}

package/src/utils/pathToRegex.ts

@@ -1,17 +0,0 @@
-export default function pathToRegex(path: string): RegExp {
-	const pattern =
-		path
-			.split("/")
-			// Replace `[slug]` (and `[...splat]`) with named capture groups
-			.map((p) => {
-				return p.replace(/\[(\.\.\.)?([^/]+?)\]/, (_, splat, name) =>
-					splat ? `(?<${name as string}>.+)` : `(?<${name as string}>[^\\/]+?)`,
-				);
-			})
-			.join("\\/")
-			// Replace globs with regex syntax
-			.replaceAll("*", ".*") +
-		// Ignore trailing slashes -- `/path` should be treated the same as `/path/`
-		"/*";
-	return new RegExp(`^${pattern}/*$`);
-}

package/src/utils/pathTrie.ts

@@ -1,182 +0,0 @@
-/**
- * A simple trie router for path patterns.
- *
- * Pattern segments:
- * - `posts` — static segment
- * - `[id]` — matches one non-empty path segment, captured as `params.id`
- * - `[...path]` — matches the rest of the path (at least one segment),
- *   captured as `params.path`
- * - `*` — matches the rest of the path (possibly nothing), not captured
- * - `*.css` — a segment with an embedded `*` matches one path segment
- *
- * `*` and `[...]` must be the last segment of a pattern. Matching priority at
- * each level is static, then param, then glob, then rest. Trailing slashes are
- * ignored, so `/posts` and `/posts/` match the same route.
- */
-export default class PathTrie<T> {
-	#root = new TrieNode<T>();
-
-	/**
-	 * Registers a value at a path pattern. The first registration of an exact
-	 * pattern wins, matching the previous regex-scanning router.
-	 */
-	insert(pattern: string, value: T): void {
-		let node = this.#root;
-		const segments = splitPath(pattern);
-		for (let i = 0; i < segments.length; i++) {
-			const segment = segments[i];
-			if (segment === "*") {
-				if (i !== segments.length - 1) {
-					throw new Error(`The '*' wildcard must be the last segment of a path: ${pattern}`);
-				}
-				node.rest ??= { name: undefined, allowEmpty: true, child: new TrieNode() };
-				node = node.rest.child;
-			} else if (segment.startsWith("[...") && segment.endsWith("]")) {
-				if (i !== segments.length - 1) {
-					throw new Error(`The '[...x]' splat must be the last segment of a path: ${pattern}`);
-				}
-				node.rest ??= {
-					name: segment.slice(4, -1),
-					allowEmpty: false,
-					child: new TrieNode(),
-				};
-				node = node.rest.child;
-			} else if (segment.startsWith("[") && segment.endsWith("]")) {
-				node.param ??= { name: segment.slice(1, -1), child: new TrieNode() };
-				node = node.param.child;
-			} else if (segment.includes("*")) {
-				node.glob ??= { regex: globToRegex(segment), child: new TrieNode() };
-				node = node.glob.child;
-			} else {
-				node.static ??= new Map();
-				let child = node.static.get(segment);
-				if (!child) {
-					child = new TrieNode();
-					node.static.set(segment, child);
-				}
-				node = child;
-			}
-		}
-		node.value ??= value;
-	}
-
-	/**
-	 * Matches a request path against the trie. Returns the registered value
-	 * and any captured params, or undefined when nothing matches.
-	 */
-	match(path: string): PathMatch<T> | undefined {
-		// Trailing slashes are optional: `/posts/` matches `/posts`. Whether
-		// there WAS a trailing separator still matters for a trailing bare
-		// `*`, which requires one (e.g. `/assets/*` matches `/assets/` but
-		// not `/assets`)
-		let trailingSlash = path === "/";
-		while (path.length > 1 && path.endsWith("/")) {
-			path = path.slice(0, -1);
-			trailingSlash = true;
-		}
-		const segments = path === "/" ? [] : splitPath(path);
-		return this.#matchNode(this.#root, segments, 0, {}, trailingSlash);
-	}
-
-	#matchNode(
-		node: TrieNode<T>,
-		segments: string[],
-		i: number,
-		params: Record<string, string>,
-		trailingSlash: boolean,
-	): PathMatch<T> | undefined {
-		if (i === segments.length) {
-			if (node.value !== undefined) {
-				return { value: node.value, params: orUndefined(params) };
-			}
-			// A trailing bare `*` also matches nothing, when the path ended
-			// with its separator (e.g. `/assets/*` matches `/assets/`)
-			const rest = node.rest;
-			if (rest?.allowEmpty && trailingSlash && rest.child.value !== undefined) {
-				return { value: rest.child.value, params: orUndefined(params) };
-			}
-			return undefined;
-		}
-
-		const segment = segments[i];
-
-		// Static segments win over params
-		const stat = node.static?.get(segment);
-		if (stat) {
-			const match = this.#matchNode(stat, segments, i + 1, params, trailingSlash);
-			if (match) return match;
-		}
-
-		if (node.param && segment !== "") {
-			const match = this.#matchNode(node.param.child, segments, i + 1, {
-				...params,
-				[node.param.name]: segment,
-			}, trailingSlash);
-			if (match) return match;
-		}
-
-		if (node.glob?.regex.test(segment)) {
-			const glob = node.glob;
-			const match = this.#matchNode(glob.child, segments, i + 1, params, trailingSlash);
-			if (match) return match;
-		}
-
-		// The rest matcher consumes all remaining segments
-		const rest = node.rest;
-		if (rest?.child.value !== undefined) {
-			// Only build the captured value (and a new params object) when the
-			// pattern actually names it — a bare `*` catch-all shouldn't pay
-			// for a slice+join on every request
-			if (rest.name !== undefined) {
-				return {
-					value: rest.child.value,
-					params: orUndefined({ ...params, [rest.name]: segments.slice(i).join("/") }),
-				};
-			}
-			return { value: rest.child.value, params: orUndefined(params) };
-		}
-
-		return undefined;
-	}
-}
-
-export interface PathMatch<T> {
-	value: T;
-	params: Record<string, string> | undefined;
-}
-
-class TrieNode<T> {
-	value: T | undefined = undefined;
-	static: Map<string, TrieNode<T>> | undefined;
-	param: { name: string; child: TrieNode<T> } | undefined;
-	glob: { regex: RegExp; child: TrieNode<T> } | undefined;
-	rest: { name: string | undefined; allowEmpty: boolean; child: TrieNode<T> } | undefined;
-}
-
-/**
- * Splits a path or pattern into segments, dropping the leading empty segment
- * and any trailing empty (from a trailing slash). `/posts/5` becomes
- * `["posts", "5"]` and `/` becomes `[]`.
- */
-function splitPath(path: string): string[] {
-	const segments = path.split("/");
-	if (segments[0] === "") segments.shift();
-	if (segments.length && segments[segments.length - 1] === "") segments.pop();
-	return segments;
-}
-
-/**
- * Compiles a pattern segment with an embedded `*` (e.g. `*.css`) into a
- * regex that matches a single path segment.
- */
-function globToRegex(segment: string): RegExp {
-	const source = segment
-		.split("*")
-		.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-		.join(".*");
-	return new RegExp(`^${source}$`);
-}
-
-function orUndefined(params: Record<string, string>): Record<string, string> | undefined {
-	return Object.keys(params).length ? params : undefined;
-}

package/src/utils/searchParamsToRecord.ts

@@ -1,18 +0,0 @@
-import type { QueryRecord } from "../types/ServerLoadEvent";
-
-/**
- * Converts a URL's query string into a plain record: one string per param,
- * or an array when a param was repeated.
- *
- * @param searchParams The URL's search params
- * @returns The param values
- */
-export default function searchParamsToRecord(searchParams: URLSearchParams): QueryRecord {
-	const result: QueryRecord = {};
-	for (const key of searchParams.keys()) {
-		if (key in result) continue;
-		const values = searchParams.getAll(key);
-		result[key] = values.length > 1 ? values : values[0];
-	}
-	return result;
-}

package/src/utils/torporPackages.ts

@@ -1,150 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { createRequire, isBuiltin } from "node:module";
-import path from "node:path";
-import type { UserConfig } from "vite";
-
-export type PackageJson = {
-	name?: string;
-	torpor?: string;
-	exports?: unknown;
-	dependencies?: Record<string, string>;
-	devDependencies?: Record<string, string>;
-	optionalDependencies?: Record<string, string>;
-	peerDependencies?: Record<string, string>;
-	[key: string]: unknown;
-};
-
-/**
- * Finds packages installed in the site that ship `.torp` files, e.g. icon
- * libraries like phosphor-torpor. These packages need the torpor compiler, so
- * they can't go through Vite's default pipelines: dep optimization parses
- * their files as plain JavaScript (and fails on torpor syntax like `@render`
- * or `import type` from an uncompiled source), and SSR externalization would
- * leave raw `.torp` imports that neither Node nor workerd can load.
- *
- * A package is a torpor package when it declares a `torpor` entry in its
- * package.json (e.g. `"torpor": "./lib/index.js"`, mirroring the `svelte`
- * field convention), or when any of its export targets is a `.torp` file.
- *
- * @param siteRoot The root folder of the site
- * @returns The names of the torpor packages found (may be empty)
- */
-export default function findTorporPackages(siteRoot: string): string[] {
-	const sitePackageJson = path.resolve(siteRoot, "package.json");
-	if (!existsSync(sitePackageJson)) return [];
-
-	const pkg: PackageJson = JSON.parse(readFileSync(sitePackageJson, "utf8"));
-	const packages = new Set<string>();
-	const visited = new Set<string>();
-
-	const rootRequire = createRequire(sitePackageJson);
-	for (const name of dependencyNames(pkg)) {
-		collectTorporPackage(name, rootRequire, packages, visited);
-	}
-	return [...packages];
-}
-
-/**
- * Adds `optimizeDeps.exclude` and `ssr.noExternal` entries for packages that
- * ship `.torp` files, so that they are served/bundled through the torpor
- * compiler instead.
- */
-export function addTorporPackageConfig(siteRoot: string, config: UserConfig): void {
-	const packages = findTorporPackages(siteRoot);
-	if (packages.length === 0) return;
-
-	config.optimizeDeps ??= {};
-	config.optimizeDeps.exclude = [...(config.optimizeDeps.exclude ?? []), ...packages];
-
-	config.ssr ??= {};
-	const noExternal = config.ssr.noExternal;
-	if (noExternal === undefined) {
-		config.ssr.noExternal = packages;
-	} else if (Array.isArray(noExternal)) {
-		noExternal.push(...packages);
-	}
-	// For `true` (bundle everything) or string/regex values there is nothing
-	// sensible to merge, and they already bundle more than we need
-}
-
-function dependencyNames(pkg: PackageJson): string[] {
-	return [
-		...Object.keys(pkg.dependencies ?? {}),
-		...Object.keys(pkg.devDependencies ?? {}),
-		...Object.keys(pkg.optionalDependencies ?? {}),
-		...Object.keys(pkg.peerDependencies ?? {}),
-	];
-}
-
-function collectTorporPackage(
-	name: string,
-	require: NodeRequire,
-	packages: Set<string>,
-	visited: Set<string>,
-): void {
-	// Some packages shadow Node builtins (e.g. a dependency literally named
-	// "path"), and builtins can't contain .torp files
-	if (isBuiltin(name)) return;
-
-	const packageJsonPath = resolvePackageJson(name, require);
-	if (!packageJsonPath || visited.has(packageJsonPath)) return;
-	visited.add(packageJsonPath);
-
-	let pkg: PackageJson;
-	try {
-		pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-	} catch {
-		return;
-	}
-
-	if (isTorporPackage(pkg)) {
-		packages.add(pkg.name ?? name);
-	}
-
-	// Recurse into the package's own dependencies, resolved relative to it
-	// (pnpm keeps transitive deps out of the site's top-level node_modules)
-	const depRequire = createRequire(packageJsonPath);
-	for (const depName of dependencyNames(pkg)) {
-		collectTorporPackage(depName, depRequire, packages, visited);
-	}
-}
-
-function isTorporPackage(pkg: PackageJson): boolean {
-	if (typeof pkg.torpor === "string") return true;
-	return exportsIncludeTorp(pkg.exports);
-}
-
-function exportsIncludeTorp(exports: unknown): boolean {
-	if (typeof exports === "string") return exports.endsWith(".torp");
-	if (Array.isArray(exports)) return exports.some(exportsIncludeTorp);
-	if (exports && typeof exports === "object") {
-		return Object.values(exports).some(exportsIncludeTorp);
-	}
-	return false;
-}
-
-function resolvePackageJson(name: string, require: NodeRequire): string | undefined {
-	// require.resolve returns the name itself for Node builtins, so guard
-	// everything below with absolute path checks
-	try {
-		const packageJson = require.resolve(`${name}/package.json`);
-		return path.isAbsolute(packageJson) ? packageJson : undefined;
-	} catch {
-		let entry: string;
-		try {
-			entry = require.resolve(name);
-		} catch {
-			// Not resolvable from here (e.g. an optional peer), skip it
-			return undefined;
-		}
-		if (!path.isAbsolute(entry)) return undefined;
-		let dir = path.dirname(entry);
-		while (true) {
-			const packageJson = path.join(dir, "package.json");
-			if (existsSync(packageJson)) return packageJson;
-			const parent = path.dirname(dir);
-			if (parent === dir) return undefined;
-			dir = parent;
-		}
-	}
-}

package/src/utils/tsconfigAliases.ts

@@ -1,90 +0,0 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-
-export interface AliasEntry {
-	find: string | RegExp;
-	replacement: string;
-}
-
-/**
- * Reads `tsconfig.json` `compilerOptions.paths` (relative to `baseUrl`,
- * defaulting to the tsconfig directory) and converts them to Vite
- * `resolve.alias` entries. Only handles paths declared in the root tsconfig
- * (not inherited via `extends`).
- */
-export default function tsconfigAliases(root: string): AliasEntry[] {
-	const file = path.join(root, "tsconfig.json");
-	let paths: Record<string, string[]> | undefined;
-	let baseUrl: string;
-	try {
-		const tsconfig = JSON.parse(stripJsonc(readFileSync(file, "utf-8")));
-		const compilerOptions = tsconfig.compilerOptions ?? {};
-		baseUrl = compilerOptions.baseUrl ? path.resolve(root, compilerOptions.baseUrl) : root;
-		paths = compilerOptions.paths;
-	} catch {
-		return [];
-	}
-	if (!paths) return [];
-
-	const aliases: AliasEntry[] = [];
-	for (const [pattern, targets] of Object.entries(paths)) {
-		const target = targets?.[0];
-		if (!target) continue;
-		if (pattern.endsWith("*")) {
-			// `@/*` -> `./src/*`: match the literal prefix (`@/`) and rewrite to
-			// the target dir. A string `find` is used (not a RegExp) because
-			// Vite applies prefix-string aliases during SSR transform, which is
-			// what makes path aliases resolve in the SSR module runner.
-			const find = pattern.slice(0, -1);
-			const targetDir = target.slice(0, -1);
-			aliases.push({
-				find,
-				replacement: `${path.resolve(baseUrl, targetDir)}/`,
-			});
-		} else {
-			aliases.push({ find: pattern, replacement: path.resolve(baseUrl, target) });
-		}
-	}
-	return aliases;
-}
-
-/**
- * Strips JSONC comments and trailing commas so `tsconfig.json` (which permits
- * both) can be parsed with `JSON.parse`. String contents are preserved.
- */
-export function stripJsonc(text: string): string {
-	let out = "";
-	for (let i = 0; i < text.length;) {
-		const c = text[i];
-		if (c === '"' || c === "'") {
-			const quote = c;
-			out += c;
-			i++;
-			while (i < text.length) {
-				if (text[i] === "\\") {
-					out += text[i] + (text[i + 1] ?? "");
-					i += 2;
-					continue;
-				}
-				const cc = text[i++];
-				out += cc;
-				if (cc === quote) break;
-			}
-			continue;
-		}
-		if (c === "/" && text[i + 1] === "/") {
-			i += 2;
-			while (i < text.length && text[i] !== "\n") i++;
-			continue;
-		}
-		if (c === "/" && text[i + 1] === "*") {
-			i += 2;
-			while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
-			i += 2;
-			continue;
-		}
-		out += c;
-		i++;
-	}
-	return out.replace(/,(\s*[}\]])/g, "$1");
-}

package/src/validation/ValidationError.ts

@@ -1,18 +0,0 @@
-import type { StandardSchemaV1 } from "../types/StandardSchema";
-
-/**
- * The error thrown when a value fails standard schema validation. The
- * framework turns it into a 422 response for endpoint request bodies.
- */
-export default class ValidationError extends Error {
-	/**
-	 * The issues reported by the schema.
-	 */
-	issues: ReadonlyArray<StandardSchemaV1.Issue>;
-
-	constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>) {
-		super("Validation failed");
-		this.name = "ValidationError";
-		this.issues = issues;
-	}
-}

package/src/validation/endpoint.ts

@@ -1,83 +0,0 @@
-import type PageServerEndPoint from "../types/PageServerEndPoint";
-import type ServerEndPoint from "../types/ServerEndPoint";
-import type { StandardSchemaV1 } from "../types/StandardSchema";
-import type ServerEvent from "../server/ServerEvent";
-import searchParamsToRecord from "../utils/searchParamsToRecord";
-import unprocessable from "../response/unprocessable";
-import ValidationError from "./ValidationError";
-import validate from "./validate";
-
-/**
- * Loose views of an endpoint's schema map, keyed by handler/action name (plus
- * the reserved `params` key). The type-level constraint differs per endpoint
- * type, but the runtime treats them the same.
- */
-type Schemas = Record<string, StandardSchemaV1 | undefined>;
-
-type EndPoint = ServerEndPoint | PageServerEndPoint;
-
-/**
- * Gets the standard schema declared for a handler or action, if any. The
- * schemas map is keyed by name; the runtime treats it as a loose record.
- */
-export function endpointSchema(endPoint: EndPoint, name: string): StandardSchemaV1 | undefined {
-	return (endPoint.schema as Schemas | undefined)?.[name];
-}
-
-/**
- * Validates the route params against the endpoint's `params` schema, if it
- * declares one, returning the coerced params. Throws a ValidationError when
- * they don't match, which callers turn into a 404 (params come from the URL,
- * so a failed validation means the resource doesn't exist).
- *
- * @param endPoint The endpoint declaring the (optional) `params` schema
- * @param params The route params from the matched route
- * @returns The validated params
- */
-export async function validateEndpointParams(
-	endPoint: EndPoint,
-	params: Record<string, any>,
-): Promise<Record<string, any>> {
-	const schema = endpointSchema(endPoint, "params");
-	return schema ? ((await validate(schema, params)) as Record<string, any>) : params;
-}
-
-/**
- * Validates a handler's input against its schema: get/head handlers and load
- * functions validate the URL's query string, other handlers validate the JSON
- * request body. Returns the validated values (an empty object when no schema
- * is declared), which callers pass through to the handler's event.
- *
- * @param schema The handler's (optional) schema
- * @param functionName The handler name (`get`, `post`, `load`, etc)
- * @param url The request URL, for the query string
- * @param ev The server event, for the request body
- * @returns The validated values
- */
-export async function validateHandlerInput(
-	schema: StandardSchemaV1 | undefined,
-	functionName: string,
-	url: URL,
-	ev: ServerEvent,
-): Promise<{ json?: unknown; form?: unknown; query?: unknown }> {
-	if (!schema) return {};
-	if (functionName === "get" || functionName === "head" || functionName === "load") {
-		return { query: await validate(schema, searchParamsToRecord(url.searchParams)) };
-	}
-	return { json: await validate(schema, await ev.json()) };
-}
-
-/**
- * Turns a ValidationError thrown during endpoint validation into a 422
- * response with the schema's issues. Returns undefined for any other error,
- * which callers should rethrow.
- *
- * @param error The error thrown by a handler or validation
- * @returns A 422 response, or undefined when the error isn't a validation failure
- */
-export function validationErrorResponse(error: unknown): Response | undefined {
-	if (error instanceof ValidationError) {
-		return unprocessable({ message: error.message, issues: error.issues });
-	}
-	return undefined;
-}

package/src/validation/validate.ts

@@ -1,26 +0,0 @@
-import type { StandardSchemaV1 } from "../types/StandardSchema";
-import ValidationError from "./ValidationError";
-
-/**
- * Validates a value against a standard schema (zod, valibot, arktype, etc),
- * returning the parsed value, or throwing a `ValidationError` with the
- * schema's issues.
- *
- * ```ts
- * const post = validate(postSchema, { title: "Hello" });
- * ```
- *
- * @param schema A schema implementing the Standard Schema interface
- * @param value The value to validate
- * @returns The parsed value
- */
-export default async function validate<Schema extends StandardSchemaV1>(
-	schema: Schema,
-	value: unknown,
-): Promise<StandardSchemaV1.InferOutput<Schema>> {
-	const result = await schema["~standard"].validate(value);
-	if (result.issues) {
-		throw new ValidationError(result.issues);
-	}
-	return result.value as StandardSchemaV1.InferOutput<Schema>;
-}