primate 0.19.3 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.19.3",
+  "version": "0.20.0",
   "description": "Expressive, minimal and extensible web framework",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -17,7 +17,7 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "runtime-compat": "^0.17.0"
+    "runtime-compat": "^0.20.2"
   },
   "type": "module",
   "exports": "./src/exports.js"

package/src/Logger.js

@@ -1,16 +1,17 @@
 import {assert, is} from "runtime-compat/dyndef";
 import {blue, bold, green, red, yellow, dim} from "runtime-compat/colors";
+import {map, valmap} from "runtime-compat/object";
 
-const errors = {
+const levels = {
   Error: 0,
   Warn: 1,
   Info: 2,
 };
 
 const print = (...messages) => process.stdout.write(messages.join(" "));
-const bye = () => print(dim(yellow("~~ bye\n")));
-const mark = (format, ...params) => params.reduce((formatted, param) =>
-  formatted.replace("%", bold(param)), format);
+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";
 
@@ -21,103 +22,86 @@ const hyphenate = classCased => classCased
   .join("")
   .slice(1);
 
+const throwable = ({message, level, fix}, name, module) => ({
+  new(...args) {
+    const error = new Error(mark(message, ...args));
+    error.level = Logger[level];
+    error.fix = mark(fix, ...args);
+    error.name = name;
+    error.module = module;
+    return error;
+  },
+  throw(...args) {
+    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 Logger = class Logger {
   #level; #trace;
 
-  static throwable(type, name, module) {
-    return {
-      throw(args = {}) {
-        const {message, level, fix} = type(args);
-        const error = new Error(mark(...message));
-        error.level = level;
-        error.fix = mark(...fix);
-        error.name = name;
-        error.module = module;
-        throw error;
-      },
-      warn(logger, ...args) {
-        const {message, level, fix} = type(...args);
-        const error = {level, message: mark(...message), fix: mark(...fix)};
-        logger.auto({...error, name, module});
-      },
-    };
+  static err(errors, module) {
+    return map(errors, ([key, value]) => [key, throwable(value, key, module)]);
   }
 
-  constructor({level = errors.Error, trace = false} = {}) {
-    assert(level !== undefined && level <= errors.Info);
+  constructor({level = levels.Error, trace = false} = {}) {
+    assert(level !== undefined && level <= levels.Info);
     is(trace).boolean();
     this.#level = level;
     this.#trace = trace;
   }
 
-  static print(...args) {
-    print(...args);
-  }
-
-  static get mark() {
-    return mark;
-  }
-
   static get Error() {
-    return errors.Error;
+    return levels.Error;
   }
 
   static get Warn() {
-    return errors.Warn;
+    return levels.Warn;
   }
 
   static get Info() {
-    return errors.Info;
-  }
-
-  get class() {
-    return this.constructor;
+    return levels.Info;
   }
 
-  #print(pre, color, message, {fix, module, name} = {}, error) {
-    print(pre, `${module !== undefined ? `${color(module)} ` : ""}${message}`, "\n");
-    if (fix && this.level >= errors.Warn) {
+  #print(pre, color, message, 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");
     }
-    this.#trace && error && console.log(error);
+    if (level === levels.Error || level === undefined && error.message) {
+      this.#trace && console.log(error);
+    }
   }
 
   get level() {
     return this.#level;
   }
 
-  info(message, args) {
-    if (this.level >= errors.Info) {
-      this.#print(green("--"), green, message, args);
-    }
+  info(...args) {
+    this.level >= levels.Info && this.#print("--", green, ...args);
   }
 
-  warn(message, args) {
-    if (this.level >= errors.Warn) {
-      this.#print(yellow("??"), yellow, message, args);
-    }
+  warn(...args) {
+    this.level >= levels.Warn && this.#print("??", yellow, ...args);
   }
 
-  error(message, args, error) {
-    if (this.level >= errors.Warn) {
-      this.#print(red("!!"), red, message, args, error);
-    }
+  error(...args) {
+    this.level >= levels.Warn && this.#print("!!", red, ...args);
   }
 
   auto(error) {
-    const {level, message, ...args} = error;
-    if (level === errors.Info) {
-      return this.info(message, args, error);
-    }
-    if (level === errors.Warn) {
-      return this.warn(message, args, error);
-    }
-
-    return this.error(message, args, error);
+    const {message} = error;
+    const matches = map(levels, ([name, level]) => [level, name.toLowerCase()]);
+    return this[matches[error.level] ?? "error"](message, error);
   }
 };
 
 export default Logger;
 
-export {print, bye};
+export {print, bye, mark};

package/src/app.js

@@ -1,38 +1,28 @@
 import crypto from "runtime-compat/crypto";
+import {tryreturn} from "runtime-compat/flow";
 import {File, Path} from "runtime-compat/fs";
 import {bold, blue} from "runtime-compat/colors";
-import errors from "./errors.js";
+import {transform, valmap} from "runtime-compat/object";
 import * as handlers from "./handlers/exports.js";
 import * as hooks from "./hooks/exports.js";
+import * as loaders from "./loaders/exports.js";
 import dispatch from "./dispatch.js";
-
-const qualify = (root, paths) =>
-  Object.keys(paths).reduce((sofar, key) => {
-    const value = paths[key];
-    sofar[key] = typeof value === "string"
-      ? new Path(root, value)
-      : qualify(`${root}/${key}`, value);
-    return sofar;
-  }, {});
+import {print} from "./Logger.js";
 
 const base = new Path(import.meta.url).up(1);
-const defaultLayout = "index.html";
+// do not hard-depend on node
+const packager = import.meta.runtime?.packager ?? "package.json";
+const library = import.meta.runtime?.library ?? "node_modules";
 
-const index = async (app, layout = defaultLayout) => {
-  const name = layout;
-  try {
-    // user-provided file
-    return await File.read(`${app.paths.layouts.join(name)}`);
-  } catch (error) {
-    // fallback
-    return base.join("defaults", defaultLayout).text();
-  }
-};
+// use user-provided file or fall back to default
+const index = (app, name) =>
+  tryreturn(async _ => File.read(`${app.paths.pages.join(name)}`))
+    .orelse(async _ => base.join("defaults", app.config.index).text());
 
 const hash = async (string, algorithm = "sha-384") => {
   const encoder = new TextEncoder();
   const bytes = await crypto.subtle.digest(algorithm, encoder.encode(string));
-  const algo = algorithm.replace("-", () => "");
+  const algo = algorithm.replace("-", _ => "");
   return `${algo}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
 };
 
@@ -45,92 +35,53 @@ const tag = ({name, attributes = {}, code = "", close = true}) =>
 
 export default async (config, root, log) => {
   const {http} = config;
+  const secure = http?.ssl !== undefined;
+  const {name, version} = await base.up(1).join(packager).json();
+  const paths = valmap(config.paths, value => root.join(value));
+  paths.client = paths.build.join("client");
+  paths.server = paths.build.join("server");
+
+  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 (http.ssl) {
+  if (secure) {
     http.ssl.key = root.join(http.ssl.key);
     http.ssl.cert = root.join(http.ssl.cert);
   }
 
-  const paths = qualify(root, config.paths);
-
-  const ending = ".js";
-  const routes = paths.routes === undefined ? [] : await Promise.all(
-    (await Path.collect(paths.routes, /^.*.js$/u))
-      .map(async route => [
-        `${route}`.replace(paths.routes, "").slice(1, -ending.length),
-        (await import(route)).default,
-      ]));
-  const types = Object.fromEntries(
-    paths.types === undefined ? [] : await Promise.all(
-      (await Path.collect(paths.types , /^.*.js$/u))
-        /* accept only lowercase-first files in type filename */
-        .filter(path => /^[a-z]/u.test(path.name))
-        .map(async type => [
-          `${type}`.replace(paths.types, "").slice(1, -ending.length),
-          (await import(type)).default,
-        ])));
-  if (await paths.types.exists) {
-    Object.keys(types).length === 0
-      && errors.EmptyTypeDirectory.warn(log, {root: paths.types});
-  }
-  Object.entries(types).some(([name, type]) =>
-    typeof type !== "function" && errors.InvalidType.throw({name}));
-
-  const modules = config.modules === undefined ? [] : config.modules;
-
-  modules.every((module, n) => module.name !== undefined ||
-    errors.ModulesMustHaveNames.throw({n}));
-
-  new Set(modules.map(({name}) => name)).size !== modules.length &&
-    errors.DoubleModule.throw({
-      modules: modules.map(({name}) => name),
-      config: root.join("primate.config.js"),
-    });
-
-  const hookless = modules.filter(module => !Object.keys(module).some(key =>
-    [...Object.keys(hooks), "load"].includes(key)));
-  hookless.length > 0 && errors.ModuleHasNoHooks.warn(log, {hookless});
-
-  const {name, version} = await base.up(1).join("package.json").json();
+  const types = await loaders.types(log, paths.types);
 
   const app = {
     config,
-    routes,
-    secure: http?.ssl !== undefined,
+    secure,
     name,
     version,
-    library: {},
-    identifiers: {},
-    replace(code) {
-      const joined = Object.keys(app.identifiers).join("|");
-      const re = `(?<=import (?:.*) from ['|"])(${joined})(?=['|"])`;
-      return code.replaceAll(new RegExp(re, "gus"), (_, p1) => {
-        if (app.library[p1] === undefined) {
-          app.library[p1] = app.identifiers[p1];
-        }
-        return app.identifiers[p1];
-      });
-    },
-    resources: [],
+    importmaps: {},
+    assets: [],
     entrypoints: [],
     paths,
     root,
     log,
-    generateHeaders: () => {
+    async copy(source, target, filter = /^.*.js$/u) {
+      const jss = await source.collect(filter);
+      await Promise.all(jss.map(async js => {
+        const file = await js.file.read();
+        const to = await target.join(js.path.replace(source, ""));
+        await to.directory.file.create();
+        await to.file.write(file);
+      }));
+    },
+    headers: _ => {
       const csp = Object.keys(http.csp).reduce((policy_string, key) =>
         `${policy_string}${key} ${http.csp[key]};`, "");
-      const scripts = app.resources
+      const scripts = app.assets
         .filter(({type}) => type !== "style")
-        .map(resource => `'${resource.integrity}'`).join(" ");
+        .map(asset => `'${asset.integrity}'`).join(" ");
       const _csp = scripts === "" ? csp : `${csp}script-src 'self' ${scripts};`;
-      // remove inline resources
-      for (let i = app.resources.length - 1; i >= 0; i--) {
-        const resource = app.resources[i];
-        if (resource.inline) {
-          app.resources.splice(i, 1);
-        }
-      }
+      // remove inline assets
+      app.assets = app.assets.filter(({inline, type}) => !inline
+        || type === "importmap");
 
       return {
         "Content-Security-Policy": _csp,
@@ -138,8 +89,8 @@ export default async (config, root, log) => {
       };
     },
     handlers: {...handlers},
-    render: async ({body = "", head = "", layout} = {}) => {
-      const html = await index(app, layout);
+    render: async ({body = "", head = "", page} = {}) => {
+      const html = await index(app, page ?? config.index);
       // inline: <script type integrity>...</script>
       // outline: <script type integrity src></script>
       const script = ({inline, code, type, integrity, src}) => inline
@@ -150,50 +101,64 @@ export default async (config, root, log) => {
       const style = ({inline, code, href, rel = "stylesheet"}) => inline
         ? tag({name: "style", code})
         : tag({name: "link", attributes: {rel, href}, close: false});
-      const heads = app.resources.map(({src, code, type, inline, integrity}) =>
-        type === "style"
-          ? style({inline, code, href: src})
-          : script({inline, code, type, integrity, src})
-      ).join("\n");
+      const heads = app.assets
+        .toSorted(({type}) => -1 * (type === "importmap"))
+        .map(({src, code, type, inline, integrity}) =>
+          type === "style"
+            ? style({inline, code, href: src})
+            : script({inline, code, type, integrity, src})
+        ).join("\n");
       return html
-        .replace("%body%", () => body)
-        .replace("%head%", () => `${head}${heads}`);
+        .replace("%body%", _ => body)
+        .replace("%head%", _ => `${head}${heads}`);
     },
     publish: async ({src, code, type = "", inline = false}) => {
-      if (type === "module") {
-        code = app.replace(code);
+      if (!inline) {
+        const base = paths.client.join(src);
+        await base.directory.file.create();
+        await base.file.write(code);
       }
       const integrity = await hash(code);
       const _src = new Path(http.static.root).join(src ?? "");
-      app.resources.push({src: `${_src}`, code, type, inline, integrity});
+      app.assets.push({src: `${_src}`, code: inline ? code : "", type, inline, integrity});
       return integrity;
     },
     bootstrap: ({type, code}) => {
       app.entrypoints.push({type, code});
     },
-    resolve: (pkg, name) => {
-      const exports = Object.fromEntries(Object.entries(pkg.exports)
-        .filter(([, _export]) => _export.import !== undefined)
-        .map(([key, value]) => [
-          key.replace(".", name),
-          value.import.replace(".", `./${name}`),
-        ]));
-      app.identifiers = {...exports, ...app.identifiers};
+    async import(module) {
+      const {build} = config;
+      const {root} = http.static;
+      const path = [library, module];
+      const pkg = await Path.resolve().join(...path, packager).json();
+      const exports = pkg.exports === undefined
+        ? {[module]: `/${module}/${pkg.main}`}
+        : transform(pkg.exports, entry => entry
+          .filter(([, _export]) => _export.import !== undefined)
+          .map(([key, value]) => [
+            key.replace(".", module),
+            value.import.replace(".", `./${module}`),
+          ]));
+      await Promise.all(Object.values(exports).map(async name => app.publish({
+          code: await Path.resolve().join(library, name).text(),
+          src: new Path(root, build.modules, name),
+          type: "module",
+        })));
+      this.importmaps = {
+        ...valmap(exports, value => new Path(root, build.modules, value).path),
+        ...this.importmaps};
     },
-    modules,
     types,
+    routes: await loaders.routes(log, paths.routes),
+    dispatch: dispatch(types),
   };
-  log.class.print(blue(bold(name)), blue(version),
-    `at http${app.secure ? "s" : ""}://${http.host}:${http.port}\n`);
-  // modules may load other modules
-  await Promise.all(app.modules
-    .filter(module => module.load !== undefined)
-    .map(module => module.load({...app, load(dependent) {
-      app.modules.push(dependent);
-    }})));
 
-  app.route = hooks.route({...app, dispatch: dispatch(types)});
-  app.parse = hooks.parse(dispatch(types));
+  const modules = await loaders.modules(app, root, config);
 
-  return app;
+  return {...app,
+    modules,
+    layoutDepth: Math.max(...app.routes.map(({layouts}) => layouts.length)) + 1,
+    route: hooks.route({...app, modules}),
+    parse: hooks.parse(dispatch(types)),
+  };
 };

package/src/bin.js

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

package/src/defaults/primate.config.js

@@ -18,19 +18,26 @@ export default {
     },
     static: {
       root: "/",
-      pure: false,
     },
   },
+  index: "app.html",
   paths: {
-    layouts: "layouts",
+    build: "build",
     static: "static",
-    public: "public",
-    routes: "routes",
     components: "components",
+    routes: "routes",
     types: "types",
+    pages: "pages",
+    layouts: "layouts",
+  },
+  build: {
+    includes: [],
+    static: "static",
+    app: "app",
+    modules: "modules",
+    index: "index.js",
   },
   modules: [],
-  dist: "app",
   types: {
     explicit: false,
   },

package/src/dispatch.js

@@ -1,24 +1,19 @@
 import {is, maybe} from "runtime-compat/dyndef";
+import {tryreturn} from "runtime-compat/flow";
+import {map} from "runtime-compat/object";
 import errors from "./errors.js";
 
 export default (patches = {}) => value => {
   is(patches.get).undefined();
   return Object.assign(Object.create(null), {
-    ...Object.fromEntries(Object.entries(patches).map(([name, patch]) =>
-      [name, property => {
-        is(property).defined(`\`${name}\` called without property`);
-        try {
-          return patch(value[property], property);
-        } catch (error) {
-          errors.MismatchedType.throw({message: error.message});
-        }
-      }])),
+    ...map(patches, ([name, patch]) => [name, property => {
+      is(property).defined(`\`${name}\` called without property`);
+      return tryreturn(_ => patch(value[property], property))
+        .orelse(({message}) => errors.MismatchedType.throw(message));
+    }]),
     get(property) {
       maybe(property).string();
-      if (property !== undefined) {
-        return value[property];
-      }
-      return value;
+      return property === undefined ? value : value[property];
     },
   });
 };