primate 0.24.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "Expressive, minimal and extensible web framework",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -18,7 +18,7 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "runtime-compat": "^0.29.0"
+    "rcompat": "^0.3.3"
   },
   "engines": {
     "node": ">=18"

package/src/Logger.js

@@ -1,7 +1,8 @@
-import {assert, is} from "runtime-compat/invariant";
-import {blue, bold, green, red, yellow, dim} from "runtime-compat/colors";
-import {map} from "runtime-compat/object";
-import console from "runtime-compat/console";
+import { assert, is } from "rcompat/invariant";
+import { blue, bold, green, red, yellow, dim } from "rcompat/colors";
+import { map } from "rcompat/object";
+import console from "rcompat/console";
+import { stdout } from "rcompat/stdio";
 
 const levels = {
   Error: 0,
@@ -9,20 +10,23 @@ const levels = {
   Info: 2,
 };
 
-const print = (...messages) => process.stdout.write(messages.join(" "));
+const print = (...messages) => stdout.write(messages.join(" "));
 const bye = _ => print(dim(yellow("~~ bye\n")));
 const mark = (format, ...params) => params.reduce((formatted, param, i) =>
   formatted.replace(`{${i}}`, bold(param)), format);
 
-const reference = "https://primatejs.com/reference/errors";
+const reference = (module, error) => {
+  const base = module ? `modules/${module}` : "guide/logging";
+  return `https://primatejs.com/${base}#${hyphenate(error)}`;
+};
 
-const hyphenate = classCased => classCased
+const hyphenate = class_cased => class_cased
   .split("")
   .map(letter => letter.replace(/[A-Z]/u, upper => `-${upper.toLowerCase()}`))
   .join("")
   .slice(1);
 
-const throwable = ({message, level, fix}, name, module) => ({
+const throwable = ({ message, level, fix }, name, module) => ({
   new(...args) {
     const error = new Error(mark(message, ...args));
     error.level = Logger[level];
@@ -35,9 +39,9 @@ const throwable = ({message, level, fix}, name, module) => ({
     throw this.new(...args);
   },
   warn(logger, ...args) {
-    const error = {level: Logger[level], message: mark(message, ...args),
-      fix: mark(fix, ...args)};
-    logger.auto({...error, name, module});
+    const error = { level: Logger[level], message: mark(message, ...args),
+      fix: mark(fix, ...args) };
+    logger.auto({ ...error, name, module });
   },
 });
 
@@ -48,7 +52,7 @@ const Logger = class Logger {
     return map(errors, ([key, value]) => [key, throwable(value, key, module)]);
   }
 
-  constructor({level = levels.Error, trace = false} = {}) {
+  constructor({ level = levels.Error, trace = false } = {}) {
     assert(level !== undefined && level <= levels.Info);
     is(trace).boolean();
     this.#level = level;
@@ -68,11 +72,11 @@ const Logger = class Logger {
   }
 
   #print(pre, color, message, error = {}) {
-    const {fix, module, name, level} = error;
+    const { fix, module, name, level } = error;
     print(color(pre), `${module !== undefined ? `${color(module)} ` : ""}${message}`, "\n");
     if (fix) {
       print(blue("++"), fix);
-      name && print(dim(`\n   -> ${reference}/${module ?? "primate"}#${hyphenate(name)}`), "\n");
+      name && print(dim(`\n   -> ${reference(module, name)}`), "\n");
     }
     if (level === levels.Error || level === undefined && error.message) {
       this.#trace && console.log(error);
@@ -96,7 +100,7 @@ const Logger = class Logger {
   }
 
   auto(error) {
-    const {message} = error;
+    const { message } = error;
     const matches = map(levels, ([name, level]) => [level, name.toLowerCase()]);
     return this[matches[error.level] ?? "error"](message, error);
   }
@@ -104,4 +108,4 @@ const Logger = class Logger {
 
 export default Logger;
 
-export {print, bye, mark};
+export { print, bye, mark };

package/src/app.js

@@ -1,25 +1,22 @@
-import crypto from "runtime-compat/crypto";
-import {tryreturn} from "runtime-compat/async";
-import {File, Path} from "runtime-compat/fs";
-import {bold, blue} from "runtime-compat/colors";
-import {is} from "runtime-compat/invariant";
-import {transform, valmap} from "runtime-compat/object";
-import {globify} from "runtime-compat/string";
-import * as runtime from "runtime-compat/meta";
+import crypto from "rcompat/crypto";
+import { tryreturn } from "rcompat/async";
+import { Path } from "rcompat/fs";
+import { is } from "rcompat/invariant";
+import { transform, valmap } from "rcompat/object";
+import { globify } from "rcompat/string";
+import * as runtime from "rcompat/meta";
 
 import errors from "./errors.js";
-import {print} from "./Logger.js";
-import dispatch from "./dispatch.js";
 import to_sorted from "./to_sorted.js";
 import * as handlers from "./handlers/exports.js";
 import * as loaders from "./loaders/exports.js";
 
-const {DoubleFileExtension} = errors;
+const { DoubleFileExtension } = errors;
 
 // use user-provided file or fall back to default
 const index = (base, page, fallback) =>
-  tryreturn(_ => File.read(`${base.join(page)}`))
-    .orelse(_ => File.read(`${base.join(fallback)}`));
+  tryreturn(_ => Path.read(`${base.join(page)}`))
+    .orelse(_ => Path.read(`${base.join(fallback)}`));
 
 const encoder = new TextEncoder();
 
@@ -27,45 +24,40 @@ const attribute = attributes => Object.keys(attributes).length > 0
   ? " ".concat(Object.entries(attributes)
     .map(([key, value]) => `${key}="${value}"`).join(" "))
   : "";
-const tag = ({name, attributes = {}, code = "", close = true}) =>
+const tag = ({ name, attributes = {}, code = "", close = true }) =>
   `<${name}${attribute(attributes)}${close ? `>${code}</${name}>` : "/>"}`;
 const tags = {
   // inline: <script type integrity>...</script>
   // outline: <script type integrity src></script>
-  script({inline, code, type, integrity, src}) {
+  script({ inline, code, type, integrity, src }) {
     return inline
-      ? tag({name: "script", attributes: {type, integrity}, code})
-      : tag({name: "script", attributes: {type, integrity, src}});
+      ? tag({ name: "script", attributes: { type, integrity }, code })
+      : tag({ name: "script", attributes: { type, integrity, src } });
   },
   // inline: <style>...</style>
   // outline: <link rel="stylesheet" href/>
-  style({inline, code, href, rel = "stylesheet"}) {
+  style({ inline, code, href, rel = "stylesheet" }) {
     return inline
-      ? tag({name: "style", code})
-      : tag({name: "link", attributes: {rel, href}, close: false});
+      ? tag({ name: "style", code })
+      : tag({ name: "link", attributes: { rel, href }, close: false });
   },
 };
 
-const {name, version} = await new Path(import.meta.url).up(2)
+const { name, version } = await new Path(import.meta.url).up(2)
   .join(runtime.manifest).json();
 
 export default async (log, root, config) => {
-  const {http} = config;
+  const { http } = config;
   const secure = http?.ssl !== undefined;
   const path = valmap(config.location, value => root.join(value));
 
-  const at = `at http${secure ? "s" : ""}://${http.host}:${http.port}\n`;
-  print(blue(bold(name)), blue(version), at);
-
   // if ssl activated, resolve key and cert early
   if (secure) {
     http.ssl.key = root.join(http.ssl.key);
     http.ssl.cert = root.join(http.ssl.cert);
   }
 
-  const types = await loaders.types(log, path.types);
   const error = await path.routes.join("+error.js");
-  const routes = await loaders.routes(log, path.routes);
 
   return {
     config,
@@ -79,83 +71,96 @@ export default async (log, root, config) => {
     root,
     log,
     error: {
-      default: await error.exists ? (await import(error)).default : undefined,
-    },
-    handlers: {...handlers},
-    types,
-    routes,
-    layout: {
-      depth: Math.max(...routes.map(({layouts}) => layouts.length)) + 1,
+      default: await error.exists() ? (await import(error)).default : undefined,
     },
-    dispatch: dispatch(types),
+    handlers: { ...handlers },
+    extensions: {},
     modules: await loaders.modules(log, root, config),
     ...runtime,
     // copy files to build folder, potentially transforming them
     async stage(source, directory, filter) {
-      const {paths, mapper} = this.config.build.transform;
+      const { paths, mapper } = this.config.build.transform;
       is(paths).array();
       is(mapper).function();
 
       const regexs = paths.map(file => globify(file));
-      const target = this.runpath(directory);
+      const target_base = this.runpath(directory);
 
       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 to = await target.join(filename.debase(directory));
-        await to.directory.file.create();
-        if (regexs.some(regex => regex.test(debased))) {
-          const contents = mapper(await path.text());
-          await to.file.write(contents);
-        } else {
-          await path.file.copy(to);
-        }
+        const target = await target_base.join(filename.debase(directory));
+        await target.directory.create();
+        await (regexs.some(regex => regex.test(debased))
+          ? target.write(mapper(await path.text()))
+          : path.copy(target));
       }));
     },
-    headers({script = "", style = ""} = {}) {
+    async compile(component) {
+      const { location: { server, client, components } } = this.config;
+
+      const source = this.path.components;
+      const compile = this.extensions[component.extension]?.compile;
+      if (compile === undefined) {
+        const debased = `${component.path}`.replace(source, "");
+
+        const server_target = this.runpath(server, components);
+        await component.copy(server_target.join(debased));
+
+        const client_target = this.runpath(client, components);
+        await component.copy(client_target.join(debased));
+      } else {
+        // compile server components
+        await compile.server(component);
+
+        // compile client components
+        await compile.client(component);
+      }
+    },
+    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")
+            .filter(({ type }) => type !== "style")
             .map(asset => `'${asset.integrity}'`).join(" ")
         }`)
         .replace("style-src 'self'", `style-src 'self' ${style} ${
           this.assets
-            .filter(({type}) => type === "style")
+            .filter(({ type }) => type === "style")
             .map(asset => `'${asset.integrity}'`).join(" ")
         }`);
 
-      return {"Content-Security-Policy": csp, "Referrer-Policy": "same-origin"};
+      return { "Content-Security-Policy": csp, "Referrer-Policy": "same-origin" };
     },
     runpath(...directories) {
       return this.path.build.join(...directories);
     },
-    async render({body = "", head = "", page = config.pages.index} = {}) {
-      const {location: {pages}} = this.config;
+    async render({ body = "", head = "", page = config.pages.index } = {}) {
+      const { location: { pages } } = this.config;
 
       const html = await index(this.runpath(pages), page, config.pages.index);
 
       const heads = to_sorted(this.assets,
-        ({type}) => -1 * (type === "importmap"))
-        .map(({src, code, type, inline, integrity}) =>
+        ({ type }) => -1 * (type === "importmap"))
+        .map(({ src, code, type, inline, integrity }) =>
           type === "style"
-            ? tags.style({inline, code, href: src})
-            : tags.script({inline, code, type, integrity, src})
+            ? tags.style({ inline, code, href: src })
+            : tags.script({ inline, code, type, integrity, src }),
         ).join("\n").concat("\n", head);
       return html.replace("%body%", _ => body).replace("%head%", _ => heads);
     },
     async inline(code, type) {
       const integrity = await this.hash(code);
       const tag_name = type === "style" ? "style" : "script";
-      const head = tags[tag_name]({code, type, inline: true, integrity});
-      return {head, csp: `'${integrity}'`};
+      const head = tags[tag_name]({ code, type, inline: true, integrity });
+      return { head, csp: `'${integrity}'` };
     },
-    async publish({src, code, type = "", inline = false, copy = true}) {
+    async publish({ src, code, type = "", inline = false, copy = true }) {
       if (!inline && copy) {
         const base = this.runpath(this.config.location.client).join(src);
-        await base.directory.file.create();
-        await base.file.write(code);
+        await base.directory.create();
+        await base.write(code);
       }
       if (inline || type === "style") {
         this.assets.push({
@@ -167,12 +172,13 @@ export default async (log, root, config) => {
         });
       }
     },
-    export({type, code}) {
-      this.exports.push({type, code});
+    export({ type, code }) {
+      this.exports.push({ type, code });
     },
-    register(extension, handler) {
+    register(extension, operations) {
       is(this.handlers[extension]).undefined(DoubleFileExtension.new(extension));
-      this.handlers[extension] = handler;
+      this.handlers[extension] = operations.handle;
+      this.extensions[extension] = operations;
     },
     async hash(data, algorithm = "sha-384") {
       const bytes = await crypto.subtle.digest(algorithm, encoder.encode(data));
@@ -180,13 +186,13 @@ export default async (log, root, config) => {
       return `${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
     },
     async import(module, deep_import) {
-      const {http: {static: {root}}, location: {client}} = this.config;
+      const { http: { static: { root } }, location: { client } } = this.config;
 
       const parts = module.split("/");
       const path = [this.library, ...parts];
       const pkg = await Path.resolve().join(...path, this.manifest).json();
       const exports = pkg.exports === undefined
-        ? {[module]: `/${module}/${pkg.main}`}
+        ? { [module]: `/${module}/${pkg.main}` }
         : transform(pkg.exports, entry => entry
           .filter(([, export$]) =>
             export$.browser?.[deep_import] !== undefined
@@ -202,11 +208,11 @@ export default async (log, root, config) => {
               ?? value.import?.replace(".", `./${module}`),
           ]));
       const dependency = Path.resolve().join(...path);
-      const to = new Path(this.runpath(client), this.library, ...parts);
-      await dependency.file.copy(to);
+      const target = new Path(this.runpath(client), this.library, ...parts);
+      await dependency.copy(target);
       this.importmaps = {
         ...valmap(exports, value => new Path(root, this.library, value).path),
-        ...this.importmaps};
+        ...this.importmaps };
     },
   };
 };

package/src/bin.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import args from "runtime-compat/args";
+import args from "rcompat/args";
 import run from "./run.js";
 await run(args[0]);

package/src/commands/dev.js

@@ -1,3 +1,3 @@
 import start from "../start.js";
 
-export default app => start(app, ["bundle"]);
+export default app => start(app, "development");

package/src/commands/exports.js

@@ -1,4 +1,4 @@
-import {default as dev} from "./dev.js";
-import {default as serve} from "./serve.js";
+import { default as dev } from "./dev.js";
+import { default as serve } from "./serve.js";
 
-export default name => ({dev, serve})[name] ?? dev;
+export default name => ({ dev, serve })[name] ?? dev;

package/src/commands/serve.js

@@ -1,3 +1,3 @@
 import start from "../start.js";
 
-export default app => start(app);
+export default app => start(app, "production");

package/src/cwd.js

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

package/src/defaults/primate.config.js

@@ -1,4 +1,4 @@
-import {identity} from "runtime-compat/function";
+import { identity } from "rcompat/function";
 import Logger from "../Logger.js";
 
 export default {

package/src/dispatch.js

@@ -1,21 +1,24 @@
-import {is, maybe} from "runtime-compat/invariant";
-import {tryreturn} from "runtime-compat/sync";
-import {map} from "runtime-compat/object";
-import {camelcased} from "runtime-compat/string";
+import { is } from "rcompat/invariant";
+import { tryreturn } from "rcompat/sync";
+import { map } from "rcompat/object";
+import { camelcased } from "rcompat/string";
 import errors from "./errors.js";
 import validate from "./validate.js";
 
-export default (patches = {}) => (value, raw, cased = true) => {
+export default (patches = {}) => (object, raw, cased = true) => {
   return Object.assign(Object.create(null), {
     ...map(patches, ([name, patch]) => [`get${camelcased(name)}`, property => {
       is(property).defined(`\`${name}\` called without property`);
-      return tryreturn(_ => validate(patch, value[property], property))
-        .orelse(({message}) => errors.MismatchedType.throw(message));
+      return tryreturn(_ => validate(patch, object[property], property))
+        .orelse(({ message }) => errors.MismatchedType.throw(message));
     }]),
     get(property) {
-      maybe(property).string();
-      return property === undefined ? value :
-        value[cased ? property : property.toLowerCase()];
+      is(property).string();
+
+      return object[cased ? property : property.toLowerCase()];
+    },
+    getAll() {
+      return object;
     },
     raw,
   });

package/src/errors.js

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

package/src/errors.json

@@ -56,6 +56,11 @@
       "fix": "do not use dots in route names",
       "level": "Error"
     },
+    "InvalidTypeExport": {
+      "message": "invalid type export at {0}",
+      "fix": "export object with a `base` string and a `validate` function",
+      "level": "Error"
+    },
     "InvalidTypeName": {
       "message": "invalid type name {0}",
       "fix": "use lowercase-first latin letters and decimals in type names",

package/src/exports.js

@@ -2,8 +2,8 @@ import run from "./run.js";
 
 export * from "./handlers/exports.js";
 
-export {default as Logger} from "./Logger.js";
+export { default as Logger } from "./Logger.js";
 
-export {URL, Response, Status, MediaType} from "runtime-compat/http";
+export { URL, Response, Status, MediaType } from "rcompat/http";
 
 export default command => run(command);

package/src/handlers/error.js

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

package/src/handlers/exports.js

@@ -1,7 +1,7 @@
-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";
+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,29 +1,29 @@
-import {Response, Status, MediaType} from "runtime-compat/http";
+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;
 
 export default (name, options = {}) => {
-  const {status = Status.OK, partial = false} = options;
+  const { status = Status.OK, partial = false } = options;
 
   return async app => {
     const html = await app.path.components.join(name).text();
     const scripts = await Promise.all([...html.matchAll(script_re)]
-      .map(({groups: {code}}) => app.inline(code, "module")));
+      .map(({ groups: { code } }) => app.inline(code, "module")));
     const styles = await Promise.all([...html.matchAll(style_re)]
-      .map(({groups: {code}}) => app.inline(code, "style")));
+      .map(({ groups: { code } }) => app.inline(code, "style")));
     const assets = [...scripts, ...styles];
 
     const body = html.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};
+    const headers = { script, style };
 
-    return new Response(partial ? body : await app.render({body, head}), {
+    return new Response(partial ? body : await app.render({ body, head }), {
       status,
-      headers: {...app.headers(headers), "Content-Type": MediaType.TEXT_HTML},
+      headers: { ...app.headers(headers), "Content-Type": MediaType.TEXT_HTML },
     });
   };
 };

package/src/handlers/json.js

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

package/src/handlers/redirect.js

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

package/src/handlers/stream.js

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

package/src/handlers/text.js

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

package/src/hooks/bundle.js

@@ -1,3 +1,3 @@
-import {cascade} from "runtime-compat/async";
+import { cascade } from "rcompat/async";
 
 export default async app => (await cascade(app.modules.bundle))(app);

package/src/hooks/copy_includes.js

@@ -1,9 +1,9 @@
-import {Path} from "runtime-compat/fs";
+import { Path } from "rcompat/fs";
 
 export default async (app, type, post = () => undefined) => {
-  const {config} = app;
-  const {build} = config;
-  const {includes} = build;
+  const { config } = app;
+  const { build } = config;
+  const { includes } = build;
 
   const reserved = Object.values(app.config.location);
 
@@ -13,10 +13,10 @@ export default async (app, type, post = () => undefined) => {
       .filter(include => /^[^/]*$/u.test(include))
       .map(async include => {
         const path = app.root.join(include);
-        if (await path.exists) {
-          const to = Path.join(type, include);
-          await app.stage(path, to);
-          await post(to);
+        if (await path.exists()) {
+          const target = Path.join(type, include);
+          await app.stage(path, target);
+          await post(target);
         }
       }));
   }