@vistta/cli 1.0.1 → 1.1.0

package/commands/default.js

@@ -39,7 +39,9 @@ export default class DefaultCommand extends Command {
       const modules = await (await import("../utils.js"))?.getOutdatedPackages(process.cwd());
       for (let i = 0, len = modules.length; i < len; i++) {
         const { name, current, wanted, latest } = modules[i];
-        if (current === wanted) console.print(`${COLORS.CYAN}Module "${name}" has a new version (${latest})${COLORS.RESET}`);
+        if (!current) console.print(`${COLORS.YELLOW}Module "${name}" is missing${COLORS.RESET}`);
+        else if (current === wanted)
+          console.print(`${COLORS.CYAN}Module "${name}" has a new version (${latest})${COLORS.RESET}`);
         else console.print(`${COLORS.YELLOW}Module "${name}" is outdated (${latest})${COLORS.RESET}`);
       }
     } catch {

package/commands/project.js

@@ -16,11 +16,7 @@ const HELP = {
 };
 
 export default class extends Command {
-  constructor(options) {
-    super(options);
-  }
-
-  help(_, command) {
+  async help(_, command) {
     switch (command) {
       case "name":
         console.print(capitalize(HELP["name"]));

package/commands/test.js

@@ -1,30 +1,20 @@
 import { COLORS } from "@vistta/console";
 import fs from "@vistta/fs";
+import { TestRunner } from "../classes/test-runner.js";
 import { parseArgs } from "../utils.js";
 import DefaultCommand from "./default.js";
 
 const cwd = process.cwd();
 
 export default class extends DefaultCommand {
-  #options = {};
-  #results = [];
-  #failed;
-  #suite;
-  #runningCounter = 0;
+  #testRunner;
 
   constructor() {
     super();
-    const suite = this.suite.bind(this, false);
-    suite.only = this.suite.bind(this, true);
     this.define("env", "NODE_ENV", "testing");
-    this.define("global", "suite", suite);
-    const test = this.test.bind(this, false);
-    test.only = this.test.bind(this, true);
-    this.define("global", "test", test);
-    this.define("global", "expect", this.expect.bind(this));
   }
 
-  help() {
+  async help() {
     console.print("Runs all the tests files that match the pattern/s in the current project");
     console.print("\nUsage:");
     console.print("vistta test [...patterns]\tRuns all the tests files that match the pattern/s in the current project");
@@ -36,179 +26,57 @@ export default class extends DefaultCommand {
 
   async main(_, ...argv) {
     let [args, options] = parseArgs(argv);
-    this.#options = options;
-    if (args.length === 0) args = ["**/*.test.js", "**/*.test.ts"];
+    this.#testRunner = new TestRunner(options);
+    this.define("global", "suite", this.#testRunner.suite);
+    this.define("global", "test", this.#testRunner.test);
+    this.define("global", "expect", this.#testRunner.expect);
+    if (args.length === 0) args = this.resolvers.map((ext) => `**/*.test.${ext}`);
     for (let i = 0, len = args.length; i < len; i++) args[i] = fs.resolve(cwd, args[i]);
     const entries = fs.glob(args);
     let entry = (await entries.next())?.value;
     if (!process.env.NODE_DEBUG) console.disable();
+    let failed = false;
     while (entry) {
       try {
         process.chdir(fs.dirname(entry));
         if (!entry.includes("\\node_modules\\")) await import(fs.resolve(entry));
-        await this.#await();
       } catch {
-        this.#failed = true;
+        failed = true;
       }
       entry = (await entries.next())?.value;
     }
     if (!process.env.NODE_DEBUG) console.enable();
     let output = "";
-    for (let i = 0, len = this.#results.length; i < len; i++) {
-      const { name, tests } = this.#results[i];
+    const results = await this.#testRunner.run();
+    for (let i = 0, len = results.length; i < len; i++) {
+      const { name, tests } = results[i];
+      let passing = 0;
+      let total = 0;
+      let first, last;
       if (name) output += `\n${name}\n`;
-      const [results, passing, total, time] = processTests(tests);
-      output += `${results}${passing === total ? COLORS.GREEN : COLORS.RED}${passing}/${total} passing ${COLORS.RESET + COLORS.DIM}(${time}ms)${COLORS.RESET}\n`;
+      for (let n = 0, nlen = tests?.length || 0; n < nlen; n++) {
+        const { name, status, start, end, result, error } = tests[n];
+        if (!first || start < first) first = start;
+        if (!last || end > last) last = end;
+        switch (status) {
+          case "pass":
+            output += `  ${COLORS.GREEN}PASSED  ${name} ${COLORS.RESET + COLORS.DIM}(${Math.round(end - start)}ms)${COLORS.RESET}\n${typeof result === "string" ? "\t" + COLORS.GREEN + result + COLORS.RESET + "\n" : ""}`;
+            passing++;
+            total++;
+            break;
+          case "fail":
+            output += `  ${COLORS.RED}FAILED  ${name} ${COLORS.RESET + COLORS.DIM}(${Math.round(end - start)}ms)${COLORS.RESET}\n\t${COLORS.RED + error + COLORS.RESET}\n`;
+            total++;
+            break;
+          case "skip":
+            output += `  ${COLORS.YELLOW}SKIPPED ${name} ${COLORS.RESET + COLORS.DIM}(${Math.round(end - start)}ms)${COLORS.RESET}\n`;
+            break;
+        }
+      }
+      if (total !== passing) failed = true;
+      output += `${passing === total ? COLORS.GREEN : COLORS.RED}${passing}/${total} passing ${COLORS.RESET + COLORS.DIM}(${Math.round(last - first)}ms)${COLORS.RESET}\n`;
     }
     console.print(output);
-    process.exit(this.#failed ? -1 : 0);
-  }
-
-  async suite(only, name, callback) {
-    if (this.#suite) throw new Error("Suites/Describes cannot be stacked");
-    this.#runningCounter++;
-    this.#suite = { name, only, tests: [] };
-    try {
-      const value = callback();
-      if (value instanceof Promise) await value;
-    } catch {
-      /* Do Nothing */
-    }
-    this.#results.push(this.#suite);
-    this.#suite = null;
-    this.#runningCounter--;
+    process.exit(failed ? -1 : 0);
   }
-
-  async test(only, name, callback) {
-    if (
-      (this.#options.filter && !name.match(new RegExp(this.#options.filter, "i"))) ||
-      (this.#options.only && !(only || this.#suite?.only))
-    )
-      return;
-    this.#runningCounter++;
-    const test = { name };
-    test.start = performance();
-    if (this.#suite) this.#suite.tests.push(test);
-    else this.#results.push({ tests: [test], time: test.time });
-
-    try {
-      test.result = callback();
-      if (test.result instanceof Promise) test.result = await test.result;
-      test.status = "pass";
-      test.end = performance();
-    } catch (error) {
-      test.status = "fail";
-      test.error = error;
-      test.end = performance();
-      this.#failed = true;
-    }
-    this.#runningCounter--;
-  }
-
-  expect(target, label) {
-    return {
-      not: {
-        toEqual: (value, unit = "") => {
-          if (target !== value) return;
-          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not equal ${value}${unit}`);
-        },
-        toBeLessThan: (value, unit = "") => {
-          if (target >= value) return;
-          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not be less than ${value}${unit}`);
-        },
-        toBeGreaterThan: (value, unit = "") => {
-          if (target <= value) return;
-          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not be greater than ${value}${unit}`);
-        },
-        toInclude: (value) => {
-          if (target.indexOf(value) === -1) return;
-          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not include ${value}`);
-        },
-        toMatch: (regex) => {
-          if (!target.match(new RegExp(regex))) return;
-          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not match ${regex}`);
-        },
-        toThrow: (message) => {
-          try {
-            target();
-          } catch (error) {
-            if (!message)
-              throw new Error(`expected ${label ? label + "()" : "function()"} to not throw, but got ${error.message}`);
-            if (error.message === message)
-              throw new Error(
-                `expected ${label ? label + "()" : "function()"} to not throw ${message}, but got ${error.message}`,
-              );
-            if (error.message.match(new RegExp(message)))
-              throw new Error(
-                `expected ${label ? label + "()" : "function()"} to not throw ${message}, but got ${error.message}`,
-              );
-            return;
-          }
-        },
-      },
-      toEqual: (value, unit = "") => {
-        if (target === value) return;
-        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to equal ${value}${unit}`);
-      },
-      toBeLessThan: (value, unit = "") => {
-        if (target < value) return;
-        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to be less than ${value}${unit}`);
-      },
-      toBeGreaterThan: (value, unit = "") => {
-        if (target > value) return;
-        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to be greater than ${value}${unit}`);
-      },
-      toInclude: (value) => {
-        if (target.indexOf(value) > -1) return;
-        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to include ${value}`);
-      },
-      toMatch: (regex) => {
-        if (target.match(new RegExp(regex))) return;
-        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to match ${regex}`);
-      },
-      toThrow: (message) => {
-        try {
-          target();
-        } catch (error) {
-          if (!message) return;
-          if (error.message === message) return;
-          if (error.message.match(new RegExp(message))) return;
-          throw new Error(`expected ${label ? label + "()" : "function()"} to throw ${message}, but got ${error.message}`);
-        }
-      },
-    };
-  }
-
-  #await() {
-    return new Promise((resolve) => {
-      const timer = () => {
-        if (this.#runningCounter === 0) resolve();
-        else setTimeout(timer, 500);
-      };
-      timer();
-    });
-  }
-}
-
-function processTests(tests) {
-  let passing = 0;
-  let total = 0;
-  let acc = "";
-  let first, last;
-  for (let i = 0, len = tests?.length || 0; i < len; i++) {
-    const { name, status, start, end, result, error } = tests[i];
-    if (!first || start < first) first = start;
-    if (!last || end > last) last = end;
-    if (status === "pass") {
-      acc += `  ${COLORS.GREEN}✔  ${name} ${COLORS.RESET + COLORS.DIM}(${Math.round(end - start)}ms)${COLORS.RESET}\n${typeof result === "string" ? "\t" + COLORS.GREEN + result + COLORS.RESET + "\n" : ""}`;
-      passing++;
-    } else
-      acc += `  ${COLORS.RED}✖  ${name} ${COLORS.RESET + COLORS.DIM}(${Math.round(end - start)}ms)${COLORS.RESET}\n\t${COLORS.RED + error + COLORS.RESET}\n`;
-    total++;
-  }
-  return [acc, passing, total, Math.round(last - first)];
-}
-
-function performance(time = process.hrtime()) {
-  return time[0] * 1000 + time[1] / 1e6;
 }

package/global.d.ts

@@ -1 +1,69 @@
 /// <reference path="@vistta/console" />
+
+interface CliRuntimeData {
+  loaders: any[];
+  resolvers: string[];
+  options: any;
+  port?: any;
+  main?: (...args: any[]) => any;
+}
+
+declare namespace NodeJS {
+  interface Process {
+    argv: string[];
+    env: Record<string, string | undefined>;
+    chdir(directory: string): void;
+    cwd(): string;
+    exit(code?: number): never;
+    on(event: string, listener: (...args: any[]) => void): void;
+    send?(message: any): void;
+    restart?: () => void;
+    vistta: CliRuntimeData;
+  }
+}
+
+declare var vistta: CliRuntimeData;
+declare var loaders: {
+  send: (event: string, ...args: any[]) => void;
+  on: (event: string, callback: (...args: any[]) => void) => void;
+  shared: Record<string, any>;
+};
+declare var main: {
+  send: (event: string, ...args: any[]) => void;
+  on: (event: string, callback: (...args: any[]) => void) => void;
+  shared: Record<string, any>;
+};
+
+declare var suite: {
+  (name: string, callback: () => void, options?: { only?: boolean; skip?: boolean }): void;
+  only(name: string, callback: () => void): void;
+  skip(name: string, callback: () => void): void;
+};
+
+declare var test: {
+  (name: string, callback: () => void, options?: { only?: boolean; skip?: boolean }): void;
+  only(name: string, callback: () => void): void;
+  skip(name: string, callback: () => void): void;
+};
+
+interface ExpectNotMatchers {
+  toEqual(expected: any, unit?: string): void;
+  toBeLessThan(expected: any, unit?: string): void;
+  toBeGreaterThan(expected: any, unit?: string): void;
+  toInclude(expected: any): void;
+  toMatch(expected: string | RegExp): void;
+  toThrow(expected?: any): void;
+}
+
+interface ExpectMatchers {
+  toEqual(expected: any): void;
+  toBeLessThan(expected: any, unit?: string): void;
+  toBeGreaterThan(expected: any, unit?: string): void;
+  toInclude(expected: any): void;
+  toMatch(expected: string | RegExp): void;
+  toThrow(expected?: any): void;
+  not: ExpectNotMatchers;
+}
+
+declare function expect(value: any, label?: string): ExpectMatchers;
+declare function setImmediate(callback: (...args: any[]) => void): any;

package/index.js

@@ -2,6 +2,7 @@ export { Bundler } from "./classes/bundler.js";
 export { Command } from "./classes/command.js";
 export { Loader } from "./classes/loader.js";
 export { Runtime } from "./classes/runtime.js";
+export { TestRunner } from "./classes/test-runner.js";
 export { default as BundleCommand } from "./commands/bundle.js";
 export { default as DefaultCommand } from "./commands/default.js";
 export { default as ProjectCommand } from "./commands/project.js";

package/loaders/bundler.js

@@ -6,7 +6,9 @@ export default class BundlerLoader extends Loader {
   async load(_, { path, ...options }) {
     options.write = false;
     remove(options, "type", "extension");
-    const { code, files, resources, errors, warnings } = await new Bundler(this).run(path, options);
+    if (options.importAttributes?.type === "bundler") delete options.importAttributes.type;
+    const runtime = /** @type {import("../classes/runtime").Runtime} */ (/** @type {unknown} */ (this));
+    const { code, files, resources, errors, warnings } = await new Bundler(runtime).run(path, options);
     return {
       code:
         `export const code = ${JSON.stringify(code)}; ` +

package/loaders/index.js

@@ -8,12 +8,12 @@ export async function initialize({ loaders, resolvers, options, port }) {
     const shared = {};
     const events = {};
     global.main = {
-      send: (event, ...args) => args.port.postMessage(JSON.stringify({ event, args })),
+      send: (event, ...args) => port.postMessage(JSON.stringify({ event, args })),
       on: (event, callback) => (events[event] ? events[event].push(callback) : (events[event] = [callback])),
       shared: new Proxy(shared, {
         set(_, prop, value) {
           port.postMessage(JSON.stringify({ sync: true, prop, value }));
-          return Reflect.set(...arguments);
+          return Reflect.set(shared, prop, value);
         },
       }),
     };

package/main.js

@@ -1 +1 @@
-process.vistta.main();
+process.vistta.main?.();

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@vistta/cli",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "type": "module",
   "main": "index.js",
   "exports": {
     ".": "./index.js",
+    "./global": "./global.d.ts",
     "./config": "./tsconfig.json",
-    "./commands/default": "./commands/default.js",
-    "./commands/bundle": "./commands/bundle.js",
-    "./commands/project": "./commands/project.js",
-    "./commands/test": "./commands/test.js",
+    "./default": "./commands/default.js",
+    "./bundle": "./commands/bundle.js",
+    "./project": "./commands/project.js",
+    "./test": "./commands/test.js",
+    "./test-runner": "./classes/test-runner.js",
     "./loaders/bundler": "./loaders/bundler.js",
     "./loaders/file": "./loaders/file.js",
     "./loaders/json": "./loaders/json.js",
@@ -18,9 +20,6 @@
   "bin": {
     "vistta": "bin.js"
   },
-  "scripts": {
-    "postinstall": ""
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/vistta-org/cli.git"
@@ -32,10 +31,10 @@
     "@vistta/console": "latest",
     "@vistta/fs": "latest",
     "@vistta/utils": "latest",
-    "esbuild": "^0.25.5",
-    "semver": "^7.7.2"
+    "esbuild": "^0.28.2",
+    "semver": "^7.8.5"
   },
   "author": "Tiago Terenas Almeida",
-  "license": "Apache 2.0 with Commons Clause",
+  "license": "GPL-3.0-only",
   "description": "Vistta CLI is a framework for extending the Node.js loader API and building reusable, customizable commands tools"
 }

package/register.js

@@ -1,7 +1,7 @@
 import "@vistta/console/global";
 import { register } from "node:module";
 import { MessageChannel } from "node:worker_threads";
-import { fs, importConfig, saveCrashReport } from "./utils.js";
+import { importConfig, resolve, saveCrashReport } from "./utils.js";
 
 console.clear();
 console.print(`Vistta CLI v${process.env.CLI_VERSION}\n`);
@@ -15,7 +15,7 @@ global.loaders = {
   shared: new Proxy(shared, {
     set(_, prop, value) {
       port1.postMessage(JSON.stringify({ sync: true, prop, value }));
-      return Reflect.set(...arguments);
+      return Reflect.set(shared, prop, value);
     },
   }),
 };
@@ -24,19 +24,20 @@ port1.on("message", (msg) => {
   if (event) events[event]?.forEach((callback) => callback(...args));
   else if (sync) shared[prop] = value;
 });
-port1.unref();
+/** @type {any} */ (port1).unref?.();
 
 const config = await importConfig({
   cli: {
     commands: {
-      default: fs.resolve(import.meta.dirname, "./commands/default.js"),
-      bundle: fs.resolve(import.meta.dirname, "./commands/bundle.js"),
-      project: fs.resolve(import.meta.dirname, "./commands/project.js"),
-      test: fs.resolve(import.meta.dirname, "./commands/test.js"),
+      default: resolve(import.meta.dirname, "./commands/default.js"),
+      bundle: resolve(import.meta.dirname, "./commands/bundle.js"),
+      project: resolve(import.meta.dirname, "./commands/project.js"),
+      test: resolve(import.meta.dirname, "./commands/test.js"),
     },
   },
 });
 const command = new (await import(config.cli.commands[process.argv[2]] || config.cli.commands["default"])).default();
+process.restart = () => process.send({ restart: true });
 process.vistta = {
   loaders: command.loaders,
   resolvers: command.resolvers,

package/tests/bundler.test.js

@@ -0,0 +1,118 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Bundler } from "../classes/bundler.js";
+import { Command } from "../classes/command.js";
+import { Runtime } from "../classes/runtime.js";
+
+suite("Bundler", () => {
+  test("constructor with Runtime stores it as the loader", () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const bundler = new Bundler(runtime);
+    expect(typeof bundler.run).toEqual("function");
+    expect(typeof bundler.import).toEqual("function");
+  });
+
+  test("constructor with Command builds a Runtime from command options", () => {
+    const cmd = new Command();
+    const bundler = new Bundler(cmd);
+    expect(typeof bundler.run).toEqual("function");
+  });
+
+  test("constructor with no argument falls back to process.vistta", () => {
+    process.vistta = { loaders: [], resolvers: [], options: {} };
+    const bundler = new Bundler();
+    expect(typeof bundler.run).toEqual("function");
+  });
+
+  test("constructor throws on invalid argument", () => {
+    let caught;
+    try {
+      new Bundler(123);
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught.message).toMatch("Invalid first argument");
+  });
+
+  test("run() applies defaults from runtime.options.bundler", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "vistta-bundler-"));
+    const entry = join(dir, "entry.js");
+    writeFileSync(entry, "export const greeting = 'hi';\n");
+
+    const runtime = new Runtime({
+      loaders: [],
+      resolvers: ["js"],
+      options: { bundler: { target: "es2020" } },
+    });
+    const bundler = new Bundler(runtime);
+    const { code, errors } = await bundler.run(entry, { write: false, logLevel: "silent" });
+    expect((errors || []).length).toEqual(0);
+    expect(code).toInclude("greeting");
+    expect(code).toInclude("hi");
+  });
+
+  test("run() with exports option rewrites entry to a re-export via @exports namespace", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "vistta-bundler-"));
+    const entry = join(dir, "page.jsx");
+    writeFileSync(entry, "export default function Page() { return null; }\n");
+
+    const runtime = new Runtime({ loaders: [], resolvers: ["jsx"], options: {} });
+    const bundler = new Bundler(runtime);
+    const { code, errors } = await bundler.run(entry, {
+      write: false,
+      logLevel: "silent",
+      exports: "default",
+    });
+    expect((errors || []).length).toEqual(0);
+    expect(code).toInclude("Page");
+  });
+
+  test("run() exposes window namespace defaults and named exports", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "vistta-bundler-"));
+    const entry = join(dir, "entry.js");
+    writeFileSync(
+      entry,
+      'import Files, { Files as NamedFiles } from "@vistta/connect/files";\nimport { equals } from "@vistta/connect/utils";\nexport const getFile = () => Files.get();\nexport const getNamedFile = () => NamedFiles.get();\nexport const compare = (left, right) => equals(left, right);\n',
+    );
+
+    const runtime = new Runtime({ loaders: [], resolvers: ["js"], options: {} });
+    const bundler = new Bundler(runtime);
+    const { code, errors } = await bundler.run(entry, {
+      write: false,
+      logLevel: "silent",
+      format: "cjs",
+      paths: {
+        "@vistta/connect/files": { path: "files", namespace: "window" },
+        "@vistta/connect/utils": { path: "utils", namespace: "window" },
+      },
+    });
+    expect((errors || []).length).toEqual(0);
+
+    const browser = /** @type {any} */ (globalThis);
+    browser.window = {};
+    const module = { exports: {} };
+    new Function("window", "module", "exports", code)(browser.window, module, module.exports);
+    browser.window.files = { default: { get: () => "file" }, Files: { get: () => "named" } };
+    browser.window.utils = { equals: (left, right) => left === right };
+    expect(module.exports.getFile()).toEqual("file");
+    expect(module.exports.getNamedFile()).toEqual("named");
+    expect(module.exports.compare("utils", "utils")).toEqual(true);
+  });
+
+  test("run() throws when source has syntax errors", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "vistta-bundler-"));
+    const entry = join(dir, "entry.js");
+    writeFileSync(entry, "this is not valid javascript !@#$\n");
+
+    const runtime = new Runtime({ loaders: [], resolvers: ["js"], options: {} });
+    const bundler = new Bundler(runtime);
+    let caught;
+    try {
+      await bundler.run(entry, { write: false, logLevel: "silent" });
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught.message).toMatch("Build failed");
+  });
+});

package/tests/loader.test.js

@@ -0,0 +1,23 @@
+import { Loader } from "../classes/loader.js";
+
+suite("Loader", () => {
+  test("base load() throws 'must be implemented'", () => {
+    const loader = new Loader({});
+    expect(() => loader.load("source", {})).toThrow("Method 'load' must be implemented.");
+  });
+
+  test("subclass can override load()", () => {
+    let captured;
+    class Custom extends Loader {
+      load(source, properties) {
+        captured = { source, properties };
+        return { code: "ok" };
+      }
+    }
+    const loader = new Custom({ x: 1 });
+    const result = loader.load("input", { type: "json" });
+    expect(result.code).toEqual("ok");
+    expect(captured.source).toEqual("input");
+    expect(captured.properties.type).toEqual("json");
+  });
+});