@primate/core 0.4.6 → 0.6.0

package/lib/private/response/error.js

@@ -1,5 +1,5 @@
 import location from "#location";
-import Status from "@rcompat/http/Status";
+import { Status } from "@rcompat/http";
 /**
  * Render an error page.
  *

package/lib/private/response/json.d.ts

@@ -4,6 +4,6 @@
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: unknown, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+declare const _default: (body: unknown, init?: ResponseInit) => (app: import("../index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
 export default _default;
 //# sourceMappingURL=json.d.ts.map

package/lib/private/response/json.js

@@ -1,10 +1,10 @@
 import response from "#response";
-import mime from "@rcompat/http/mime/application/json";
+import { MIME } from "@rcompat/http";
 /**
  * Issue a JSON response
  * @param body body object
  * @param options response options
  * @return Response rendering function
  */
-export default response(mime, JSON.stringify);
+export default response(MIME.APPLICATION_JSON, JSON.stringify);
 //# sourceMappingURL=json.js.map

package/lib/private/response/redirect.d.ts

@@ -1,11 +1,11 @@
 import type ResponseFunction from "#response/ResponseFunction";
 type Redirection = 300 | 301 | 302 | 303 | 304 | 307 | 308;
 /**
- * Redirect request
- * @param location location to redirect to
- * @param status redirection 3xx code
- * @return Response rendering function
- */
+* Redirect request
+* @param location location to redirect to
+* @param status redirection 3xx code
+* @return Response rendering function
+*/
 declare const _default: (location: string, status?: Redirection) => ResponseFunction;
 export default _default;
 //# sourceMappingURL=redirect.d.ts.map

package/lib/private/response/redirect.js

@@ -1,4 +1,4 @@
-import Status from "@rcompat/http/Status";
+import { Status } from "@rcompat/http";
 function hasCRLF(s) {
     return /[\r\n]/.test(s);
 }
