primate 0.15.4 → 0.15.6

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "primate",
-  "version": "0.15.4",
+  "version": "0.15.6",
   "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/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/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/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,13 +57,17 @@ export default async (filename = "primate.config.js") => {
   const root = await getRoot();
   const config = await getConfig(root, filename);
 
+  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;
     },
@@ -86,16 +89,17 @@ export default async (filename = "primate.config.js") => {
         .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);
-      env.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), "");
+  print(colors.gray(`at http://${config.http.host}:${config.http.port}`), "\n");
   const {modules} = config;
   // modules may load other modules
   const loads = await Promise.all(modules

package/src/errors/Info.js

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

package/src/exports.js

@@ -1,4 +1,5 @@
 import run from "./run.js";
 
 export * from "./handlers/exports.js";
+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,

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/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});
     }
   };
@@ -135,6 +136,4 @@ export default env => {
 
     return handlers({original: request, pathname: pathname + search, body});
   }, http);
-
-  env.log.info(`running on ${http.host}:${http.port}`);
 };

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);
-};