primate 0.15.3 → 0.15.5

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "primate",
-  "version": "0.15.3",
+  "version": "0.15.5",
   "description": "Expressive, minimal and extensible framework for JavaScript",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
   "license": "MIT",
+  "files": [
+    "src/**",
+    "!src/**/*.spec.js",
+    "!readme/**"
+  ],
   "bin": "src/bin.js",
   "repository": "https://github.com/primatejs/primate",
   "scripts": {
@@ -18,9 +23,6 @@
   "devDependencies": {
     "maximin": "^0.1.2"
   },
-  "engines": {
-    "node": ">=17.9.0"
-  },
   "type": "module",
   "exports": "./src/exports.js"
 }

package/src/Logger.js

@@ -0,0 +1,98 @@
+import {assert, is} from "runtime-compat/dyndef";
+
+const colors = {
+  black: msg => `\x1b[0m${msg}\x1b[0m`,
+  bold: msg => `\x1b[1m${msg}\x1b[0m`,
+  red: msg => `\x1b[31m${msg}\x1b[0m`,
+  green: msg => `\x1b[32m${msg}\x1b[0m`,
+  yellow: msg => `\x1b[33m${msg}\x1b[0m`,
+  blue: msg => `\x1b[34m${msg}\x1b[0m`,
+  gray: msg => `\x1b[2m${msg}\x1b[0m`,
+};
+
+const error = 0;
+const warn = 1;
+const info = 2;
+
+// Error natively provided
+const Warn = class Warn extends Error {};
+const Info = class Info extends Error {};
+
+const levels = new Map([
+  [Error, error],
+  [Warn, warn],
+  [Info, info],
+]);
+
+const print = (...messages) => process.stdout.write(messages.join(" "));
+
+const Logger = class Logger {
+  #level; #traceStack;
+
+  constructor({level = Error, traceStack = false} = {}) {
+    assert(level !== undefined && levels.get(level) <= info);
+    is(traceStack).boolean();
+    this.#level = level;
+    this.#traceStack = traceStack;
+  }
+
+  static get Error() {
+    return Error;
+  }
+
+  static get Warn() {
+    return Warn;
+  }
+
+  static get Info() {
+    return Info;
+  }
+
+  #print(pre, error) {
+    if (error instanceof Error) {
+      print(colors.bold(pre), error.message, "\n");
+      if (this.#traceStack) {
+        console.log(error);
+      }
+    } else {
+      print(colors.bold(pre), error, "\n");
+    }
+  }
+
+  get level() {
+    return levels.get(this.#level);
+  }
+
+  info(message) {
+    if (this.level >= levels.get(Info)) {
+      this.#print(colors.green("--"), message);
+    }
+  }
+
+  warn(message) {
+    if (this.level >= levels.get(Warn)) {
+      this.#print(colors.yellow("??"), message);
+    }
+  }
+
+  error(message) {
+    if (this.level >= levels.get(Error)) {
+      this.#print(colors.red("!!"), message);
+    }
+  }
+
+  auto(message) {
+    if (message instanceof Info) {
+      return this.info(message.message);
+    }
+    if (message instanceof Warn) {
+      return this.warn(message.message);
+    }
+
+    return this.error(message);
+  }
+};
+
+export default Logger;
+
+export {colors, levels, print};

package/src/bin.js

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
 import args from "runtime-compat/args";
-import * as commands from "./commands/exports.js";
 import run from "./run.js";
 
-const command = name => commands[name] ?? commands.help;
-
-await run(args[0] === undefined ? commands.dev : command(args[0]));
+await run(args[0]);

package/src/commands/create.js

@@ -1,7 +1,6 @@
 import {Path} from "runtime-compat/fs";
-import package_json from "../../package.json" assert {type: "json"};
 
