@torpor/build 1.0.0 → 1.0.1

package/src/types/PageData.test-d.ts

@@ -1,136 +0,0 @@
-import found from "../response/found";
-import ok from "../response/ok";
-import type TypedResponse from "../response/TypedResponse";
-import type { MergePageData, PageData } from "./PageData";
-import type PageEndPoint from "./PageEndPoint";
-import type PageLoadEvent from "./PageLoadEvent";
-import type PageProps from "./PageProps";
-import type PageServerEndPoint from "./PageServerEndPoint";
-
-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;
-
-interface Post {
-	title: string;
-}
-
-// A server endpoint whose load returns typed data
-interface PostsServer {
-	load: () => Promise<TypedResponse<{ posts: { title: string }[] }>>;
-}
-
-export const server: PostsServer = {
-	load: async () => ok({ posts: [{ title: "Hello" }] }),
-};
-
-// The shape above is a valid +page.server endpoint
-export const serverCompat: PageServerEndPoint<"/posts"> = server;
-
-// PageData extracts the Jsonify'd body of the load's typed responses
-export type D01 = Expect<Equals<PageData<PostsServer>, { posts: { title: string }[] }>>;
-
-// Dates are Jsonify'd to strings through ok()
-interface ClockServer {
-	load: () => Promise<TypedResponse<{ now: string }>>;
-}
-
-export const clockServer: ClockServer = {
-	load: async () => ok({ now: new Date() }),
-};
-
-export type D02 = Expect<Equals<PageData<ClockServer>, { now: string }>>;
-
-// Endpoints without a load fall back to a loose record
-export const actionsOnly: PageServerEndPoint<"/posts"> = {
-	actions: { default: async () => ok({}) },
-};
-export type D03 = Expect<Equals<PageData<typeof actionsOnly>, Record<string, any>>>;
-
-// Untyped loads (redirects etc) fall back to a loose record
-export const untypedLoad: PageServerEndPoint<"/posts"> = {
-	load: async () => found("/elsewhere"),
-};
-export type D04 = Expect<Equals<PageData<typeof untypedLoad>, Record<string, any>>>;
-
-// The page endpoint: data keys are checked against Data
-export const page: PageEndPoint<"/posts", PageData<PostsServer>> = {
-	load: async () => ok({ posts: [{ title: "Hello" }] }),
-};
-
-export const badPage: PageEndPoint<"/posts", PageData<PostsServer>> = {
-	// @ts-expect-error 'comments' is not part of the page's data
-	load: async () => ok({ comments: [] }),
-};
-
-// Untyped responses (redirects etc) are always allowed
-export const redirecting: PageEndPoint<"/posts", PageData<PostsServer>> = {
-	load: async () => found("/elsewhere"),
-};
-
-// Loads with no return are allowed
-export const silent: PageEndPoint<"/posts", PageData<PostsServer>> = {
-	load: async () => {},
-};
-
-// Server endpoints are checked the same way
-export const checkedServer: PageServerEndPoint<"/posts", { posts: Post[] }> = {
-	load: async () => ok({ posts: [{ title: "Hello" }] }),
-};
-
-export const badServer: PageServerEndPoint<"/posts", { posts: Post[] }> = {
-	// @ts-expect-error wrong data shape is flagged on the server endpoint too
-	load: async () => ok({ posts: "not an array" }),
-};
-
-// PageProps: the shape page components receive
-const props: PageProps<PageData<PostsServer>> = null as never;
-export const posts: { title: string }[] = props.data.posts;
-export const form: Record<string, any> | undefined = props.form;
-
-// --- Layout data ---
-
-// A layout endpoint with its own typed load
-interface LayoutServer {
-	load: () => Promise<TypedResponse<{ user: { name: string } }>>;
-}
-
-export const layoutServer: LayoutServer = {
-	load: async () => ok({ user: { name: "Andrew" } }),
-};
-
-// MergePageData intersects layout and page data, in order
-export type M01 = Expect<
-	Equals<
-		MergePageData<[typeof layoutServer, PostsServer]>,
-		{ user: { name: string } } & { posts: { title: string }[] }
-	>
->;
-
-// A single endpoint merges to its own data
-export type M02 = Expect<Equals<MergePageData<[PostsServer]>, { posts: { title: string }[] }>>;
-
-// The merged shape is what the page component receives as $props.data
-const mergedProps: PageProps<MergePageData<[typeof layoutServer, PostsServer]>> = null as never;
-export const userName: string = mergedProps.data.user.name;
-export const mergedPosts: { title: string }[] = mergedProps.data.posts;
-
-// Endpoints without a typed load contribute only looseness
-const looseProps: PageProps<MergePageData<[typeof actionsOnly, PostsServer]>> = null as never;
-export const loosePosts: { title: string }[] = looseProps.data.posts;
-
-// --- Client load events ---
-
-// event.data is typed by the second annotation, e.g. the layout's data
-export const clientLoad = (event: PageLoadEvent<"/posts", PageData<typeof layoutServer>>): void =>
-	void event.data.user.name;
-
-// 'nope' is not part of the accumulated layout data
-export const badClientLoad = (
-	event: PageLoadEvent<"/posts", PageData<typeof layoutServer>>,
-): void =>
-	// @ts-expect-error 'nope' is not part of the accumulated layout data
-	void event.data.nope;
-
-// Without a data annotation it stays loose
-export const looseClientLoad = (event: PageLoadEvent<"/posts">): void => void event.data.whatever;

