@torpor/build 1.0.0 → 1.0.1

package/src/form/readForm.ts

@@ -1,71 +0,0 @@
-/**
- * The values read from a form submission, coerced by the spec's default
- * value types: string defaults produce strings, number defaults produce
- * numbers, boolean defaults produce booleans, and array defaults produce
- * arrays of the element type (an empty array default produces strings).
- */
-export type FormValues<Spec extends Record<string, unknown>> = {
-	[K in keyof Spec]: FormValue<Spec[K]>;
-};
-
-type FormValue<T> = T extends boolean
-	? boolean
-	: T extends number
-		? number
-		: T extends readonly unknown[]
-			? [T[number]] extends [never]
-				? string[]
-				: T[number][]
-			: string;
-
-/**
- * Reads and coerces the submitted fields of a form action, e.g.
- *
- * ```ts
- * const data = await readForm(request, {
- *   title: "",
- *   done: false,
- *   priority: 0,
- *   tags: [],
- * });
- * // data: { title: string; done: boolean; priority: number; tags: string[] }
- * ```
- *
- * The spec object declares the expected fields; each key's default value
- * determines the type and the fallback when the field is missing or can't be
- * coerced. Booleans follow checkbox semantics (unchecked fields are absent,
- * so they come back as `false`).
- *
- * @param request The action event's request, or its FormData directly
- * @param spec An object mapping field names to default values
- * @returns The coerced field values
- */
-export default async function readForm<Spec extends Record<string, unknown>>(
-	request: Request | FormData,
-	spec: Spec,
-): Promise<FormValues<Spec>> {
-	const formData = request instanceof FormData ? request : await request.formData();
-	const result: Record<string, unknown> = {};
-	for (const key of Object.keys(spec)) {
-		const defaultValue = spec[key];
-		// oxlint-disable-next-line typescript/no-base-to-string
-		const values = formData.getAll(key).map((v) => v.toString());
-		result[key] = Array.isArray(defaultValue)
-			? values.map((value) => coerceValue(value, defaultValue[0]))
-			: coerceValue(values[0], defaultValue);
-	}
-	return result as FormValues<Spec>;
-}
-
-function coerceValue(value: string | undefined, defaultValue: unknown): unknown {
-	if (typeof defaultValue === "number") {
-		const n = value === undefined || value === "" ? NaN : Number(value);
-		return Number.isNaN(n) ? defaultValue : n;
-	}
-	if (typeof defaultValue === "boolean") {
-		// Unchecked checkboxes are not submitted at all
-		if (value === undefined) return false;
-		return !(value === "" || value === "false" || value === "off");
-	}
-	return value ?? defaultValue ?? "";
-}

package/src/form.ts

@@ -1,4 +0,0 @@
-import readForm from "./form/readForm";
-
-export { readForm };
-export type { FormValues } from "./form/readForm";

package/src/index.ts