-const createModule = async () => {
+const createModule = async env => {
   const space = 2;
   try {
     // will throw if cannot find a package.json up the filesystem hierarchy
@@ -11,7 +10,7 @@ const createModule = async () => {
       name: "primate-app",
       private: true,
       dependencies: {
-        primate: `^${package_json.version}`,
+        primate: `^${env.version}`,
       },
       scripts: {
         start: "npx primate",
@@ -37,7 +36,7 @@ const createConfig = async env => {
 };
 
 export default async env => {
-  await createModule();
+  await createModule(env);
   await createConfig(env);
 };
 

package/src/commands/dev.js

@@ -1,16 +1,3 @@
-import register from "../register.js";
-import compile from "../compile.js";
-import publish from "../publish.js";
-import route from "../route.js";
-import serve from "../serve.js";
+import start from "../start.js";
 
-export default async env => {
-  // register handlers
-  await register(env);
-  // compile server-side code
-  await compile(env);
-  // publish client-side code
-  await publish(env);
-  // serve
-  serve({router: await route(env), ...env});
-};
+export default async env => start(env);

package/src/commands/exports.js

@@ -1,4 +1,10 @@
-export {default as dev} from "./dev.js";
-export {default as serve} from "./serve.js";
-export {default as create} from "./create.js";
-export {default as help} from "./help.js";
+import {default as dev} from "./dev.js";
+import {default as serve} from "./serve.js";
+import {default as create} from "./create.js";
+import {default as help} from "./help.js";
+
+const commands = {dev, serve, create, help};
+
+const run = name => commands[name] ?? help;
+
+export default name => name === undefined ? dev : run(name);

package/src/commands/help.js

@@ -1,3 +1,3 @@
 export default env => {
-  env.log.info("available commands: create start");
+  env.log.info("available commands: create dev serve");
 };

package/src/commands/serve.js

@@ -1,19 +1,3 @@
-import register from "../register.js";
-import compile from "../compile.js";
-import publish from "../publish.js";
-import bundle from "../bundle.js";
-import route from "../route.js";
-import serve from "../serve.js";
+import start from "../start.js";
 
-export default async env => {
-  // register handlers
-  await register(env);
-  // compile server-side code
-  await compile(env);
-  // publish client-side code
-  await publish(env);
-  // bundle client-side code
-  await bundle(env);
-  // serve
-  serve({router: await route(env), ...env});
-};
+export default async env => start(env, {bundle: true});

package/src/config.js

@@ -4,9 +4,8 @@ import {File, Path} from "runtime-compat/fs";
 import cache from "./cache.js";
 import extend from "./extend.js";
 import defaults from "./primate.config.js";
-import * as log from "./log.js";
+import {colors, print, default as Logger} from "./Logger.js";
 import * as handlers from "./handlers/exports.js";
-import package_json from "../package.json" assert {type: "json"};
 
 const qualify = (root, paths) =>
   Object.keys(paths).reduce((sofar, key) => {
@@ -58,41 +57,54 @@ export default async (filename = "primate.config.js") => {
   const root = await getRoot();
   const config = await getConfig(root, filename);
 
-  const resources = [];
+  const {name, version} = JSON.parse(await new Path(import.meta.url)
+    .directory.directory.join("package.json").file.read());
+
   const env = {
     ...config,
+    name, version,
+    resources: [],
+    entrypoints: [],
     paths: qualify(root, config.paths),
     root,
-    log: {...log, error: error => log.error(error, config)},
+    log: new Logger(config.logger),
     register: (name, handler) => {
       env.handlers[name] = handler;
     },
     handlers: {...handlers},
     render: async ({body = "", head = ""} = {}) => {
       const html = await index(env);
-      const heads = resources.map(({src, code, type, inline, integrity}) => {
-        const tag = "script";
-        const pre = `<${tag} type="${type}" integrity="${integrity}"`;
-        const post = `</${tag}>`;
-        return inline ? `${pre}>${code}${post}` : `${pre} src="${src}">${post}`;
+      const heads = env.resources.map(({src, code, type, inline, integrity}) => {
+        const tag = type === "style" ? "link" : "script";
+        const pre = type === "style"
+          ? `<${tag} rel="stylesheet" integrity="${integrity}"`
+          : `<${tag} type="${type}" integrity="${integrity}"`;
+        const middle = type === "style"
+          ? ` href="${src}">`
+          : ` src="${src}">`;
+        const post = type === "style" ? "" : `</${tag}>`;
+        return inline ? `${pre}>${code}${post}` : `${pre}${middle}${post}`;
       }).join("\n");
       return html
         .replace("%body%", () => body)
         .replace("%head%", () => `${head}${heads}`);
     },
-    publish: async ({src, code, type = "", inline = false, main}) => {
+    publish: async ({src, code, type = "", inline = false}) => {
       const integrity = await hash(code);
-      resources.push({src, code, type, inline, integrity, main});
+      env.resources.push({src, code, type, inline, integrity});
       return integrity;
     },
+    bootstrap: ({type, code}) => {
+      env.entrypoints.push({type, code});
+    },
   };
-  env.log.info(`${package_json.name} \x1b[34m${package_json.version}\x1b[0m`);
+  print(colors.blue(colors.bold(name)), colors.blue(version), "");
   const {modules} = config;
   // modules may load other modules
   const loads = await Promise.all(modules
     .filter(module => module.load !== undefined)
     .map(module => module.load()));
 
-  return cache("config", filename, () => ({...env, resources,
+  return cache("config", filename, () => ({...env,
     modules: modules.concat(loads.flat())}));
 };

package/src/errors/Info.js

@@ -0,0 +1 @@
+export default class InfoError extends Error {}

package/src/exports.js

@@ -1,5 +1,5 @@
-import {serve} from "./commands/exports.js";
 import run from "./run.js";
 
 export * from "./handlers/exports.js";
-export default () => run(serve);
+export {default as Logger} from "./Logger.js";
+export default command => run(command);

package/src/primate.config.js

@@ -1,6 +1,10 @@
+import {Logger} from "primate";
+
 export default {
   base: "/",
-  debug: false,
+  logger: {
+    level: Logger.Warn,
+  },
   http: {
     host: "localhost",
     port: 6161,
@@ -19,4 +23,5 @@ export default {
     components: "components",
   },
   modules: [],
+  dist: "app",
 };

package/src/route.js

@@ -1,5 +1,5 @@
 import {Path} from "runtime-compat/fs";
-import RouteError from "./errors/Route.js";
+import Logger from "./Logger.js";
 
 // insensitive-case equal
 const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
@@ -23,7 +23,7 @@ export default async env => {
       const {pathname, searchParams} = url;
       const params = Object.fromEntries(searchParams);
       const verb = find(method, pathname, {handler: () => {
-        throw new RouteError(`no ${method.toUpperCase()} route to ${pathname}`);
+        throw new Logger.Info(`no ${method.toUpperCase()} route to ${pathname}`);
       }});
       const path = pathname.split("/").filter(part => part !== "");
       const named = verb.path?.exec(pathname)?.groups ?? {};

package/src/run.js

@@ -1,6 +1,4 @@
 import config from "./config.js";
+import command from "./commands/exports.js";
 
-export default async command => {
-  // env should initialised before any commands run
-  await command(await config());
-};
+export default async name => command(name)(await config());

package/src/serve.js

@@ -5,6 +5,7 @@ import mimes from "./mimes.js";
 import {http404} from "./handlers/http.js";
 import {isResponse} from "./duck.js";
 import respond from "./respond.js";
+import {colors, print} from "./Logger.js";
 
 const regex = /\.([a-z1-9]*)$/u;
 const mime = filename => mimes[filename.match(regex)[1]] ?? mimes.binary;
@@ -46,7 +47,7 @@ export default env => {
         input => handler(input, acc));
       return await respond(await handlers({request, env}))(env, headers);
     } catch (error) {
-      env.log.error(error);
+      env.log.auto(error);
       return http404()(env, headers);
     }
   };
@@ -89,7 +90,7 @@ export default env => {
     try {
       return await _serve(request);
     } catch (error) {
-      env.log.error(error);
+      env.log.auto(error);
       return new Response(null, {status: statuses.InternalServerError});
     }
   };
@@ -136,5 +137,5 @@ export default env => {
     return handlers({original: request, pathname: pathname + search, body});
   }, http);
 
-  env.log.info(`running on ${http.host}:${http.port}`);
+  print(colors.gray(`at http://${http.host}:${http.port}`), "\n");
 };

package/src/start.js

@@ -0,0 +1,27 @@
+import register from "./register.js";
+import compile from "./compile.js";
+import publish from "./publish.js";
+import bundle from "./bundle.js";
+import route from "./route.js";
+import serve from "./serve.js";
+
+export default async (env, operations = {}) => {
+  // register handlers
+  await register(env);
+  // compile server-side code
+  await compile(env);
+  // publish client-side code
+  await publish(env);
+
+  // after publish hook, publish a zero assumptions app.js (no css imports)
+  const code = env.entrypoints.filter(({type}) => type === "script")
+    .map(({code}) => code).join("");
+  await env.publish({src: `${env.dist}.js`, code, type: "module"});
+
+  if (operations?.bundle) {
+    // bundle client-side code
+    await bundle(env);
+  }
+  // serve
+  serve({router: await route(env), ...env});
+};

package/src/log.js

@@ -1,29 +0,0 @@
-const colors = {
-  red: 31,
-  green: 32,
-  yellow: 33,
-  blue: 34,
-};
-const reset = 0;
-
-const Log = {
-  paint: (color, message) => {
-    process.stdout.write(`\x1b[${color}m${message}\x1b[0m`);
-    return log;
-  },
-  nl: () => log.paint(reset, "\n"),
-};
-
-const log = new Proxy(Log, {
-  get: (target, property) => target[property] ?? (message =>
-    log.paint(colors[property] ?? reset, message).paint(reset, " ")),
-});
-
-export const info = (...args) => log.green("[info]").reset(...args).nl();
-
-export const warn = (...args) => log.yellow("[warn]").reset(...args).nl();
-
-export const error = (originalError, env) => {
-  log.red("[error]").reset(originalError.message).nl();
-  env.debug && console.log(originalError);
-};