primate 0.27.6 → 0.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.27.6",
+  "version": "0.29.0",
   "description": "Polymorphic development platform",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -9,7 +9,8 @@
     "src/**/*.js",
     "src/errors.json",
     "src/defaults/*.html",
-    "!src/**/*.spec.js"
+    "!src/**/*.spec.js",
+    "types/*.ts"
   ],
   "bin": "src/bin.js",
   "repository": {
@@ -18,11 +19,12 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "rcompat": "^0.5.1"
+    "rcompat": "^0.7.2"
   },
   "engines": {
     "node": ">=18"
   },
   "type": "module",
+  "types": "./types/index.d.ts",
   "exports": "./src/exports.js"
 }

package/src/app.js

@@ -1,22 +1,23 @@
 import crypto from "rcompat/crypto";
 import { tryreturn } from "rcompat/async";
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { is } from "rcompat/invariant";
 import { transform, valmap, to } from "rcompat/object";
 import { globify } from "rcompat/string";
 import * as runtime from "rcompat/meta";
+import { Response, Status, MediaType } from "rcompat/http";
 
 import errors from "./errors.js";
 import to_sorted from "./to_sorted.js";
-import * as handlers from "./handlers/exports.js";
+import * as handlers from "./handlers.js";
 import * as loaders from "./loaders/exports.js";
 
 const { DoubleFileExtension } = errors;
 
 // use user-provided file or fall back to default
-const index = (base, page, fallback) =>
-  tryreturn(_ => Path.read(`${base.join(page)}`))
-    .orelse(_ => Path.read(`${base.join(fallback)}`));
+const get_index = (base, page, fallback) =>
+  tryreturn(_ => File.text(`${base.join(page)}`))
+    .orelse(_ => File.text(`${base.join(fallback)}`));
 
 const encoder = new TextEncoder();
 
@@ -51,7 +52,7 @@ const render_head = (assets, head) =>
         : tags.script({ inline, code, type, integrity, src }),
     ).join("\n").concat("\n", head ?? "");
 
