@torpor/build 0.4.14 → 1.0.0

package/dist/unprocessable-DAZbrDeR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unprocessable-DAZbrDeR.mjs","names":[],"sources":["../src/response/response.ts","../src/response/transfer.ts","../src/response/notFound.ts","../src/response/ok.ts","../src/response/seeOther.ts","../src/response/unprocessable.ts"],"sourcesContent":["/**\n * Creates a response with the supplied status code and optional body.\n *\n * If the body is an object, it will be converted to JSON and the Content-Type\n * header set to \"application/json\". Otherwise, if the body is a string, the\n * Content-Type header will be set to \"text/plain\".\n */\nexport default function response(status: number, body?: object | string): Response {\n\tlet headers: Record<string, string> | undefined = undefined;\n\tif (body) {\n\t\tif (typeof body === \"object\") {\n\t\t\theaders = { \"Content-Type\": \"application/json\" };\n\t\t\tbody = JSON.stringify(body);\n\t\t} else {\n\t\t\theaders = { \"Content-Type\": \"text/plain\" };\n\t\t}\n\t}\n\treturn new Response(body, {\n\t\tstatus,\n\t\theaders,\n\t});\n}\n","/**\n * Creates a redirect response with the supplied status code.\n */\nexport default function transfer(\n\tstatus: 300 | 301 | 302 | 303 | 304 | 307 | 308,\n\tlocation: string,\n): Response {\n\treturn new Response(null, {\n\t\tstatus,\n\t\theaders: {\n\t\t\tlocation,\n\t\t},\n\t});\n}\n","import response from \"./response\";\n\n/**\n * 404 Not Found\n *\n * The HTTP 404 Not Found client error response status code indicates that the\n * server cannot find the requested resource. Links that lead to a 404 page are\n * often called broken or dead links and can be subject to link rot.\n *\n * A 404 status code only indicates that the resource is missing without\n * indicating if this is temporary or permanent. If a resource is permanently\n * removed, servers should send the 410 Gone status instead.\n *\n * 404 errors on a website can lead to a poor user experience for your visitors,\n * so the number of broken links (internal and external) should be minimized to\n * prevent frustration for readers. Common causes of 404 responses are mistyped\n * URLs or pages that are moved or deleted without redirection. For more\n * information, see the Redirections in HTTP guide.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/404\n */\nexport default function notFound(body?: object | string): Response {\n\treturn response(404, body ?? \"Not found\");\n}\n","import type { Jsonify } from \"../types/Jsonify\";\nimport type TypedResponse from \"./TypedResponse\";\nimport response from \"./response\";\n\ntype OkResponse<T extends object | string | undefined> = T extends object\n\t? TypedResponse<Jsonify<T>>\n\t: Response;\n\n/**\n * 200 OK\n *\n * The HTTP 200 OK successful response status code indicates that a request has\n * succeeded. A 200 OK response is cacheable by default.\n *\n * A 200 OK response has a different meaning and format depending on the HTTP\n * request method. Here's how they vary for different methods:\n *\n * - GET: A resource was retrieved by the server and included in the response\n *   body.\n * - POST: An action succeeded; the response has a message body describing the\n *   result.\n * - HEAD: Identical to GET, except there is no message body.\n * - TRACE: The response has a message body containing the request as received\n *   by the server.\n *\n * Although possible, successful PUT or DELETE requests often do not result in\n * a 200 OK response. It is more common to see 201 Created if the resource is\n * uploaded or created for the first time, or 204 No Content upon successful\n * deletion of a resource.\n *\n * An object body is typed: the client sees its JSON form through\n * `makeApi`-created callers.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/200\n */\nexport default function ok<T extends object | string | undefined>(body?: T): OkResponse<T> {\n\treturn response(200, body) as OkResponse<T>;\n}\n","import transfer from \"./transfer\";\n\n/**\n * 303 See Other\n *\n * The HTTP 303 See Other redirection response status code indicates that the\n * browser should redirect to the URL in the Location header instead of\n * rendering the requested resource.\n *\n * This response code is often sent back as a result of PUT or POST methods so\n * the client may retrieve a confirmation, or view a representation of a\n * real-world object (see HTTP range-14). The method to retrieve the redirected\n * resource is always GET.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/303\n */\nexport default function seeOther(location: string): Response {\n\treturn transfer(303, location);\n}\n","import response from \"./response\";\nimport type { Jsonify } from \"../types/Jsonify\";\nimport type TypedResponse from \"./TypedResponse\";\n\ntype UnprocessableResponse<T extends object | string | undefined> = T extends object\n\t? TypedResponse<Jsonify<T>>\n\t: Response;\n\n/**\n * 422 Unprocessable Content\n *\n * The HTTP 422 Unprocessable Content client error response status code\n * indicates that the server understood the content type of the request content,\n * and the syntax of the request content was correct, but it was unable to\n * process the contained instructions.\n *\n * Clients that receive a 422 response should expect that repeating the request\n * without modification will fail with the same error.\n *\n * An object body is typed: it becomes the page's `$props.form` (with its JSON\n * form) after a form submit, so validation errors can be surfaced with their\n * field types via `PageForm`.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/422\n */\nexport default function unprocessable<T extends object | string | undefined>(\n\tbody?: T,\n): UnprocessableResponse<T> {\n\treturn response(422, body ?? \"Unprocessable\") as UnprocessableResponse<T>;\n}\n"],"mappings":";;;;;;;;AAOA,SAAwB,SAAS,QAAgB,MAAkC;CAClF,IAAI,UAA8C,KAAA;CAClD,IAAI,MACH,IAAI,OAAO,SAAS,UAAU;EAC7B,UAAU,EAAE,gBAAgB,mBAAmB;EAC/C,OAAO,KAAK,UAAU,IAAI;CAC3B,OACC,UAAU,EAAE,gBAAgB,aAAa;CAG3C,OAAO,IAAI,SAAS,MAAM;EACzB;EACA;CACD,CAAC;AACF;;;;;;AClBA,SAAwB,SACvB,QACA,UACW;CACX,OAAO,IAAI,SAAS,MAAM;EACzB;EACA,SAAS,EACR,SACD;CACD,CAAC;AACF;;;;;;;;;;;;;;;;;;;;;;ACQA,SAAwB,SAAS,MAAkC;CAClE,OAAO,SAAS,KAAK,QAAQ,WAAW;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACYA,SAAwB,GAA0C,MAAyB;CAC1F,OAAO,SAAS,KAAK,IAAI;AAC1B;;;;;;;;;;;;;;;;;ACrBA,SAAwB,SAAS,UAA4B;CAC5D,OAAO,SAAS,KAAK,QAAQ;AAC9B;;;;;;;;;;;;;;;;;;;;ACOA,SAAwB,cACvB,MAC2B;CAC3B,OAAO,SAAS,KAAK,QAAQ,eAAe;AAC7C"}

package/dist/validate-Ok4krlkX.mjs

@@ -0,0 +1,40 @@
+//#region src/validation/ValidationError.ts
+/**
+* The error thrown when a value fails standard schema validation. The
+* framework turns it into a 422 response for endpoint request bodies.
+*/
+var ValidationError = class extends Error {
+	/**
+	* The issues reported by the schema.
+	*/
+	issues;
+	constructor(issues) {
+		super("Validation failed");
+		this.name = "ValidationError";
+		this.issues = issues;
+	}
+};
+//#endregion
+//#region src/validation/validate.ts
+/**
+* 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
+*/
+async function validate(schema, value) {
+	const result = await schema["~standard"].validate(value);
+	if (result.issues) throw new ValidationError(result.issues);
+	return result.value;
+}
+//#endregion
+export { ValidationError as n, validate as t };
+
+//# sourceMappingURL=validate-Ok4krlkX.mjs.map

package/dist/validate-Ok4krlkX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-Ok4krlkX.mjs","names":[],"sources":["../src/validation/ValidationError.ts","../src/validation/validate.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"../types/StandardSchema\";\n\n/**\n * The error thrown when a value fails standard schema validation. The\n * framework turns it into a 422 response for endpoint request bodies.\n */\nexport default class ValidationError extends Error {\n\t/**\n\t * The issues reported by the schema.\n\t */\n\tissues: ReadonlyArray<StandardSchemaV1.Issue>;\n\n\tconstructor(issues: ReadonlyArray<StandardSchemaV1.Issue>) {\n\t\tsuper(\"Validation failed\");\n\t\tthis.name = \"ValidationError\";\n\t\tthis.issues = issues;\n\t}\n}\n","import type { StandardSchemaV1 } from \"../types/StandardSchema\";\nimport ValidationError from \"./ValidationError\";\n\n/**\n * Validates a value against a standard schema (zod, valibot, arktype, etc),\n * returning the parsed value, or throwing a `ValidationError` with the\n * schema's issues.\n *\n * ```ts\n * const post = validate(postSchema, { title: \"Hello\" });\n * ```\n *\n * @param schema A schema implementing the Standard Schema interface\n * @param value The value to validate\n * @returns The parsed value\n */\nexport default async function validate<Schema extends StandardSchemaV1>(\n\tschema: Schema,\n\tvalue: unknown,\n): Promise<StandardSchemaV1.InferOutput<Schema>> {\n\tconst result = await schema[\"~standard\"].validate(value);\n\tif (result.issues) {\n\t\tthrow new ValidationError(result.issues);\n\t}\n\treturn result.value as StandardSchemaV1.InferOutput<Schema>;\n}\n"],"mappings":";;;;;AAMA,IAAqB,kBAArB,cAA6C,MAAM;;;;CAIlD;CAEA,YAAY,QAA+C;EAC1D,MAAM,mBAAmB;EACzB,KAAK,OAAO;EACZ,KAAK,SAAS;CACf;AACD;;;;;;;;;;;;;;;;ACDA,eAA8B,SAC7B,QACA,OACgD;CAChD,MAAM,SAAS,MAAM,OAAO,YAAY,CAAC,SAAS,KAAK;CACvD,IAAI,OAAO,QACV,MAAM,IAAI,gBAAgB,OAAO,MAAM;CAExC,OAAO,OAAO;AACf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torpor/build",
-  "version": "0.4.14",
+  "version": "1.0.0",
   "description": "A framework for building sites and apps with Torpor",
   "type": "module",
   "exports": {
@@ -8,14 +8,30 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
     },