package/src/types/PageData.ts

@@ -1,35 +0,0 @@
-import type TypedResponse from "../response/TypedResponse";
-
-/**
- * The page data produced by an endpoint's `load` function, e.g.
- *
- * ```ts
- * import type server from "./+page.server";
- * type Data = PageData<typeof server>;
- * ```
- *
- * Falls back to a loose record when the endpoint has no load or its load
- * returns untyped responses.
- */
-export type PageData<EndPoint> = EndPoint extends { load?: (event: any) => infer Return }
-	? NonNullable<Awaited<Return>> extends TypedResponse<infer Body>
-		? Body
-		: Record<string, any>
-	: Record<string, any>;
-
-/**
- * The merged page data for a page that sits under one or more layouts: pass
- * the layout endpoints first and the page endpoint last, e.g.
- *
- * ```ts
- * import type layoutServer from "../_layout.server";
- * import type server from "./+page.server";
- * type Data = MergePageData<typeof layoutServer, typeof server>;
- * ```
- *
- * Each endpoint's data is intersected in order; endpoints without a typed
- * `load` contribute nothing but looseness.
- */
-export type MergePageData<EndPoints extends any[]> = EndPoints extends [infer First, ...infer Rest]
-	? PageData<First> & MergePageData<Rest>
-	: unknown;

package/src/types/PageEndPoint.ts

@@ -1,55 +0,0 @@
-import { type Component } from "@torpor/view";
-import type { ExactRouteParams, ParseRouteParams, RouteParamsOf } from "./ParseRouteParams";
-import type PageLoadEvent from "./PageLoadEvent";
-import type { PageLoadReturn } from "./PageLoadReturn";
-
-/**
- * For +page. Annotate with a route path to get typed params, and with a data
- * shape to flag loads that return keys the page doesn't expect, e.g.
- * `PageEndPoint<"/posts/[id]", PageData<typeof server>>`.
- */
-export default interface PageEndPoint<
-	Route extends string | undefined = undefined,
-	Data = Record<string, any>,
-> {
-	/**
-	 * Builds the route path for the page in a type-safe manner. The params
-	 * object is checked for exact keys when `Route` is annotated.
-	 *
-	 * NOTE: The rest args conditional must stay INLINE — routing it through a
-	 * type alias defeats `Params` inference, and excess keys stop being checked
-	 */
-	route?: <Params extends RouteParamsOf<Route>>(
-		...args: Route extends string
-			? string extends Route
-				? [params?: Record<string, string>]
-				: keyof ParseRouteParams<Route> extends never
-					? []
-					: [params: Params & ExactRouteParams<Params, ParseRouteParams<Route>>]
-			: [params?: Record<string, string>]
-	) => string;
-	/**
-	 * Loads data for the page.
-	 */
-	load?: (event: PageLoadEvent<Route>) => PageLoadReturn<Data> | Promise<PageLoadReturn<Data>>;
-	/**
-	 * The component that is displayed for the page.
-	 */
-	component?: Component;
-	// TODO: Better typing
-	/**
-	 * The head element data for the page, which may include a <title> and <meta> elements.
-	 */
-	head?: HeadElement[] | ((event: PageLoadEvent<Route>) => HeadElement[]);
-}
-
-type HeadElement = TitleElement | MetaElement;
-
-interface TitleElement {
-	title: string;
-}
-
-interface MetaElement {
-	name: string;
-	content: string;
-}