@@ -22,9 +22,8 @@ function encodePathname(s) {
         .map((each, i) => i === 0 ? "" : encodeURIComponent(each)).join("/");
 }
 function toSearch(query) {
-    if (!query) {
+    if (!query)
         return "";
-    }
     const search = Object.entries(query)
         .filter(([, v]) => v !== null && v !== undefined)
         .reduce((params, [k, v]) => {
@@ -36,7 +35,7 @@ function toSearch(query) {
 }
 function toNormalized(relative, base) {
     // base -> URL resolution
-    if (base) {
+    if (base !== undefined) {
         const url = new URL(relative, new URL(String(base)));
         return url.pathname + url.search;
     }
@@ -48,18 +47,18 @@ function toNormalized(relative, base) {
     return i === -1 ? relative : relative.slice(0, i);
 }
 /**
- * Redirect request
- * @param location location to redirect to
- * @param status redirection 3xx code
- * @return Response rendering function
- */
+* Redirect request
+* @param location location to redirect to
+* @param status redirection 3xx code
+* @return Response rendering function
+*/
 export default (location, status) => 
 // no body
 app => app.respond(null, {
     headers: {
         "Content-Length": String(0),
         Location: location,
-        "Cache-Control": 'no-cache',
+        "Cache-Control": "no-cache",
     },
     status: status ?? Status.FOUND,
 });

package/lib/private/response/respond.js

@@ -1,31 +1,30 @@
-import fail from "#fail";
+import E from "#errors";
 import binary from "#response/binary";
 import json from "#response/json";
 import redirect from "#response/redirect";
 import text from "#response/text";
 import Streamable from "@rcompat/fs/Streamable";
-import Status from "@rcompat/http/Status";
-import proper from "@rcompat/record/proper";
-function invalid_body(body) {
-    throw fail("invalid body {0} returned from route", body);
-}
-const is_instance = (of) => ((value) => value instanceof of);
-const is_response = is_instance(Response);
-const is_url = is_instance(URL);
-const is_null = (value) => value === null;
+import { Status } from "@rcompat/http";
+import is from "@rcompat/is";
 function match(m) {
     return m;
 }
 // [if, then]
 const guesses = match([
-    [is_null, () => () => new Response(null, { status: Status.NO_CONTENT })],
-    [is_url, value => redirect(value.toString())],
+    [is.null, () => () => new Response(null, { status: Status.NO_CONTENT })],
+    [is.url, value => redirect(value.toString())],
     [Streamable.is, value => binary(value)],
-    [(value) => is_response(value), value => _ => value],
-    [proper, json],
-    [(value) => typeof value === "string", text],
+    [is.response, value => _ => value],
+    [is.dict, json],
+    [is.array, json],
+    [is.string, text],
 ]);
-const guess = (value) => guesses.find(([_if]) => _if(value))?.[1](value)
-    ?? invalid_body(`${value}`);
+function guess(value) {
+    const found = guesses.find(([_if]) => _if(value))?.[1](value);
+    if (found === undefined)
+        throw E.response_invalid_body(`${value}`);
+    return found;
+}
+;
 export default (result) => typeof result === "function" ? result : guess(result);
 //# sourceMappingURL=respond.js.map

package/lib/private/response/sse.d.ts

@@ -10,6 +10,6 @@ type Body = {
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: Body, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+declare const _default: (body: Body, init?: ResponseInit) => (app: import("../index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
 export default _default;
 //# sourceMappingURL=sse.d.ts.map

package/lib/private/response/sse.js

@@ -1,5 +1,5 @@
 import response from "#response";
-import mime from "@rcompat/http/mime/text/event-stream";
+import { MIME } from "@rcompat/http";
 const encode = (input) => new TextEncoder().encode(input);
 const handle = (body) => new ReadableStream({
     cancel() {
@@ -21,5 +21,5 @@ const handle = (body) => new ReadableStream({
  * @param options response options
  * @return Response rendering function
  */
-export default response(mime, handle);
+export default response(MIME.TEXT_EVENT_STREAM, handle);
 //# sourceMappingURL=sse.js.map

package/lib/private/response/text.d.ts

@@ -4,6 +4,6 @@
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: string, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+declare const _default: (body: string, init?: ResponseInit) => (app: import("../index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
 export default _default;
 //# sourceMappingURL=text.d.ts.map

package/lib/private/response/text.js

@@ -1,11 +1,11 @@
 import response from "#response";
-import identity from "@rcompat/function/identity";
-import mime from "@rcompat/http/mime/text/plain";
+import fn from "@rcompat/fn";
+import { MIME } from "@rcompat/http";
 /**
  * Return a plaintext response
  * @param body plaintext body
  * @param options response options
  * @return Response rendering function
  */
-export default response(mime, identity);
+export default response(MIME.TEXT_PLAIN, fn.identity);
 //# sourceMappingURL=text.js.map

package/lib/private/response/view.d.ts

@@ -1,6 +1,6 @@
-import type ViewOptions from "#frontend/ViewOptions";
-import type Dict from "@rcompat/type/Dict";
-import type ResponseFunction from "./ResponseFunction.js";
+import type ViewOptions from "#client/ViewOptions";
+import type ResponseFunction from "#response/ResponseFunction";
+import type { Dict } from "@rcompat/type";
 declare function view<Props>(component: (props: Props) => any, props: Props, options?: ViewOptions): ResponseFunction;
 declare function view(component: () => any, props?: Dict, options?: ViewOptions): ResponseFunction;
 declare function view(name: string, props?: Dict, options?: ViewOptions): ResponseFunction;

package/lib/private/response/view.js

@@ -1,5 +1,5 @@
-import fail from "#fail";
-import FileRef from "@rcompat/fs/FileRef";
+import E from "#errors";
+import fs from "@rcompat/fs";
 const extensions = ["extension", "fullExtension"];
 const backmap = {
     "component.ts": "angular",
@@ -17,14 +17,6 @@ const backmap = {
     tsx: "react",
     jsx: "react",
 };
-function no_frontend(view) {
-    const extension = new FileRef(view).fullExtension.slice(1);
-    const hasPkg = extension in backmap;
-    const error = "No frontend for {0}";
-    const fix = hasPkg ? ", did you configure {1}?" : "";
-    const pkgname = hasPkg ? `@primate/${backmap[extension]}` : "";
-    return fail(`${error}${fix}`, view, pkgname);
-}
 /**
  * Render a view component using a frontend for the given filename extension
  * @param view path to view
@@ -33,14 +25,15 @@ function no_frontend(view) {
  * @return Response rendering function
  */
 function view(name, props, options) {
-    const _name = name;
+    const view_name = name;
     return async (app, transfer, request) => {
         const found_view = extensions
-            .map(extension => app.frontends[new FileRef(_name)[extension]])
-            .find(extension => extension !== undefined)?.(_name, props, options)(app, transfer, request);
+            .map(extension => app.frontends[fs.ref(view_name)[extension]])
+            .find(extension => extension !== undefined)?.(view_name, props, options)(app, transfer, request);
         if (found_view !== undefined)
             return found_view;
-        throw no_frontend(_name);
+        const extension = fs.ref(view_name).fullExtension.slice(1);
+        throw E.frontend_missing(view_name, backmap[extension]);
     };
 }
 export default view;

package/lib/private/response/ws.d.ts

@@ -1,5 +1,5 @@
 import type ResponseFunction from "#response/ResponseFunction";
-import type Actions from "@rcompat/http/Actions";
+import type { Actions } from "@rcompat/http";
 declare const _default: (actions: Actions) => ResponseFunction;
 export default _default;
 //# sourceMappingURL=ws.d.ts.map

package/lib/private/response.d.ts

@@ -1,5 +1,5 @@
 import type ServeApp from "#serve/App";
-import type MaybePromise from "@rcompat/type/MaybePromise";
+import type { MaybePromise } from "@rcompat/type";
 declare const _default: <T>(mime: string, mapper: (input: T) => BodyInit) => (body: T, init?: ResponseInit) => (app: ServeApp) => MaybePromise<Response>;
 export default _default;
 //# sourceMappingURL=response.d.ts.map

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

@@ -1,6 +1,6 @@
 import type RequestFacade from "#request/RequestFacade";
 import type ResponseLike from "#response/ResponseLike";
-import type MaybePromise from "@rcompat/type/MaybePromise";
+import type { MaybePromise } from "@rcompat/type";
 type RouteHandler = (request: RequestFacade) => MaybePromise<ResponseLike>;
 export { RouteHandler as default };
 //# sourceMappingURL=Handler.d.ts.map

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

@@ -0,0 +1,6 @@
+import type NextRoute from "#module/NextRoute";
+import type RequestFacade from "#request/RequestFacade";
+import type ResponseLike from "#response/ResponseLike";
+import type { MaybePromise } from "@rcompat/type";
+export default function hook(fn: (request: RequestFacade, next: NextRoute) => MaybePromise<ResponseLike>): void;
+//# sourceMappingURL=hook.d.ts.map

package/lib/private/route/hook.js

@@ -0,0 +1,5 @@
+import router from "#route/router";
+export default function hook(fn) {
+    router.addHook(fn);
+}
+//# sourceMappingURL=hook.js.map

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

@@ -1,3 +1,4 @@
+import type RequestHook from "#module/RequestHook";
 import type Verb from "#request/Verb";
 import type RouteHandler from "#route/Handler";
 import type RouteOptions from "#route/Options";
@@ -8,12 +9,15 @@ declare class Router {
     pop(): void;
     get active(): string | undefined;
     add(verb: Verb, handler: RouteHandler, options?: RouteOptions): void;
+    addHook(fn: RequestHook): void;
+    getHooks(path: string): RequestHook[];
+    verifyHook(path: string): void;
     get(path: string): {
-        head?: {
+        options?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        options?: {
+        head?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;

package/lib/private/route/router.js

@@ -1,29 +1,43 @@
+import E from "#errors";
 import assert from "@rcompat/assert";
-import is from "@rcompat/assert/is";
-import maybe from "@rcompat/assert/maybe";
 const stack = [];
 export const routes = stack;
+function is_hook_file(p) {
+    const basename = p.split("/").at(-1) ?? p;
+    return basename === "+hook" || basename.startsWith("+hook.");
+}
 class Router {
     #routes = {};
-    push(route) {
-        stack.push(route);
+    #hooks = {};
+    push(route) { stack.push(route); }
+    pop() { stack.pop(); }
+    get active() { return stack.at(-1); }
+    add(verb, handler, options) {
+        assert.string(verb);
+        assert.function(handler);
+        assert.maybe.dict(options);
+        assert.maybe.boolean(options?.parseBody);
+        const active = assert.defined(this.active);
+        if (is_hook_file(active))
+            throw E.hook_route_functions_not_allowed(active);
+        const _routes = this.#routes;
+        if (!(active in _routes))
+            _routes[active] = {};
+        _routes[active][verb] = { handler, options: options ?? {} };
     }
-    pop() {
-        stack.pop();
+    addHook(fn) {
+        assert.function(fn);
+        const active = assert.defined(this.active);
+        if (!is_hook_file(active))
+            throw E.hook_not_allowed(active);
+        (this.#hooks[active] ??= []).push(fn);
     }
-    get active() {
-        return stack.at(-1);
+    getHooks(path) {
+        return [...(this.#hooks[path] ?? [])];
     }
-    add(verb, handler, options = {}) {
-        assert(this.active !== undefined);
-        is(handler).function();
-        maybe(options).object();
-        const active = this.active;
-        const routes = this.#routes;
-        if (!(active in routes)) {
-            routes[active] = {};
-        }
-        routes[active][verb] = { handler, options };
+    verifyHook(path) {
+        if ((this.#hooks[path] ?? []).length === 0)
+            throw E.hook_unused(path);
     }
     get(path) {
         return { ...this.#routes[path] };

package/lib/private/route/wrap.js

@@ -1,7 +1,7 @@
-import dedent from "@rcompat/string/dedent";
+import string from "@rcompat/string";
 export default function wrap(code, path, build_id) {
     const router = `ROUTER_${build_id}`;
-    const prelude = dedent `
+    const prelude = string.dedent `
     import ${router} from "primate/router";
     ${router}.push("${path}");
   `;

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

@@ -1,17 +1,15 @@
 import App from "#App";
 import type Asset from "#asset/Asset";
-import type ServerView from "#frontend/ServerView";
-import type ViewOptions from "#frontend/ViewOptions";
-import type ViewResponse from "#frontend/ViewResponse";
+import type ServerView from "#client/ServerView";
+import type ViewOptions from "#client/ViewOptions";
+import type ViewResponse from "#client/ViewResponse";
 import type I18NConfig from "#i18n/Config";
-import RequestBag from "#request/RequestBag";
-import RequestBody from "#request/RequestBody";
 import type RequestFacade from "#request/RequestFacade";
 import type RouteHandler from "#route/Handler";
 import type ServeInit from "#serve/Init";
 import FileRouter from "@rcompat/fs/FileRouter";
-import type Actions from "@rcompat/http/Actions";
-import type Dict from "@rcompat/type/Dict";
+import type { Actions } from "@rcompat/http";
+import type { Dict } from "@rcompat/type";
 interface FullViewOptions extends ViewOptions {
     body: string;
 }
@@ -26,11 +24,10 @@ export default class ServeApp extends App {
     constructor(rootfile: string, init: ServeInit);
     get secure(): boolean;
     get assets(): Asset[];
-    get modules(): import("../Module.js").default[];
     get url(): string;
     get router(): FileRouter;
     get frontends(): {
-        [x: string]: ViewResponse | undefined;
+        [k: string]: ViewResponse;
     };
     get stores(): Dict;
     get i18n(): I18NConfig | undefined;
@@ -45,29 +42,18 @@ export default class ServeApp extends App {
     media(content_type: string, response?: ResponseInit): ResponseInit;
     publish({ code, inline, src, type }: PublishOptions): Promise<void>;
     create_csp(): void;
-    register(extension: string, viewFunction: ViewResponse): void;
+    frontend(extension: string, view_response: ViewResponse): void;
     page(name?: string): string;
-    serveAsset(pathname: string): Promise<Response | undefined>;
+    serve_assets(pathname: string): Promise<Response | undefined>;
     start(): Promise<void>;
     stop(): void;
     upgrade(request: Request, actions: Actions): null;
     route(request: RequestFacade): Promise<{
         errors: RouteHandler[];
-        guards: RouteHandler[];
-        handler: RouteHandler;
+        hooks: import("../module/RequestHook.js").default[];
         layouts: RouteHandler[];
-        request: {
-            body: RequestBody;
-            path: RequestBag;
-            context: Dict;
-            cookies: RequestBag;
-            forward(to: string, headers?: Dict<string>): Promise<Response>;
-            headers: RequestBag;
-            original: Request;
-            query: RequestBag;
-            target: string;
-            url: URL;
-        };
+        handler: RouteHandler;
+        request: any;
     } | undefined>;
 }
 export {};