-const { name, version } = await new Path(import.meta.url).up(2)
+const { name, version } = await new File(import.meta.url).up(2)
   .join(runtime.manifest).json();
 
 export default async (log, root, config) => {
@@ -100,7 +101,7 @@ export default async (log, root, config) => {
 
       await Promise.all((await source.collect(filter)).map(async path => {
         const debased = path.debase(this.root).path.slice(1);
-        const filename = new Path(directory).join(path.debase(source));
+        const filename = File.join(directory, path.debase(source));
         const target = await target_base.join(filename.debase(directory));
         await target.directory.create();
         await (regexs.some(regex => regex.test(debased))
@@ -112,7 +113,7 @@ export default async (log, root, config) => {
       const { location: { server, client, components } } = this.config;
 
       const source = this.path.components;
-      const compile = this.extensions[component.extension]?.compile;
+      const compile = this.extensions[component.fullExtension]?.compile;
       if (compile === undefined) {
         const debased = `${component.path}`.replace(source, "");
 
@@ -134,15 +135,13 @@ export default async (log, root, config) => {
     headers({ script = "", style = "" } = {}) {
       const csp = Object.keys(http.csp).reduce((policy, key) =>
         `${policy}${key} ${http.csp[key]};`, "")
-        .replace("script-src 'self'", `script-src 'self' ${script} ${
-          this.assets
-            .filter(({ type }) => type !== "style")
-            .map(asset => `'${asset.integrity}'`).join(" ")
+        .replace("script-src 'self'", `script-src 'self' ${script} ${this.assets
+          .filter(({ type }) => type !== "style")
+          .map(asset => `'${asset.integrity}'`).join(" ")
         }`)
-        .replace("style-src 'self'", `style-src 'self' ${style} ${
-          this.assets
-            .filter(({ type }) => type === "style")
-            .map(asset => `'${asset.integrity}'`).join(" ")
+        .replace("style-src 'self'", `style-src 'self' ${style} ${this.assets
+          .filter(({ type }) => type === "style")
+          .map(asset => `'${asset.integrity}'`).join(" ")
         }`);
 
       return { "Content-Security-Policy": csp, "Referrer-Policy": "same-origin" };
@@ -150,18 +149,33 @@ export default async (log, root, config) => {
     runpath(...directories) {
       return this.path.build.join(...directories);
     },
-    async render({ body, head }, page = config.pages.index, placeholders = {}) {
+    async render(content) {
+      const { assets, config: { location, pages: { index } } } = this;
+      const { body, head, partial, placeholders = {}, page = index } = content;
       ["body", "head"].every(used => is(placeholders[used]).undefined());
-      const { assets, config: { location, pages } } = this;
 
-      return to(placeholders)
+      return partial ? body : to(placeholders)
         // replace given placeholders, defaulting to ""
         .reduce((html, [key, value]) => html.replace(`%${key}%`, value ?? ""),
-          await index(this.runpath(location.pages), page, pages.index))
+          await get_index(this.runpath(location.pages), page, index))
         // replace non-given placeholders, aside from %body% / %head%
         .replaceAll(/(?<keep>%(?:head|body)%)|%.*?%/gus, "$1")
         // replace body and head
-        .replace("%body%", body).replace("%head%", render_head(assets, head));
+        .replace("%body%", body)
+        .replace("%head%", render_head(assets, head));
+    },
+    respond(body, { status = Status.OK, headers = {} } = {}) {
+      return new Response(body, { status, headers: {
+        ...this.headers(), "Content-Type": MediaType.TEXT_HTML, ...headers },
+      });
+    },
+    async view(options) {
+      // split render and respond options
+      const { status, headers, ...rest } = options;
+      return this.respond(await this.render(rest), { status, headers });
+    },
+    media(type, { status, headers } = {}) {
+      return { status, headers: { ...headers, "Content-Type": type } };
     },
     async inline(code, type) {
       const integrity = await this.hash(code);
@@ -177,7 +191,7 @@ export default async (log, root, config) => {
       }
       if (inline || type === "style") {
         this.assets.push({
-          src: new Path(http.static.root).join(src ?? "").path,
+          src: File.join(http.static.root, src ?? "").path,
           code: inline ? code : "",
           type,
           inline,
@@ -203,7 +217,7 @@ export default async (log, root, config) => {
 
       const parts = module.split("/");
       const path = [this.library, ...parts];
-      const pkg = await Path.resolve().join(...path, this.manifest).json();
+      const pkg = await File.resolve().join(...path, this.manifest).json();
       const exports = pkg.exports === undefined
         ? { [module]: `/${module}/${pkg.main}` }
         : transform(pkg.exports, entry => entry
@@ -220,11 +234,11 @@ export default async (log, root, config) => {
               ?? value.default?.replace(".", `./${module}`)
               ?? value.import?.replace(".", `./${module}`),
           ]));
-      const dependency = Path.resolve().join(...path);
-      const target = new Path(this.runpath(client), this.library, ...parts);
+      const dependency = File.resolve().join(...path);
+      const target = File.join(this.runpath(client), this.library, ...parts);
       await dependency.copy(target);
       this.importmaps = {
-        ...valmap(exports, value => new Path(root, this.library, value).path),
+        ...valmap(exports, value => File.join(root, this.library, value).path),
         ...this.importmaps };
     },
   };

package/src/cwd.js

@@ -1,3 +1,3 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 
-export default (meta, up = 1) => new Path(meta.url).up(up);
+export default (meta, up = 1) => new File(meta.url).up(up);

package/src/errors.js

@@ -1,7 +1,7 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import Logger from "./Logger.js";
 
-const json = await new Path(import.meta.url).up(1).join("errors.json").json();
+const json = await new File(import.meta.url).up(1).join("errors.json").json();
 
 const errors = Logger.err(json.errors, json.module);
 

package/src/exports.js

@@ -1,6 +1,6 @@
 import run from "./run.js";
 
-export * from "./handlers/exports.js";
+export * from "./handlers.js";
 
 export { default as Logger } from "./Logger.js";
 

package/src/handlers.js

@@ -0,0 +1,77 @@
+import { File } from "rcompat/fs";
+import { MediaType, Status } from "rcompat/http";
+import { identity } from "rcompat/function";
+import errors from "./errors.js";
+
+const handle = (mediatype, mapper = identity) => (body, options) => app =>
+  app.respond(mapper(body), app.media(mediatype, options));
+
+// {{{ text
+const text = handle(MediaType.TEXT_PLAIN);
+// }}}
+// {{{ json
+const json = handle(MediaType.APPLICATION_JSON, JSON.stringify);
+// }}}
+// {{{ stream
+const stream = handle(MediaType.APPLICATION_OCTET_STREAM);
+// }}}
+// {{{ ws
+const ws = implementation => ({ server }, _, { original }) =>
+  server.upgrade(original, implementation);
+// }}}
+// {{{ sse
+const sse = handle(MediaType.TEXT_EVENT_STREAM, implementation =>
+  new ReadableStream({
+    start(controller) {
+      implementation.open({
+        send(name, data) {
+          const event = data === undefined ? "" : `event: ${name}\n`;
+          const $data = data === undefined ? name : data;
+          controller.enqueue(`${event}data:${JSON.stringify($data)}\n\n`);
+        },
+      });
+    },
+    cancel() {
+      implementation.close?.();
+    },
+  }));
+// }}}
+// {{{ redirect
+const redirect = (Location, { status = Status.FOUND } = {}) => app =>
+  /* no body */
+  app.respond(null, { status, headers: { Location } });
+// }}}
+// {{{ error
+const error = (body = "Not Found", { status = Status.NOT_FOUND, page } = {}) =>
+  app => app.view({ body, status, page: page ?? app.config.pages.error });
+// }}}
+// {{{ html
+const script_re = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
+const style_re = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
+const remove = /<(?<tag>script|style)>.*?<\/\k<tag>>/gus;
+const html = (name, options) => async app => {
+  const component = await app.path.components.join(name).text();
+  const scripts = await Promise.all([...component.matchAll(script_re)]
+    .map(({ groups: { code } }) => app.inline(code, "module")));
+  const styles = await Promise.all([...component.matchAll(style_re)]
+    .map(({ groups: { code } }) => app.inline(code, "style")));
+  const assets = [...scripts, ...styles];
+
+  const body = component.replaceAll(remove, _ => "");
+  const head = assets.map(asset => asset.head).join("\n");
+  const script = scripts.map(asset => asset.csp).join(" ");
+  const style = styles.map(asset => asset.csp).join(" ");
+  const headers = app.headers({ script, style });
+
+  return app.view({ body, head, headers, ...options });
+};
+// }}}
+// {{{ view
+const view = (name, props, options) => async (app, ...rest) => {
+  const { fullExtension: extension } = new File(name);
+  return app.extensions[extension]?.handle(name, props, options)(app, ...rest)
+    ?? errors.NoHandlerForExtension.throw(extension, name);
+};
+// }}}
+
+export { text, json, stream, redirect, error, html, view, ws, sse };

package/src/hooks/copy_includes.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 
 export default async (app, type, post = () => undefined) => {
   const { config } = app;
@@ -14,7 +14,7 @@ export default async (app, type, post = () => undefined) => {
       .map(async include => {
         const path = app.root.join(include);
         if (await path.exists()) {
-          const target = Path.join(type, include);
+          const target = File.join(type, include);
           await app.stage(path, target);
           await post(target);
         }

package/src/hooks/exports.js

@@ -6,4 +6,3 @@ export { default as bundle } from "./bundle.js";
 export { default as route } from "./route.js";
 export { default as handle } from "./handle.js";
 export { default as parse } from "./parse.js";
-export { default as serve } from "./serve.js";

package/src/hooks/handle.js

@@ -1,7 +1,7 @@
 import { Response, Status, MediaType } from "rcompat/http";
 import { cascade, tryreturn } from "rcompat/async";
 import { respond } from "./respond/exports.js";
-import { error as clientError } from "../handlers/exports.js";
+import { error as clientError } from "../handlers.js";
 
 const guard_error = Symbol("guard_error");
 const guard = (app, guards) => async (request, next) => {
@@ -44,6 +44,7 @@ export default app => {
 
     return tryreturn(async _ => {
       const { path, guards, errors, layouts, handler } = await route(request);
+
       error_handler = errors?.at(-1);
 
       const pathed = { ...request, path };
@@ -52,6 +53,7 @@ export default app => {
 
       // handle request
       const response = await (await cascade(hooks, handler))(pathed);
+
       const $layouts = { layouts: await get_layouts(layouts, request) };
       return (await respond(response))(app, $layouts, pathed);
     }).orelse(async error => {

package/src/hooks/parse.js

@@ -5,15 +5,15 @@ import errors from "../errors.js";
 
 const deslash = url => url.replaceAll(/(?<!http:)\/{2,}/gu, _ => "/");
 
-const parse_body = (body, headers, url) =>
-  tryreturn(async _ => Body.parse(body, headers.get("content-type")) ?? {})
+const parse_body = (request, url) =>
+  tryreturn(async _ => await Body.parse(request) ?? {})
     .orelse(error => errors.MismatchedBody.throw(url.pathname, error.message));
 
 export default dispatch => async original => {
   const { headers } = original;
   const url = new URL(deslash(globalThis.decodeURIComponent(original.url)));
   const cookies = headers.get("cookie");
-  const body = await parse_body(original.body, headers, url);
+  const body = await parse_body(original, url);
 
   return { original, url, body, ...valmap({
     query: [from(url.searchParams), url.search],

package/src/hooks/publish.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { cascade } from "rcompat/async";
 import { stringify } from "rcompat/object";
 
@@ -7,7 +7,7 @@ const post = async app => {
 
   {
     // after hook, publish a zero assumptions app.js (no css imports)
-    const src = new Path(root, app.config.build.index);
+    const src = File.join(root, app.config.build.index);
 
     await app.publish({
       code: app.exports.filter(({ type }) => type === "script")

package/src/hooks/register.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { cascade } from "rcompat/async";
 import cwd from "../cwd.js";
 import copy_includes from "./copy_includes.js";
@@ -17,7 +17,7 @@ const pre = async app => {
   if (await path.components.exists()) {
     // copy .js files from components to build/client/components, since
     // frontend frameworks handle non-js files
-    const target = Path.join(client, components);
+    const target = File.join(client, components);
     await app.stage(path.components, target, /^.*.js$/u);
   }
 
@@ -29,13 +29,13 @@ const post = async app => {
 
   if (await path.static.exists()) {
     // copy static files to build/server/static
-    await app.stage(path.static, new Path(location.server, location.static));
+    await app.stage(path.static, File.join(location.server, location.static));
 
     // copy static files to build/client/static
-    await app.stage(path.static, new Path(location.client, location.static));
+    await app.stage(path.static, File.join(location.client, location.static));
 
     // publish JavaScript and CSS files
-    const imports = await Path.collect(path.static, /\.(?:js|css)$/u);
+    const imports = await File.collect(path.static, /\.(?:js|css)$/u);
     await Promise.all(imports.map(async file => {
       const code = await file.text();
       const src = file.debase(path.static);
@@ -54,7 +54,7 @@ const post = async app => {
   const client = app.runpath(location.client);
   await copy_includes(app, location.client, async to =>
     Promise.all((await to.collect(/\.js$/u)).map(async script => {
-      const src = new Path(root, script.path.replace(client, _ => ""));
+      const src = File.join(root, script.path.replace(client, _ => ""));
       await app.publish({ src, code: await script.text(), type: "module" });
     })),
   );

package/src/hooks/respond/respond.js

@@ -15,10 +15,10 @@ const is_object = value => is_non_null_object(value)
   ? json(value) : is_text(value);
 const is_response = value => is_response_duck(value)
   ? _ => value : is_object(value);
-const isStream = value => value instanceof ReadableStream
+const is_stream = value => value instanceof ReadableStream
   ? stream(value) : is_response(value);
 const is_blob = value => value instanceof Blob
-  ? stream(value) : isStream(value);
+  ? stream(value.stream()) : is_stream(value);
 const is_URL = value => value instanceof URL
   ? redirect(value.href) : is_blob(value);
 const guess = value => is_URL(value);

package/src/hooks/route.js

@@ -21,8 +21,7 @@ export default app => {
       [name, type === undefined ? value : validate(types[type], value, name)],
     )));
 
-  const is_type = (groups, pathname) => Object
-    .entries(groups ?? {})
+  const is_type = (groups, pathname) => Object.entries(groups ?? {})
     .map(([name, value]) =>
       [types[name] === undefined || explicit ? name : `${name}$${name}`, value])
     .filter(([name]) => name.includes("$"))

package/src/loaders/common.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { identity } from "rcompat/function";
 import errors from "../errors.js";
 
@@ -17,13 +17,13 @@ export default async ({
   warn = true,
 } = {}) => {
   const objects = directory === undefined ? [] : await Promise.all(
-    (await Path.collect(directory, /^.*.js$/u, { recursive }))
+    (await File.collect(directory, /^.*.js$/u, { recursive }))
       .filter(filter)
       .map(async path => [
         `${path}`.replace(directory, _ => "").slice(1, -ending.length),
-        (await import(path)),
+        await import(path),
       ]));
-  warn && await Path.exists(directory) && empty(log)(objects, name, directory);
+  warn && await directory.exists() && empty(log)(objects, name, directory);
 
   return objects;
 };

package/src/loaders/routes/load.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import errors from "../../errors.js";
 import to_sorted from "../../to_sorted.js";
 
@@ -10,7 +10,7 @@ export default type => async (log, directory, load) => {
     .map(([name, object]) => [name.replace(replace, () => ""), object]),
   ([a], [b]) => a.length - b.length);
 
-  const resolve = name => new Path(directory, name, `+${type}.js`);
+  const resolve = name => File.join(directory, name, `+${type}.js`);
   objects.some(([name, value]) => typeof value.default !== "function"
     && errors.InvalidDefaultExport.throw(resolve(name)));
 

package/src/loaders/types.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { is } from "rcompat/invariant";
 import { tryreturn } from "rcompat/sync";
 import errors from "../errors.js";
@@ -10,7 +10,7 @@ export default async (log, directory, load = fs) => {
   const types = (await load({ log, directory, name: "types", filter }))
     .map(([name, type]) => [name, type.default]);
 
-  const resolve = name => new Path(directory, name);
+  const resolve = name => File.join(directory, name);
   types.every(([name, type]) => tryreturn(_ => {
     is(type).object();
     is(type.base).string();

package/src/run.js

@@ -1,6 +1,7 @@
 import { tryreturn } from "rcompat/async";
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { extend } from "rcompat/object";
+import { runtime } from "rcompat/meta";
 import app from "./app.js";
 import { default as Logger, bye } from "./Logger.js";
 import errors from "./errors.js";
@@ -8,7 +9,6 @@ import command from "./commands/exports.js";
 import defaults from "./defaults/primate.config.js";
 
 let logger = new Logger({ level: Logger.Warn });
-const { runtime = "node" } = import.meta;
 
 const get_config = async root => {
   const name = "primate.config.js";
@@ -28,7 +28,7 @@ const get_config = async root => {
 
 export default async name => tryreturn(async _ => {
   // use module root if possible, fall back to current directory
-  const root = await tryreturn(_ => Path.root()).orelse(_ => Path.resolve());
+  const root = await tryreturn(_ => File.root()).orelse(_ => File.resolve());
   const config = await get_config(root);
   logger = new Logger(config.logger);
   await command(name)(await app(logger, root, config));

package/src/start.js

@@ -1,5 +1,5 @@
 import { serve, Response, Status } from "rcompat/http";
-import { cascade, tryreturn } from "rcompat/async";
+import { tryreturn } from "rcompat/async";
 import { bold, blue } from "rcompat/colors";
 import * as hooks from "./hooks/exports.js";
 import { print } from "./Logger.js";
@@ -24,14 +24,11 @@ export default async (app$, mode = "development") => {
 
   app.route = hooks.route(app);
   app.parse = hooks.parse(app.dispatch);
-
-  const server = await serve(async request =>
+  app.server = await serve(async request =>
     tryreturn(async _ => (await hooks.handle(app))(await app.parse(request)))
       .orelse(error => {
         app.log.auto(error);
         return new Response(null, { status: Status.INTERNAL_SERVER_ERROR });
       }),
   app.config.http);
-
-  await (await cascade(app.modules.serve))({ ...app, server });
 };

package/types/index.d.ts

@@ -0,0 +1,69 @@
+declare module "primate" {
+  type App = any;
+
+  interface MinOptions {
+    status: number,
+    headers: Headers | {},
+  }
+  
+  interface ErrorOptions extends MinOptions {
+    page: string,
+  }
+
+  interface Options extends ErrorOptions {
+    placeholders: {},
+  }
+
+  type Dispatcher = {
+    get(property: string): string,
+  };
+
+  type RequestFacade = {
+    body: {}
+    path: Dispatcher,
+    query: Dispatcher,
+    cookies: Dispatcher,
+    headers: Dispatcher,
+    original: Request,
+  };
+
+  type ResponseFn = (app: App, ...rest: any) => Response;
+  type ResponseFacade = 
+    string 
+  | object
+  | URL
+  | Blob
+  | ReadableStream
+  | Response
+  | ResponseFn;
+
+  type RouteFunction = (request?: RequestFacade) => ResponseFacade;
+
+  type Streamable = ReadableStream | Blob;
+
+  export type Route = {
+    get?: RouteFunction,
+    post?: RouteFunction,
+    put?: RouteFunction,
+    delete?: RouteFunction,
+  };
+
+  export function text(body: string, options?: MinOptions): ResponseFn;
+
+  export function json(body: {}, options?: MinOptions): ResponseFn;
+
+  export function stream(body: Streamable, options?: MinOptions): ResponseFn;
+
+  export function redirect(location: string, options?: MinOptions): ResponseFn;
+
+  export function html(name: string, options?: MinOptions): ResponseFn;
+
+  export function view(name: string, props: {}, options?: Options): ResponseFn;
+
+  export function error(body: string, options?: ErrorOptions): ResponseFn;
+
+  export function sse(implementation: {
+    open?: () => void,
+    close?: () => void,
+  }, options?: MinOptions): ResponseFn;
+}

package/src/handlers/error.js

@@ -1,8 +0,0 @@
-import { Response, Status, MediaType } from "rcompat/http";
-
-export default (body = "Not Found", { status = Status.NOT_FOUND, page } = {}) =>
-  async app =>
-    new Response(await app.render({ body }, page ?? app.config.pages.error), {
-      status,
-      headers: { ...app.headers(), "Content-Type": MediaType.TEXT_HTML },
-    });

package/src/handlers/exports.js

@@ -1,7 +0,0 @@
-export { default as text } from "./text.js";
-export { default as json } from "./json.js";
-export { default as stream } from "./stream.js";
-export { default as redirect } from "./redirect.js";
-export { default as html } from "./html.js";
-export { default as view } from "./view.js";
-export { default as error } from "./error.js";

package/src/handlers/html.js

@@ -1,28 +0,0 @@
-import { Response, Status, MediaType } from "rcompat/http";
-
-const script_re = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
-const style_re = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
-const remove = /<(?<tag>script|style)>.*?<\/\k<tag>>/gus;
-
-const render = (body, head, { partial = false, app, page, placeholders }) =>
-  partial ? body : app.render({ body, head }, page, placeholders);
-
-export default (name, options = {}) => async app => {
-  const component = await app.path.components.join(name).text();
-  const scripts = await Promise.all([...component.matchAll(script_re)]
-    .map(({ groups: { code } }) => app.inline(code, "module")));
-  const styles = await Promise.all([...component.matchAll(style_re)]
-    .map(({ groups: { code } }) => app.inline(code, "style")));
-  const assets = [...scripts, ...styles];
-
-  const body = component.replaceAll(remove, _ => "");
-  const head = assets.map(asset => asset.head).join("\n");
-  const script = scripts.map(asset => asset.csp).join(" ");
-  const style = styles.map(asset => asset.csp).join(" ");
-  const headers = { script, style };
-
-  return new Response(await render(body, head, { app, ...options }), {
-      status: options.status ?? Status.OK,
-      headers: { ...app.headers(headers), "Content-Type": MediaType.TEXT_HTML },
-    });
-};

package/src/handlers/json.js

@@ -1,7 +0,0 @@
-import { Response, Status, MediaType } from "rcompat/http";
-
-export default (body, { status = Status.OK } = {}) => app =>
-  new Response(JSON.stringify(body), {
-    status,
-    headers: { ...app.headers(), "Content-Type": MediaType.APPLICATION_JSON },
-  });

package/src/handlers/redirect.js

@@ -1,8 +0,0 @@
-import { Response, Status } from "rcompat/http";
-
-export default (Location, { status = Status.FOUND } = {}) => app =>
-  /* no body */
-  new Response(null, {
-    status,
-    headers: { ...app.headers(), Location },
-  });

package/src/handlers/stream.js

@@ -1,8 +0,0 @@
-import { Response, Status, MediaType } from "rcompat/http";
-
-export default (body, { status = Status.OK } = {}) => app =>
-  new Response(body, {
-    status,
-    headers: { ...app.headers(), "Content-Type":
-      MediaType.APPLICATION_OCTET_STREAM },
-  });

package/src/handlers/text.js

@@ -1,7 +0,0 @@
-import { Response, Status, MediaType } from "rcompat/http";
-
-export default (body, { status = Status.OK } = {}) => app =>
-  new Response(body, {
-    status,
-    headers: { ...app.headers(), "Content-Type": MediaType.TEXT_PLAIN },
-  });

package/src/handlers/view.js

@@ -1,7 +0,0 @@
-import errors from "../errors.js";
-
-export default (name, props, options) => async (app, ...rest) => {
-  const extension = name.slice(name.lastIndexOf("."));
-  return app.extensions[extension]?.handle(name, props, options)(app, ...rest)
-    ?? errors.NoHandlerForExtension.throw(extension, name);
-};

package/src/hooks/serve.js

@@ -1,6 +0,0 @@
-import { cascade } from "rcompat/async";
-
-export default async (app, server) => {
-  app.log.info("running serve hooks", { module: "primate" });
-  await (await cascade(app.modules.serve))({ ...app, server });
-};