package/src/types/PageForm.test-d.ts

@@ -1,78 +0,0 @@
-import badRequest from "../response/badRequest";
-import ok from "../response/ok";
-import type TypedResponse from "../response/TypedResponse";
-import type { PageData } from "./PageData";
-import type { PageForm } from "./PageForm";
-import type PageProps from "./PageProps";
-import type PageServerEndPoint from "./PageServerEndPoint";
-
-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 docs-site form pattern: ok for success, badRequest for validation errors
-interface FormServer {
-	actions: {
-		default: () => Promise<TypedResponse<{ ok: true } | { ok: false; message: string }>>;
-	};
-}
-
-export const formServer: FormServer = {
-	actions: {
-		default: async () =>
-			Math.random() > 0.5
-				? ok({ ok: true as const })
-				: badRequest({ ok: false as const, message: "bad text" }),
-	},
-};
-
-// The shape above is a valid +page.server endpoint
-export const formServerCompat: PageServerEndPoint<"/form"> = formServer;
-
-// PageForm extracts the union of action result bodies
-export type F01 = Expect<
-	Equals<PageForm<FormServer>, { ok: true } | { ok: false; message: string }>
->;
-
-// PageProps carries data and form together
-const props: PageProps<PageData<FormServer>, PageForm<FormServer>> = null as never;
-const form = props.form;
-export const okValue: boolean | undefined = form?.ok;
-export const message: string = form && form.ok === false ? form.message : "";
-
-// badRequest bodies are typed and Jsonify'd
-export const bad: TypedResponse<{ ok: false; message: string }> = badRequest({
-	ok: false,
-	message: "bad text",
-});
-export const untypedBad: Response = badRequest("plain");
-
-// Endpoints without actions fall back to a loose record
-interface LoadOnly {
-	load: () => Promise<TypedResponse<{ posts: { title: string }[] }>>;
-}
-export type F02 = Expect<Equals<PageForm<LoadOnly>, Record<string, any>>>;
-
-// Annotated (widened) endpoints fall back to a loose record
-export const widened: PageServerEndPoint<"/form"> = {
-	actions: { default: async () => ok({ ok: true }) },
-};
-export type F03 = Expect<Equals<PageForm<typeof widened>, Record<string, any>>>;
-
-// Multiple actions union their bodies
-interface MultiServer {
-	actions: {
-		save: () => Promise<TypedResponse<{ saved: true }>>;
-		remove: () => Promise<TypedResponse<{ removed: true }>>;
-	};
-}
-export type F04 = Expect<Equals<PageForm<MultiServer>, { saved: true } | { removed: true }>>;
-
-// Mixed typed and untyped action returns fall back to a loose record
-interface MixedServer {
-	actions: {
-		save: () => Promise<TypedResponse<{ saved: true }>>;
-		other: () => Promise<Response>;
-	};
-}
-export type F05 = Expect<Equals<PageForm<MixedServer>, Record<string, any>>>;

package/src/types/PageForm.ts

@@ -1,29 +0,0 @@
-import type TypedResponse from "../response/TypedResponse";
-
-/** The non-undefined return values of an endpoint's actions. */
-type ActionReturns<Actions> = {
-	[K in keyof Actions]: Actions[K] extends (event: any) => infer Return
-		? NonNullable<Awaited<Return>>
-		: never;
-}[keyof Actions];
-
-/**
- * The form result an endpoint's actions produce, i.e. what becomes the page's
- * `$props.form` after a submit, e.g.
- *
- * ```ts
- * import type server from "./+page.server";
- * type Form = PageForm<typeof server>;
- * ```
- *
- * Actions returning typed responses (e.g. `ok({ ... })`, `badRequest({ ... })`)
- * contribute their JSON bodies as a union. Falls back to a loose record when
- * there are no actions or their responses are untyped.
- */
-export type PageForm<EndPoint> = EndPoint extends { actions?: infer Actions }
-	? [NonNullable<Actions>] extends [never]
-		? Record<string, any>
-		: ActionReturns<NonNullable<Actions>> extends TypedResponse<infer Body>
-			? Body
-			: Record<string, any>
-	: Record<string, any>;