+    "./dev": {
+      "types": "./src/dev.ts",
+      "import": "./src/dev.ts"
+    },
+    "./form": {
+      "types": "./dist/form.d.mts",
+      "import": "./dist/form.mjs"
+    },
     "./nav": {
       "types": "./dist/nav.d.mts",
       "import": "./dist/nav.mjs"
     },
+    "./openapi": {
+      "types": "./dist/openapi.d.mts",
+      "import": "./dist/openapi.mjs"
+    },
     "./response": {
       "types": "./dist/response.d.mts",
       "import": "./dist/response.mjs"
     },
+    "./schema": {
+      "types": "./dist/schema.d.mts",
+      "import": "./dist/schema.mjs"
+    },
     "./run": {
       "types": "./dist/run.d.mts",
       "import": "./dist/run.mjs"
@@ -50,27 +66,22 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "cookie": "^1.0.2",
-    "dotenv": "^17.2.3",
-    "vite": "^7.2.2",
-    "vite-tsconfig-paths": "^5.1.4",
-    "@torpor/unplugin": "^0.2.1",
-    "@torpor/view": "^0.4.18"
+    "cookie": "^2.0.1",
+    "dotenv": "^17.4.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.7",
+    "@torpor/unplugin": "^1.0.0",
+    "@torpor/view": "^1.0.0"
   },
   "devDependencies": {
-    "@trivago/prettier-plugin-sort-imports": "^6.0.0",
-    "@typescript/native-preview": "7.0.0-dev.20251112.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "esno": "^4.8.0",
-    "oxlint-tsgolint": "^0.6.0",
-    "tsdown": "^0.16.4",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.8"
+    "typescript": "^7.0.2",
+    "vite-plus": "0.2.7"
   },
   "scripts": {
     "check": "tsgo --noEmit && pnpm dlx oxlint --type-aware",
-    "build": "tsgo --noEmit && tsdown",
-    "build:fix": "esno scripts/postbuild.ts",
-    "build:watch": "tsdown --watch",
-    "test": "vitest"
+    "build": "tsgo --noEmit && vp pack",
+    "build:watch": "vp pack --watch",
+    "test": "vp test"
   }
 }