@@ -1,82 +0,0 @@
-import Router from "./site/Router";
-import Site from "./site/Site";
-import type Adapter from "./types/Adapter";
-import type { Jsonify } from "./types/Jsonify";
-import type { MergePageData, PageData } from "./types/PageData";
-import type { PageForm } from "./types/PageForm";
-import type PageEndPoint from "./types/PageEndPoint";
-import type PageLoadEvent from "./types/PageLoadEvent";
-import type { PageLoadReturn } from "./types/PageLoadReturn";
-import type PageProps from "./types/PageProps";
-import type {
-	ParseRouteParams,
-	RouteArgs,
-	RouteArgsOf,
-	RouteParamsOf,
-} from "./types/ParseRouteParams";
-import type PageServerAction from "./types/PageServerAction";
-import type PageServerEndPoint from "./types/PageServerEndPoint";
-import type {
-	ActionBody,
-	LoadParams,
-	LoadQuery,
-	PageServerActionSchemas,
-} from "./types/PageServerEndPoint";
-import type PageServerLoad from "./types/PageServerLoad";
-import type TypedResponse from "./response/TypedResponse";
-import type { UntypedResponse } from "./response/TypedResponse";
-import type ServerEndPoint from "./types/ServerEndPoint";
-import type {
-	ParamsOf,
-	SchemaBody,
-	SchemaQuery,
-	ServerEndPointSchemas,
-} from "./types/ServerEndPoint";
-import type ServerHook from "./types/ServerHook";
-import type ServerLoadEvent from "./types/ServerLoadEvent";
-import type { FormDataRecord, QueryRecord } from "./types/ServerLoadEvent";
-import type ServerRequest from "./types/ServerRequest";
-import type { StandardSchemaV1 } from "./types/StandardSchema";
-import type SitePlugin from "./types/SitePlugin";
-
-// NOTE: Don't export any general functionality from here -- it may result in
-// Vite errors like `Could not resolve '../pkg' in lightningcss` etc
-
-export { Site, Router };
-
-export type {
-	Adapter,
-	PageEndPoint,
-	PageServerEndPoint,
-	PageServerActionSchemas,
-	ActionBody,
-	LoadQuery,
-	LoadParams,
-	PageServerLoad,
-	PageServerAction,
-	ServerEndPoint,
-	ServerEndPointSchemas,
-	SchemaBody,
-	SchemaQuery,
-	ParamsOf,
-	ServerRequest,
-	ServerHook,
-	ServerLoadEvent,
-	SitePlugin,
-	FormDataRecord,
-	QueryRecord,
-	StandardSchemaV1,
-	PageLoadEvent,
-	ParseRouteParams,
-	RouteArgs,
-	RouteArgsOf,
-	RouteParamsOf,
-	Jsonify,
-	TypedResponse,
-	UntypedResponse,
-	PageData,
-	MergePageData,
-	PageForm,
-	PageLoadReturn,
-	PageProps,
-};

package/src/nav/api.test-d.ts