package/src/types/PageLoadEvent.ts

@@ -1,26 +0,0 @@
-import type { RouteParamsOf } from "./ParseRouteParams";
-
-/**
- * The event passed to client load functions. Annotate with a route path to
- * get typed params, e.g. `PageLoadEvent<"/posts/[id]">`, and with a data type
- * to type the data accumulated from the layouts above, e.g.
- * `PageLoadEvent<"/posts/[id]", PageData<typeof layoutServer>>`.
- */
-export default interface PageLoadEvent<
-	Route extends string | undefined = undefined,
-	Data = Record<string, any>,
-> {
-	/**
-	 * The URL for the server function.
-	 */
-	url: URL;
-	/**
-	 * Route params from the URL and route path.
-	 */
-	params: RouteParamsOf<Route>;
-	/**
-	 * Data loaded by the layouts above, accumulated top down. Loads may add to
-	 * it, and the merged result is passed into the page as `$props.data`.
-	 */
-	data: Data;
-}

package/src/types/PageLoadReturn.ts

@@ -1,13 +0,0 @@
-import type TypedResponse from "../response/TypedResponse";
-import type { UntypedResponse } from "../response/TypedResponse";
-
-/**
- * What a load function may return. When `Data` is provided, a typed response
- * (e.g. `ok({ ... })`) must only contain keys the page expects; untyped
- * responses (redirects, errors, plain text) are always allowed.
- */
-export type PageLoadReturn<Data> =
-	| TypedResponse<Partial<Data>>
-	| UntypedResponse
-	| undefined
-	| void;

package/src/types/PageProps.ts

@@ -1,14 +0,0 @@
-/**
- * The props passed to a page (or layout) component: the data accumulated from
- * load functions, plus the result of the last form action if any.
- */
-export default interface PageProps<Data = Record<string, any>, Form = Record<string, any>> {
-	/**
-	 * Data loaded by the page's (and its layouts') load functions.
-	 */
-	data: Data;
-	/**
-	 * The JSON result of the last form action, if a form was submitted.
-	 */
-	form: Form | undefined;
-}

package/src/types/PageServerAction.ts

@@ -1,13 +0,0 @@
-import type { RouteParamsOf } from "./ParseRouteParams";
-import type { FormDataRecord, QueryRecord } from "./ServerLoadEvent";
-import type ServerLoadEvent from "./ServerLoadEvent";
-
-type PageServerAction<
-	Route extends string | undefined = undefined,
-	FormBody = FormDataRecord,
-	Params = RouteParamsOf<Route>,
-> = (
-	event: ServerLoadEvent<Route, unknown, FormBody, QueryRecord, Params>,
-) => Response | undefined | void | Promise<Response | undefined | void>;
-
-export default PageServerAction;

package/src/types/PageServerEndPoint.test-d.ts