package/src/bin/index.ts

@@ -1,8 +1,19 @@
 #! /usr/bin/env node
-import run from "../run/run";
+import run, { loadSite } from "../run/run";
+import runOpenApi from "../run/runOpenApi";
 
 const workingDir = process.cwd();
-if (process.argv.includes("--dev")) {
+if (process.argv.includes("--openapi")) {
+	const flagIndex = process.argv.indexOf("--openapi");
+	const next = process.argv[flagIndex + 1];
+	const outFile = next && !next.startsWith("-") ? next : "openapi.json";
+	const { site, vite } = await loadSite(workingDir);
+	try {
+		await runOpenApi(site, vite, outFile);
+	} finally {
+		await vite.close();
+	}
+} else if (process.argv.includes("--dev")) {
 	await run(workingDir, "dev");
 } else if (process.argv.includes("--build")) {
 	await run(workingDir, "build");

package/src/dev.ts

@@ -0,0 +1,10 @@
+/**
+ * Dev-only entry point re-exporting the server-side pieces that adapters need
+ * to assemble a dev runtime (e.g. the Cloudflare adapter's workerd dev worker).
+ *
+ * Pointed at by the `@torpor/build/dev` export (source, so Vite transforms and
+ * HMR apply). Not intended for production use — production workers are bundled
+ * from the built output instead.
+ */
+export { default as Server } from "./server/Server.ts";
+export { load } from "./site/serverEntry.ts";

package/src/form/formDataToRecord.ts

@@ -0,0 +1,23 @@
+import type { FormDataRecord } from "../types/ServerLoadEvent";
+
+/**
+ * Converts the submitted fields of a form request into a plain record: one
+ * value per field, or an array when a field was submitted with multiple
+ * values (e.g. a multi select). File inputs pass through as `File` values;
+ * coercing them is left to the schema or the action.
+ *
+ * @param request The request (or FormData directly)
+ * @returns The field values
+ */
+export default async function formDataToRecord(
+	request: Request | FormData,
+): Promise<FormDataRecord> {
+	const formData = request instanceof FormData ? request : await request.formData();
+	const result: FormDataRecord = {};
+	for (const key of formData.keys()) {
+		if (key in result) continue;
+		const values = formData.getAll(key);
+		result[key] = values.length > 1 ? values : values[0];
+	}
+	return result;
+}

package/src/form/readForm.ts

@@ -0,0 +1,71 @@
+/**
+ * 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

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

package/src/index.ts

@@ -1,15 +1,43 @@
 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
@@ -20,11 +48,35 @@ export type {
 	Adapter,
 	PageEndPoint,
 	PageServerEndPoint,
+	PageServerActionSchemas,
+	ActionBody,
+	LoadQuery,
+	LoadParams,
 	PageServerLoad,
 	PageServerAction,
 	ServerEndPoint,
+	ServerEndPointSchemas,
+	SchemaBody,
+	SchemaQuery,
+	ParamsOf,
 	ServerRequest,
 	ServerHook,
-	PageLoadEvent,
 	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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -29,7 +29,7 @@ export default async function formSubmit(e: SubmitEvent): Promise<void> {
 		// error response (if applicable) rather than the reloaded page that you
 		// would get if submitting a page without javascript
 		headers: {
-			"x-torpor-form-submit": "",
+			"X-Torpor-Form-Submit": "",
 		},
 	};
 	const response = await fetch(
@@ -38,9 +38,23 @@ export default async function formSubmit(e: SubmitEvent): Promise<void> {
 		options,
 	);
 
-	if (response.status === 200 && response.headers.has("x-torpor-form-redirect")) {
+	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")!;
+		const redirect = response.headers.get("Location")!;
 		await load(redirect);
 		window.location.href = redirect;
 	} else if (
@@ -48,7 +62,7 @@ export default async function formSubmit(e: SubmitEvent): Promise<void> {
 		(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") {
+		if (response.headers.get("Content-Type") === "application/json") {
 			$page.form = await response.json();
 		}
 		await reload();