@@ -1,79 +0,0 @@
-import type { ApiMethods } from "./api";
-import makeApi from "./api";
-import ok from "../response/ok";
-import type TypedResponse from "../response/TypedResponse";
-import type ServerLoadEvent from "../types/ServerLoadEvent";
-
-// A sample endpoint shape, as inferred from a `+server` default export
-interface TimeEndPoint {
-	get: (event: ServerLoadEvent<"/api/time">) => Promise<TypedResponse<{ time: number }>>;
-	post: (event: ServerLoadEvent<"/api/time">) => Promise<Response>;
-}
-
-// An endpoint whose handler annotates an expected request body
-interface CreatePostEndPoint {
-	post: (
-		event: ServerLoadEvent<"/api/posts", { title: string }>,
-	) => Promise<TypedResponse<{ id: number }>>;
-}
-
-type Equals<A, B> =
-	(<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-type Expect<T extends true> = T;
-
-// The get caller resolves to the typed JSON body (or a raw Response)
-export type R01 = Expect<
-	Equals<
-		ApiMethods<TimeEndPoint>["get"],
-		(body?: BodyInit | object, init?: RequestInit) => Promise<{ time: number } | Response>
-	>
->;
-
-// Handlers that return a plain Response fall back to unknown
-export type R02 = Expect<
-	Equals<
-		ApiMethods<TimeEndPoint>["post"],
-		(body?: BodyInit | object, init?: RequestInit) => Promise<unknown>
-	>
->;
-
-// Only defined handlers are callable
-export type R03 = Expect<Equals<keyof ApiMethods<TimeEndPoint>, "get" | "post">>;
-
-// An annotated event body types the client call's body param
-export type R04 = Expect<
-	Equals<
-		ApiMethods<CreatePostEndPoint>["post"],
-		(body?: { title: string }, init?: RequestInit) => Promise<{ id: number } | Response>
-	>
->;
-
-// Usage: params are enforced by the route path
-export const timeApi: ApiMethods<TimeEndPoint> = makeApi<"/api/time", TimeEndPoint>("/api/time");
-export const postApi: ApiMethods<TimeEndPoint> = makeApi<"/api/posts/[id]", TimeEndPoint>(
-	"/api/posts/[id]",
-	{
-		id: "5",
-	},
-);
-// @ts-expect-error missing params
-void makeApi<"/api/posts/[id]", TimeEndPoint>("/api/posts/[id]");
-// @ts-expect-error params are not accepted for static paths
-void makeApi<"/api/time", TimeEndPoint>("/api/time", {});
-// @ts-expect-error 'nope' is not a param of /api/posts/[id]
-void makeApi<"/api/posts/[id]", TimeEndPoint>("/api/posts/[id]", { nope: "1" });
-
-// Usage: an annotated body is checked at the call site
-export const createApi: ApiMethods<CreatePostEndPoint> = makeApi<"/api/posts", CreatePostEndPoint>(
-	"/api/posts",
-);
-void createApi.post({ title: "Hello" });
-// @ts-expect-error 'name' is not part of the endpoint's expected body
-void createApi.post({ name: "Hello" });
-// @ts-expect-error 'title' is required
-void createApi.post({});
-
-// ok() typing: object bodies are typed, strings are not
-export const typed: TypedResponse<{ time: number }> = ok({ time: 5 });
-export const untypedResponse: Response = ok("plain");
-export const noBodyResponse: Response = ok();

package/src/nav/api.ts

@@ -1,104 +0,0 @@
-import type { ExactRouteParams, ParseRouteParams } from "../types/ParseRouteParams";
-import type TypedResponse from "../response/TypedResponse";
-import route from "./route";
-
-/**
- * The value a client call resolves to: the endpoint's typed JSON body when it
- * returns a typed response, or the raw Response when the body isn't JSON.
- * Untyped endpoints resolve to `unknown`.
- */
-type ApiResult<Handler> = Handler extends (event: any) => any
-	? Awaited<ReturnType<Handler>> extends TypedResponse<infer Body>
-		? Body | Response
-		: unknown
-	: never;
-
-/**
- * The body a client call accepts: the endpoint event's annotated JSON body
- * type (from `ServerLoadEvent<Route, Body>`), or a loose value when the
- * handler doesn't annotate one.
- */
-type ApiRequestBody<Handler> = Handler extends (event: infer Event) => any
-	? Event extends { json: () => Promise<infer Body> }
-		? unknown extends Body
-			? BodyInit | object
-			: Body
-		: BodyInit | object
-	: BodyInit | object;
-
-/** The callable methods of an endpoint, one per handler it defines. */
-export type ApiMethods<Endpoint extends object> = {
-	[Method in string & keyof Endpoint as NonNullable<Endpoint[Method]> extends (event: any) => any
-		? Method
-		: never]: (
-		body?: ApiRequestBody<NonNullable<Endpoint[Method]>>,
-		init?: RequestInit,
-	) => Promise<ApiResult<NonNullable<Endpoint[Method]>>>;
-};
-
-const METHODS = ["get", "post", "patch", "put", "del", "options", "head"] as const;
-
-/**
- * Creates typed client callers for a `+server` endpoint, e.g.
- *
- * ```ts
- * import type endpoint from "@/routes/api/posts/[id]/+server";
- * const post = makeApi<"/api/posts/[id]", typeof endpoint>("/api/posts/[id]");
- * const data = await post.get(); // typed from the endpoint's responses
- * ```
- *
- * Method names match the endpoint's handlers (`del` for DELETE). Params are
- * filled in and URI-encoded from the route path, and JSON responses are
- * parsed; non-JSON responses resolve to the raw Response. Failed requests
- * (non-2xx) throw.
- *
- * @param path The endpoint's route path
- * @param params The route params, required if the path has dynamic segments
- * @returns An object with one caller per handler defined by the endpoint
- */
-export default function makeApi<
-	Route extends string,
-	Endpoint extends object,
-	Params extends ParseRouteParams<Route> = ParseRouteParams<Route>,
->(
-	path: Route,
-	// NOTE: The rest args conditional must stay INLINE — routing it through a
-	// type alias defeats `Params` inference, and excess keys stop being checked
-	...args: string extends Route
-		? [params?: Record<string, string>]
-		: keyof ParseRouteParams<Route> extends never
-			? []
-			: [params: Params & ExactRouteParams<Params, ParseRouteParams<Route>>]
-): ApiMethods<Endpoint> {
-	const url = route(path as string, ...(args as [params?: Record<string, string>]));
-	const api: Record<string, (body?: unknown, init?: RequestInit) => Promise<unknown>> = {};
-	for (const method of METHODS) {
-		api[method] = (body, init) => request(method, url, body, init);
-	}
-	return api as ApiMethods<Endpoint>;
-}
-
-async function request(
-	method: string,
-	url: string,
-	body: unknown,
-	init?: RequestInit,
-): Promise<unknown> {
-	// `del` is the endpoint handler name for DELETE requests
-	const httpMethod = method === "del" ? "delete" : method;
-	const options: RequestInit = { method: httpMethod.toUpperCase(), ...init };
-	if (body !== undefined && options.body === undefined && method !== "get" && method !== "head") {
-		if (typeof body === "object") {
-			options.headers ??= { "Content-Type": "application/json" };
-			options.body = JSON.stringify(body);
-		} else {
-			options.body = body as BodyInit;
-		}
-	}
-	const response = await fetch(url, options);
-	if (!response.ok) {
-		throw new Error(`API ${method.toUpperCase()} ${url} failed: ${response.status}`);
-	}
-	const contentType = response.headers.get("Content-Type") ?? "";
-	return contentType.includes("application/json") ? await response.json() : response;
-}

package/src/nav/formSubmit.ts

@@ -1,70 +0,0 @@
-import $page from "../state/$page";
-import load from "./load";
-import reload from "./reload";
-
-export default async function formSubmit(e: SubmitEvent): Promise<void> {
-	// We'll take it from here
-	e.preventDefault();
-
-	// Reset $page on submit and link navigation
-	// TODO: Should we put data in $page.data??
-	$page.form = undefined;
-
-	// Perform a POST fetch to the form's action location
-	const form = e.target as HTMLFormElement;
-	const button = e.submitter as HTMLButtonElement;
-	// HACK: submit buttons have their formAction set to the current page if not
-	// set, so we can't just check whether it's empty and fallback to form action
-	//const action = button?.formAction ?? form.action;
-	let action = form.action || document.URL;
-	if (button && button.formAction && button.formAction !== document.URL) {
-		action = button.formAction;
-	}
-	const options = {
-		body: new FormData(form),
-		method: "POST",
-		mode: "cors",
-		credentials: "same-origin",
-		// Add a special header which tells the server that we want the raw
-		// error response (if applicable) rather than the reloaded page that you
-		// would get if submitting a page without javascript
-		headers: {
-			"X-Torpor-Form-Submit": "",
-		},
-	};
-	const response = await fetch(
-		action,
-		// @ts-ignore -- don't know what it's complaining about here
-		options,
-	);
-
-	if (
-		response.status === 200 &&
-		response.headers.has("Content-Disposition") &&
-		/attachment;\s*filename="(.+?)"/.test(response.headers.get("Content-Disposition")!)
-	) {
-		// TODO: Is this enough to check to see if we have a file that should download?
-		// Download the file by creating a dummy <a> and clicking it
-		const downloadFileName =
-			response.headers.get("Content-Disposition")?.match(/attachment;\s*filename="(.+?)"/)![1] ??
-			"file";
-		const downloadLink = document.createElement("a");
-		downloadLink.href = window.URL.createObjectURL(await response.blob());
-		downloadLink.download = downloadFileName;
-		downloadLink.click();
-	} else if (response.status === 200 && response.headers.has("X-Torpor-Form-Redirect")) {
-		// TODO: Should do the correct type of redirect e.g. seeOther etc
-		const redirect = response.headers.get("Location")!;
-		await load(redirect);
-		window.location.href = redirect;
-	} else if (
-		(response.status >= 200 && response.status <= 299) ||
-		(response.status >= 400 && response.status <= 499)
-	) {
-		// Put the response into `$page.form`, and it will be put into `$props` in reload
-		if (response.headers.get("Content-Type") === "application/json") {
-			$page.form = await response.json();
-		}
-		await reload();
-	}
-}

package/src/nav/load.ts

@@ -1,9 +0,0 @@
-import navigate from "./navigate";
-
-/**
- * Loads and renders the page at the supplied path.
- */
-export default async function load(path: string): Promise<boolean> {
-	const url = new URL(path, document.location.href);
-	return await navigate(url);
-}

package/src/nav/loadData.ts

@@ -1,134 +0,0 @@
-import client from "../state/client";
-import type LayoutPath from "../types/LayoutPath";
-import type PageEndPoint from "../types/PageEndPoint";
-import type PageServerEndPoint from "../types/PageServerEndPoint";
-import type RouteHandler from "../types/RouteHandler";
-
-export default async function loadData(
-	handler: RouteHandler,
-	params: Record<string, string>,
-	path: string,
-	query: URLSearchParams,
-	newLayoutStack: LayoutPath[],
-	clientEndPoint: PageEndPoint | undefined,
-	serverEndPoint: PageServerEndPoint | undefined,
-	prefetch = false,
-): Promise<Record<string, string> | void> {
-	let data = {};
-	if (handler.layouts) {
-		let layoutStack = client.layoutStack;
-		for (let [i, layout] of handler.layouts.entries()) {
-			let layoutPath = layout.path;
-			for (let key in params) {
-				layoutPath = layoutPath.replace(`[${key}]`, params[key]);
-			}
-			if (layoutStack.at(i)?.path === layoutPath) {
-				// We've already loaded this layout, we can just re-use its data and UI
-				if (!prefetch) {
-					layoutStack[i].reuse = true;
-				}
-				newLayoutStack[i] = layoutStack[i];
-				Object.assign(data, layoutStack[i].data);
-			} else {
-				const stackLayout = { path: layoutPath, data: {}, reuse: false, slotRegion: null };
-				const layoutEndPoint: PageEndPoint | undefined = (await layout.endPoint())?.default;
-				const layoutServerEndPoint: PageServerEndPoint | undefined =
-					layout.serverEndPoint && (await layout.serverEndPoint())?.default;
-				const layoutResponse = await loadClientAndServerData(
-					stackLayout.data,
-					document.location.origin + layoutPath,
-					query,
-					params,
-					layoutEndPoint,
-					layoutServerEndPoint,
-				);
-				if (layoutResponse?.ok === false) {
-					return;
-				}
-				Object.assign(data, stackLayout.data);
-				newLayoutStack.push(stackLayout);
-			}
-		}
-	}
-	let endPointResponse = await loadClientAndServerData(
-		data,
-		document.location.origin + path,
-		query,
-		params,
-		clientEndPoint,
-		serverEndPoint,
-	);
-	if (endPointResponse?.ok === false) {
-		return;
-	}
-	return data;
-}
-
-async function loadClientAndServerData(
-	data: Record<string, any>,
-	location: string,
-	query: URLSearchParams,
-	params: Record<string, string>,
-	clientEndPoint?: PageEndPoint,
-	serverEndPoint?: PageServerEndPoint,
-): Promise<Response | undefined | void> {
-	let prefetchedData = client.prefetchedData;
-
-	if (clientEndPoint?.load) {
-		const clientKey = location + (query.size > 0 ? `?${query}` : "");
-		if (prefetchedData[clientKey]) {
-			Object.assign(data, prefetchedData[clientKey]);
-		} else {
-			const clientUrl = new URL(document.location.href);
-			for (let [name, value] of query) {
-				clientUrl.searchParams.append(name, value);
-			}
-			const clientParams = buildClientParams(clientUrl, params, data);
-			const clientResponse = await clientEndPoint.load(clientParams);
-			if (clientResponse) {
-				if (clientResponse.ok) {
-					if (clientResponse.headers.get("Content-Type")?.includes("application/json")) {
-						const clientData = await clientResponse.json();
-						Object.assign(data, clientData);
-						prefetchedData[clientKey] = clientData;
-					}
-				} else {
-					return clientResponse;
-				}
-			}
-		}
-	}
-
-	if (serverEndPoint?.load) {
-		const serverLocation = location.replace(/\/$/, "") + "/~server";
-		const serverKey = serverLocation + (query.size > 0 ? `?${query}` : "");
-		if (prefetchedData[serverKey]) {
-			Object.assign(data, prefetchedData[serverKey]);
-		} else {
-			const serverUrl = new URL(serverLocation);
-			for (let [name, value] of query) {
-				serverUrl.searchParams.append(name, value);
-			}
-			const serverResponse = await fetch(serverUrl);
-			if (serverResponse) {
-				if (serverResponse.ok) {
-					if (serverResponse.headers.get("Content-Type")?.includes("application/json")) {
-						const serverData = await serverResponse.json();
-						Object.assign(data, serverData);
-						prefetchedData[serverKey] = serverData;
-					}
-				} else {
-					return serverResponse;
-				}
-			}
-		}
-	}
-}
-
-function buildClientParams(url: URL, params: Record<string, string>, data: Record<string, any>) {
-	return {
-		url,
-		params,
-		data,
-	};
-}