@@ -1,105 +0,0 @@
-import ok from "../response/ok";
-import type {
-	ActionBody,
-	LoadParams,
-	LoadQuery,
-	PageServerActionSchemas,
-} from "./PageServerEndPoint";
-import type PageServerEndPoint from "./PageServerEndPoint";
-import type { StandardSchemaV1 } from "./StandardSchema";
-
-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;
-
-// A mock schema library's schema, with input and output types
-declare const postSchema: StandardSchemaV1<{ title: string }, { title: string; upper: string }>;
-declare const querySchema: StandardSchemaV1<{ page: string }, { page: number }>;
-declare const paramsSchema: StandardSchemaV1<{ id: string }, { id: number }>;
-
-const schemas: { default: typeof postSchema } = { default: postSchema };
-
-// An endpoint declaring a schema for its default action. The `.upper` access
-// below compiles only when form() is contextually typed from the schema's
-// output, since actions map their body to their schema's key
-export const endPoint: PageServerEndPoint<"/form", Record<string, any>, typeof schemas> = {
-	schema: schemas,
-	actions: {
-		default: async ({ form }) => ok({ title: (await form()).upper }),
-	},
-};
-
-// The type helpers behind the load/action signatures
-export type A01 = Expect<
-	Equals<ActionBody<typeof schemas, "default">, { title: string; upper: string }>
->;
-export type A02 = Expect<
-	Equals<
-		ActionBody<typeof schemas, "missing">,
-		Record<string, FormDataEntryValue | FormDataEntryValue[]>
-	>
->;
-export type A03 = Expect<
-	Equals<
-		ActionBody<PageServerActionSchemas, "default">,
-		Record<string, FormDataEntryValue | FormDataEntryValue[]>
-	>
->;
-
-// The load function's schema (the `load` key) types the query string
-const querySchemas: { load: typeof querySchema } = { load: querySchema };
-export type A04 = Expect<Equals<LoadQuery<typeof querySchemas>, { page: number }>>;
-export type A05 = Expect<
-	Equals<LoadQuery<PageServerActionSchemas>, Record<string, string | string[]>>
->;
-
-// The `params` key types the params of the load function and actions
-const paramSchemas: { params: typeof paramsSchema } = { params: paramsSchema };
-export type A06 = Expect<Equals<LoadParams<typeof paramSchemas, "/posts/[id]">, { id: number }>>;
-export type A07 = Expect<
-	Equals<LoadParams<PageServerActionSchemas, "/posts/[id]">, { id: string }>
->;
-
-// An endpoint using all of them: the `page` access below compiles only when
-// the load's query is typed from its schema
-export const fullEndPoint: PageServerEndPoint<
-	"/posts/[id]",
-	Record<string, any>,
-	{ params: typeof paramsSchema; load: typeof querySchema; default: typeof postSchema }
-> = {
-	schema: {
-		params: paramsSchema,
-		load: querySchema,
-		default: postSchema,
-	},
-	load: async ({ params, query }) => ok({ id: params.id, page: (await query()).page }),
-	actions: {
-		default: async ({ params, form }) => ok({ id: params.id, title: (await form()).upper }),
-	},
-};
-
-// An untyped action keeps the loose form record and string params
-type PlainAction = NonNullable<NonNullable<typeof plainEndPoint.actions>["default"]>;
-const plainEndPoint: PageServerEndPoint<"/form"> = {
-	actions: {
-		default: async ({ form }) => ok({ title: (await form()).title }),
-	},
-};
-type PlainEvent = Parameters<PlainAction>[0];
-export type A08 = Expect<
-	Equals<
-		Awaited<ReturnType<PlainEvent["form"]>>,
-		Record<string, FormDataEntryValue | FormDataEntryValue[]>
-	>
->;
-
-// Typed ok() bodies still flow through actions (PageForm's source)
-type DefaultReturn = Awaited<
-	ReturnType<NonNullable<NonNullable<typeof endPoint.actions>["default"]>>
->;
-export type A09 = Expect<Equals<DefaultReturn, Response | undefined | void>>;
-
-// The schema property is optional, as before
-export type A10 = Expect<
-	Equals<PageServerEndPoint extends { schema?: unknown } ? true : false, true>
->;

package/src/types/PageServerEndPoint.ts

