@primate/core 0.8.8 → 0.9.0

package/lib/private/route/Options.d.ts

@@ -1,11 +1,13 @@
 import type http from "@rcompat/http";
-import type { ObjectType, Parsed } from "pema";
+import type { AsyncType, ObjectType } from "pema";
+import type { Parsed } from "pema";
 type MIME = Omit<typeof http.MIME, "resolve" | "extension">;
 type MIMEValue = MIME[keyof MIME];
+type BodySchema = Parsed<unknown> | AsyncType;
 type RouteOptions = {
     contentType?: MIMEValue;
-    body?: Parsed<unknown>;
-    path?: ObjectType;
+    body?: BodySchema;
+    path?: ObjectType | AsyncType;
 };
 export type { RouteOptions as default };
 //# sourceMappingURL=Options.d.ts.map

package/lib/private/route/router.js

@@ -16,7 +16,8 @@ class Router {
             throw E.hook_route_functions_not_allowed(path);
         if (options?.path !== undefined) {
             const declared = Object.keys(options.path.properties);
-            const expected = [...path.matchAll(/\[([^\]]+)\]/g)].map(m => m[1]);
+            const expected = [...path.matchAll(/\[([^\]]+)\]/g)]
+                .map(m => m[1].replace(/^[\[.]+/, ""));
             const missing = expected.filter(k => !declared.includes(k));
             const extra = declared.filter(k => !expected.includes(k));
             if (missing.length > 0 || extra.length > 0) {

package/lib/private/route.client.d.ts

@@ -1,27 +1,32 @@
 import type ResponseLike from "#response/ResponseLike";
+import type ResponseFunction from "#response/ResponseFunction";
 import type ContentTypeMap from "#route/ContentTypeMap";
 import type RouteHandler from "#route/Handler";
 import hook from "#route/hook";
 import type RouteOptions from "#route/Options";
 import type { Unpack } from "@rcompat/type";
-import type { Parsed } from "pema";
+type InferSchema<S> = S extends {
+    infer: infer I;
+} ? Awaited<I> : never;
 type Body<O extends RouteOptions> = O extends {
     contentType: infer _CT extends keyof ContentTypeMap;
-    body: infer S extends Parsed<unknown>;
-} ? Unpack<S["infer"]> : O extends {
+    body: infer S;
+} ? Unpack<InferSchema<S>> : O extends {
     contentType: infer CT extends keyof ContentTypeMap;
 } ? ContentTypeMap[CT] : never;
 type Path<O extends RouteOptions> = O extends {
-    path: infer S extends Parsed<unknown>;
-} ? Unpack<S["infer"]> : never;
+    path: infer S;
+} ? Unpack<InferSchema<S>> : never;
 type MethodMeta = {
     contentType?: string;
 };
 type RequestMeta = {
     headers?: HeadersInit;
 };
+type Page<R> = Awaited<R> extends ResponseFunction<infer Props> ? Props : never;
 type ClientMethod<O extends RouteOptions, R = unknown> = MethodMeta & {
     _result?: R;
+    Page: Page<R>;
 } & (Body<O> extends never ? Path<O> extends never ? (args?: RequestMeta) => Promise<Response> : (args: {
     path: Path<O>;
 } & RequestMeta) => Promise<Response> : Path<O> extends never ? (args: {
@@ -34,7 +39,7 @@ type ClientRoute<R> = {
     [K in keyof R]: R[K] extends {
         options: infer O extends RouteOptions;
         result?: infer Result;
-    } ? ClientMethod<O, Result> : (args?: RequestMeta) => Promise<Response>;
+    } ? ClientMethod<O, Result> : R[K] extends (...args: any[]) => infer Result ? ClientMethod<{}, Result> : (args?: RequestMeta) => Promise<Response>;
 };
 type WithResult<O extends RouteOptions, R = unknown> = {
     handler: RouteHandler<O>;

package/lib/private/route.client.js

@@ -1,4 +1,5 @@
 import hook from "#route/hook";
+import is from "@rcompat/is";
 function is_with(value) {
     return typeof value === "object" &&
         value !== null &&
@@ -33,8 +34,15 @@ function route(handlers) {
         connect(path) {
             return Object.fromEntries(Object.entries(this._handlers).map(([method, { contentType }]) => {
                 const fn = async (args = {}) => {
-                    const resolved = args.path !== undefined
-                        ? path.replace(/\[([^\]]+)\]/g, (_, key) => encodeURIComponent(args.path[key] ?? `[${key}]`))
+                    const resolved = is.defined(args.path)
+                        ? path.replace(/\[{1,2}\.{0,3}([^\]]+)\]{1,2}/g, (match, key) => {
+                            const is_rest = match.includes("...");
+                            const is_optional = match.startsWith("[[");
+                            const value = args.path[key];
+                            if (value === undefined)
+                                return is_optional ? "" : match;
+                            return is_rest ? value : encodeURIComponent(value);
+                        })
                         : path;
                     return fetch(resolved, {
                         method: method.toUpperCase(),

package/lib/private/route.d.ts

@@ -1,3 +1,5 @@
+import type ResponseFunction from "#response/ResponseFunction";
+import type NarrowedRequest from "#route/NarrowedRequest";
 import type RouteHandler from "#route/Handler";
 import hook from "#route/hook";
 import type RouteOptions from "#route/Options";
@@ -5,19 +7,28 @@ import type { Method } from "@rcompat/http";
 declare const BRAND: unique symbol;
 type WithResult<O extends RouteOptions> = {
     [BRAND]: true;
-    handler: RouteHandler;
+    handler: (request: NarrowedRequest<O>) => unknown;
     options: O;
 };
+type Page<R> = Awaited<R> extends ResponseFunction<infer Props> ? Props : never;
 type AnyHandler = RouteHandler | WithResult<RouteOptions>;
 type RouteHandlers = {
     [key in Method]?: AnyHandler;
 };
-declare function route(handlers: RouteHandlers): {
-    [k: string]: {
-        handler: RouteHandler;
-        options: RouteOptions;
-    };
+type RouteMethod<O extends RouteOptions> = {
+    handler: (request: NarrowedRequest<O>) => unknown;
+    options: O;
+    Page: never;
+};
+type RouteMethodWithResult<O extends RouteOptions, R> = Omit<RouteMethod<O>, "Page"> & {
+    Page: Page<R>;
+};
+type Routes<R extends RouteHandlers> = {
+    [K in keyof R]: R[K] extends WithResult<infer O extends RouteOptions> ? R[K] extends {
+        handler: (...args: any[]) => infer Result;
+    } ? RouteMethodWithResult<O, Result> : RouteMethod<O> : R[K] extends (...args: any[]) => infer Result ? RouteMethodWithResult<{}, Result> : RouteMethod<{}>;
 };
+declare function route<R extends RouteHandlers>(handlers: R): Routes<R>;
 declare namespace route {
     var _a: <O extends RouteOptions>(options: O, handler: RouteHandler<O>) => WithResult<O>;
     export { _a as with };

package/lib/private/serve/App.d.ts

@@ -30,18 +30,26 @@ export default class ServeApp extends App {
     media(content_type: string, response?: ResponseInit): ResponseInit;
     create_csp(): void;
     frontend(extension: string, view_response: ViewResponse): void;
-    page(name?: string): string;
+    template(name?: string): string;
+    page(route: string): string;
     serve_assets(pathname: string): Promise<Response | undefined>;
     start(): Promise<void>;
     stop(): void;
     upgrade(request: Request, actions: Actions): null;
     route(request: RequestFacade): Promise<{
-        errors: RouteHandler[];
+        errors: {
+            handler: RouteHandler;
+            path: string;
+        }[];
         hooks: import("../module/RequestHook.js").default[];
-        layouts: RouteHandler[];
+        layouts: {
+            handler: RouteHandler;
+            path: string;
+        }[];
         handler: RouteHandler;
         request: any;
         is_head: boolean;
+        path: string;
     } | undefined>;
 }
 export {};

package/lib/private/serve/App.js

@@ -92,10 +92,11 @@ export default class ServeApp extends App {
     #init;
     #server;
     #views;
+    #pages = {};
     #csp = {};
     #assets = [];
     #serve_assets;
-    #pages;
+    #templates;
     #frontends = new Map();
     #router;
     #entrypoints = {};
@@ -117,8 +118,9 @@ export default class ServeApp extends App {
             const extension = Object.keys(this.frontends).find(e => f.endsWith(e));
             return is.undefined(extension) ? name : f.slice(0, -extension.length);
         });
+        this.#pages = Object.fromEntries(init.pages ?? []);
         this.#serve_assets = init.assets;
-        this.#pages = init.pages;
+        this.#templates = init.templates;
         const http_config = this.#init.facade[s_config].http;
         this.set(s_http, {
             host: http_config.host,
@@ -137,16 +139,16 @@ export default class ServeApp extends App {
             },
         }, init.routes.map(s => s[0]));
         if (init.mode === "development")
-            this.register(dev_module());
+            this.module(dev_module());
         const assets = this.serve_assets.bind(this);
         const bound_route = (request) => route(this, request);
         if (init.session !== undefined) {
-            this.register(session_module(init.session));
+            this.module(session_module(init.session));
         }
         const i18n_config = init.facade[s_config].i18n;
         if (i18n_config !== undefined)
-            this.register(i18n_module(i18n_config));
-        this.register(create({
+            this.module(i18n_module(i18n_config));
+        this.module(create({
             name: "builtin/handle",
             setup({ onHandle }) {
                 onHandle(async (request) => {
@@ -190,7 +192,7 @@ export default class ServeApp extends App {
     }
     ;
     render(content) {
-        const { body, head, page, partial, placeholders = {} } = content;
+        const { body, head, template, partial, placeholders = {} } = content;
         ["body", "head"].forEach(key => assert.undefined(placeholders[key]));
         const all_placeholders = {
             ...this.#entrypoints,
@@ -200,7 +202,7 @@ export default class ServeApp extends App {
         return partial === true ? body : Object.entries(all_placeholders)
             // replace given placeholders, defaulting to ""
             .reduce((rendered, [key, value]) => rendered
-            .replaceAll(`%${key}%`, value?.toString() ?? ""), this.page(page))
+            .replaceAll(`%${key}%`, value?.toString() ?? ""), this.template(template))
             // replace non-given placeholders, aside from %body% / %head%
             .replaceAll(/(?<keep>%(?:head|body)%)|%.*?%/gus, "$1")
             // replace body and head
@@ -256,9 +258,15 @@ export default class ServeApp extends App {
         this.#frontends.set(extension, view_response);
     }
     ;
-    page(name) {
-        const page_name = name ?? location.app_html;
-        return this.#pages[page_name];
+    template(name) {
+        const template_name = name ?? location.app_html;
+        return this.#templates[template_name];
+    }
+    page(route) {
+        const key = this.#pages[route];
+        if (is.undefined(key))
+            throw E.response_page_missing(route);
+        return key;
     }
     async #try_serve(ref) {
         if (await ref.exists() && await ref.type() === "file") {
@@ -383,12 +391,12 @@ export default class ServeApp extends App {
         const method = request.method.toLowerCase();
         const specials = matched.specials;
         const errors = (specials.error ?? [])
-            .map(v => router.get(v)[method]?.handler)
-            .filter(Boolean)
+            .map(v => ({ handler: router.get(v)[method]?.handler, path: v }))
+            .filter(({ handler }) => Boolean(handler))
             .toReversed();
         const layouts = (specials.layout ?? [])
-            .map(v => router.get(v)[method]?.handler)
-            .filter(Boolean)
+            .map(v => ({ handler: router.get(v)[method]?.handler, path: v }))
+            .filter(({ handler }) => Boolean(handler))
             .toReversed();
         const hooks = (specials.hook ?? [])
             .toReversed()
@@ -410,10 +418,11 @@ export default class ServeApp extends App {
                 throw E.request_content_type_mismatch(contentType, actual);
             }
         }
+        const params = is.defined(path)
+            ? await path.parse(matched.params)
+            : matched.params;
         const refined = Object.assign(Object.create(request), {
-            path: new RequestBag(is.defined(path)
-                ? path.parse(matched.params)
-                : matched.params, "path", {
+            path: new RequestBag(params, "path", {
                 normalize: k => k.toLowerCase(),
                 raw: request.url.pathname,
             }),
@@ -421,7 +430,7 @@ export default class ServeApp extends App {
                 ? { body: request.body[BodyPatch]({ contentType, schema: body }) }
                 : {}),
         });
-        return { errors, hooks, layouts, handler, request: refined, is_head };
+        return { errors, hooks, layouts, handler, request: refined, is_head, path: matched.path };
     }
 }
 //# sourceMappingURL=App.js.map

package/lib/private/serve/Init.d.ts

@@ -18,6 +18,7 @@ type ServeInit = {
         }>;
     };
     views?: [string, Import][];
+    pages?: [string, string][];
     facade: AppFacade;
     routes: [string, {
         default: any;
@@ -25,7 +26,7 @@ type ServeInit = {
     mode: Mode;
     target: string;
     log: typeof LogSchema.infer;
-    pages: Dict<string>;
+    templates: Dict<string>;
     session?: SessionConfig;
 };
 export type { ServeInit as default };

package/lib/public/events.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#events";
+//# sourceMappingURL=events.d.ts.map

package/lib/public/events.js

@@ -0,0 +1,2 @@
+export { default } from "#events";
+//# sourceMappingURL=events.js.map

package/lib/public/response.d.ts

@@ -1,18 +1,17 @@
 import binary from "#response/binary";
 import error from "#response/error";
+import page from "#response/page";
 import view from "#response/view";
 import $null from "#response/null";
 declare const response: {
     binary: typeof binary;
     error: typeof error;
     json: (body: unknown, init?: ResponseInit) => (app: import("./index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
+    page: typeof page;
     redirect: (location: string, status?: 300 | 301 | 302 | 303 | 304 | 307 | 308) => import("./index.js").ResponseFunction;
-    sse: (body: {
-        close?(): undefined;
-        open(events: {
-            send(name: string, data: unknown): undefined;
-        }): undefined;
-    }, init?: ResponseInit) => (app: import("./index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
+    sse: (body: (source: {
+        send(name: string, data: unknown): void;
+    }) => void | (() => void), init?: ResponseInit) => (app: import("./index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
     text: (body: string, init?: ResponseInit) => (app: import("./index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
     view: typeof view;
     ws: (actions: import("@rcompat/http").Actions) => import("./index.js").ResponseFunction;

package/lib/public/response.js

@@ -1,6 +1,7 @@
 import binary from "#response/binary";
 import error from "#response/error";
 import json from "#response/json";
+import page from "#response/page";
 import redirect from "#response/redirect";
 import sse from "#response/sse";
 import text from "#response/text";
@@ -11,6 +12,7 @@ const response = {
     binary,
     error,
     json,
+    page,
     redirect,
     sse,
     text,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/core",
-  "version": "0.8.8",
+  "version": "0.9.0",
   "description": "The universal web framework",
   "homepage": "https://primate.run",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -18,24 +18,24 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@rcompat/assert": "^0.13.0",
-    "@rcompat/cli": "^0.24.0",
-    "@rcompat/crypto": "^0.21.0",
-    "@rcompat/dict": "^0.10.0",
-    "@rcompat/env": "^0.22.2",
-    "@rcompat/error": "^0.8.0",
-    "@rcompat/fn": "^0.10.0",
-    "@rcompat/fs": "^0.33.2",
-    "@rcompat/http": "^0.30.0",
-    "@rcompat/io": "^0.10.0",
-    "@rcompat/is": "^0.11.0",
-    "@rcompat/kv": "^0.13.0",
-    "@rcompat/runtime": "^0.16.0",
-    "@rcompat/string": "^0.21.0",
-    "@rcompat/symbol": "^0.2.0",
-    "@rcompat/type": "^0.17.0",
-    "esbuild": "^0.28.0",
-    "pema": "^0.8.3"
+    "@rcompat/assert": "^0.14.0",
+    "@rcompat/cli": "^0.25.0",
+    "@rcompat/crypto": "^0.22.0",
+    "@rcompat/dict": "^0.11.0",
+    "@rcompat/env": "^0.23.0",
+    "@rcompat/error": "^0.9.0",
+    "@rcompat/fn": "^0.11.0",
+    "@rcompat/fs": "^0.35.1",
+    "@rcompat/http": "^0.31.0",
+    "@rcompat/io": "^0.11.0",
+    "@rcompat/is": "^0.12.0",
+    "@rcompat/kv": "^0.14.0",
+    "@rcompat/runtime": "^0.17.0",
+    "@rcompat/string": "^0.22.0",
+    "@rcompat/symbol": "^0.3.0",
+    "@rcompat/type": "^0.18.0",
+    "esbuild": "^0.28.1",
+    "pema": "^0.9.0"
   },
   "imports": {
     "#i18n/config": {
@@ -94,7 +94,7 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsgo && cp -a src/private/defaults lib/private",
+    "build": "npm run clean && tsc && cp -a src/private/defaults lib/private",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
     "test": "npx proby"

package/lib/private/Binder.d.ts

@@ -1,11 +0,0 @@
-import type { FileRef } from "@rcompat/fs";
-import type { MaybePromise } from "@rcompat/type";
-type Options = {
-    build: {
-        id: string;
-    };
-    context: string;
-};
-type Binder = (file: FileRef, options: Options) => MaybePromise<string>;
-export type { Binder as default };
-//# sourceMappingURL=Binder.d.ts.map

package/lib/private/Binder.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Binder.js.map

package/lib/private/build/server/plugin/virtual-pages.d.ts

@@ -1,4 +0,0 @@
-import type BuildApp from "#build/App";
-import type { Plugin } from "esbuild";
-export default function plugin_server_virtual_pages(app: BuildApp): Plugin;
-//# sourceMappingURL=virtual-pages.d.ts.map