@@ -1,110 +0,0 @@
-import type { RouteParamsOf } from "./ParseRouteParams";
-import type PageServerAction from "./PageServerAction";
-import type PageServerLoad from "./PageServerLoad";
-import type { FormDataRecord, QueryRecord } from "./ServerLoadEvent";
-import type { StandardSchemaV1 } from "./StandardSchema";
-
-/**
- * Optional standard schemas for +page.server endpoints, keyed by name. Any
- * schema implementing the Standard Schema interface (zod, valibot, arktype,
- * etc) can be used.
- *
- * - action name schemas validate the submitted form data, surfaced through
- *   `event.form()` in the action
- * - the `load` key validates the URL's query string, surfaced through
- *   `event.query()` in the load function
- * - a `params` key validates (and generally coerces) the route params,
- *   surfaced through `event.params` in the load function and actions
- *
- * When a submitted form or query string fails validation, the action or load
- * function is not called and a 422 response with the schema's issues is
- * returned (which becomes the page's `$props.form` for actions). When route
- * params fail validation, a 404 response is returned, since the URL can't
- * refer to an existing resource.
- */
-export type PageServerActionSchemas = {
-	params?: StandardSchemaV1;
-	load?: StandardSchemaV1;
-	[action: string]: StandardSchemaV1 | undefined;
-};
-
-/**
- * The form values type for an action, inferred from its schema. Falls back
- * to a loose record for actions without a declared schema.
- */
-export type ActionBody<Schemas extends PageServerActionSchemas, Name extends string> = [
-	Name,
-] extends [keyof Schemas & string]
-	? Schemas[Name] extends StandardSchemaV1
-		? StandardSchemaV1.InferOutput<Schemas[Name]>
-		: FormDataRecord
-	: FormDataRecord;
-
-/**
- * The query type for the load function, inferred from its schema.
- */
-export type LoadQuery<Schemas extends PageServerActionSchemas> = Schemas extends {
-	load: StandardSchemaV1;
-}
-	? StandardSchemaV1.InferOutput<Schemas["load"]>
-	: QueryRecord;
-
-/**
- * The route params type, inferred from the `params` schema.
- */
-export type LoadParams<
-	Schemas extends PageServerActionSchemas,
-	Route extends string | undefined,
-> = Schemas extends { params: StandardSchemaV1 }
-	? StandardSchemaV1.InferOutput<Schemas["params"]>
-	: RouteParamsOf<Route>;
-
-/**
- * For +page.server. Annotate with a route path to get typed params, and with
- * a data shape to flag loads that return keys the page doesn't expect, e.g.
- * `PageServerEndPoint<"/posts/[id]", { posts: Post[] }>`. Annotate with a
- * schemas object to get typed (and validated) form values, query strings and
- * params, e.g. `PageServerEndPoint<"/posts", Record<string, any>, typeof schema>`.
- */
-export default interface PageServerEndPoint<
-	Route extends string | undefined = undefined,
-	Data = Record<string, any>,
-	Schemas extends PageServerActionSchemas = PageServerActionSchemas,
-> {
-	/**
-	 * Loads data from the server for a page. Its schema (the `load` key)
-	 * validates the URL's query string.
-	 */
-	load?: PageServerLoad<Route, Data, LoadQuery<Schemas>, LoadParams<Schemas, Route>>;
-	/**
-	 * A map of actions that can be performed on the server for a page, generally from a form submit.
-	 */
-	actions?: {
-		[Name in string]: PageServerAction<
-			Route,
-			ActionBody<Schemas, Name>,
-			LoadParams<Schemas, Route>
-		>;
-	};
-	/**
-	 * Optional standard schemas for validating requests, keyed by action name
-	 * (plus `load` for the query string and `params` for the route params),
-	 * e.g.
-	 *
-	 * ```ts
-	 * const schema = {
-	 *   params: z.object({ id: z.coerce.number() }),
-	 *   load: z.object({ page: z.coerce.number() }),
-	 *   default: z.object({ title: z.string() }),
-	 * };
-	 * export default {
-	 *   schema,
-	 *   load: async ({ query }) => ok(await query()),
-	 *   actions: {
-	 *     default: async ({ form }) => ok((await form()).title),
-	 *   },
-	 * } satisfies PageServerEndPoint<"/posts/[id]", Record<string, any>, typeof schema>;
-	 * ```
-	 */
-	schema?: Schemas | undefined;
-}

package/src/types/PageServerLoad.ts

@@ -1,15 +0,0 @@
-import type { RouteParamsOf } from "./ParseRouteParams";
-import type { PageLoadReturn } from "./PageLoadReturn";
-import type { FormDataRecord, QueryRecord } from "./ServerLoadEvent";
-import type ServerLoadEvent from "./ServerLoadEvent";
-
-type PageServerLoad<
-	Route extends string | undefined = undefined,
-	Data = Record<string, any>,
-	QueryBody = QueryRecord,
-	Params = RouteParamsOf<Route>,
-> = (
-	event: ServerLoadEvent<Route, unknown, FormDataRecord, QueryBody, Params>,
-) => PageLoadReturn<Data> | Promise<PageLoadReturn<Data>>;
-
-export default PageServerLoad;

package/src/types/PageState.ts

@@ -1,8 +0,0 @@
-export default interface PageState {
-	status: number;
-	url: URL;
-	form?: Record<string, string | number>;
-	error?: {
-		message: string;
-	};
-}