@vistta/cli 1.0.1 → 1.2.0

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();
+    if (!process.env.NODE_DEBUG) console.enable();
+    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--;
-  }
-
-  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--;
+    process.exit(failed ? -1 : 0);
   }
-
-  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/config.js

@@ -0,0 +1,128 @@
+import { parse, printParseErrorCode } from "jsonc-parser";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+export function mergeConfig(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (["__proto__", "constructor", "prototype"].includes(key)) continue;
+    result[key] = value && typeof value === "object" && !Array.isArray(value) ? mergeConfig(result[key], value) : value;
+  }
+  return result;
+}
+
+export function loadProjectConfig(directory = process.cwd()) {
+  const file = ["tsconfig.json", "jsconfig.json"].map((name) => resolve(directory, name)).find(existsSync);
+  if (!file) return { file: undefined, config: {}, sources: {} };
+  const active = new Set();
+  const sources = {};
+  function load(filepath) {
+    if (active.has(filepath)) throw new Error(`Circular configuration inheritance: ${filepath}`);
+    active.add(filepath);
+    const errors = [];
+    const own = parse(readFileSync(filepath, "utf8"), errors, { allowTrailingComma: true });
+    if (errors.length) throw new Error(`Invalid configuration ${filepath}: ${printParseErrorCode(errors[0].error)}`);
+    if (!own || typeof own !== "object" || Array.isArray(own))
+      throw new Error(`Expected a configuration object in ${filepath}`);
+    for (const name of ["cli", "cliOptions"]) {
+      if (own[name] !== undefined && (!own[name] || typeof own[name] !== "object" || Array.isArray(own[name])))
+        throw new Error(`${name} must be an object in ${filepath}`);
+    }
+    let inherited = {};
+    for (const parent of own.extends ? (Array.isArray(own.extends) ? own.extends : [own.extends]) : []) {
+      if (typeof parent !== "string") throw new Error(`Expected a string in extends in ${filepath}`);
+      const base = dirname(filepath);
+      let parentFile;
+      if (parent.startsWith(".") || isAbsolute(parent)) {
+        parentFile = resolve(base, parent);
+        if (!existsSync(parentFile) && existsSync(parentFile + ".json")) parentFile += ".json";
+      } else parentFile = createRequire(filepath).resolve(parent);
+      inherited = mergeConfig(inherited, load(parentFile));
+    }
+    const cli = mergeConfig(own.cliOptions, own.cli || {});
+    if (cli.commands !== undefined && (!cli.commands || typeof cli.commands !== "object" || Array.isArray(cli.commands)))
+      throw new Error(`cli.commands must be an object in ${filepath}`);
+    for (const [name, value] of Object.entries(cli.commands || {})) {
+      if (typeof value !== "string") throw new Error(`Expected a module path for cli.commands.${name} in ${filepath}`);
+      cli.commands[name] =
+        value.startsWith(".") || isAbsolute(value)
+          ? pathToFileURL(resolve(dirname(filepath), value)).href
+          : pathToFileURL(createRequire(filepath).resolve(value)).href;
+    }
+    for (const section of ["lint", "format"]) {
+      if (cli[section]?.config !== undefined && typeof cli[section].config !== "string")
+        throw new Error(`cli.${section}.config must be a module path in ${filepath}`);
+      if (typeof cli[section]?.config === "string") {
+        const value = cli[section].config;
+        cli[section].config =
+          value.startsWith(".") || isAbsolute(value)
+            ? pathToFileURL(resolve(dirname(filepath), value)).href
+            : pathToFileURL(createRequire(filepath).resolve(value)).href;
+      }
+    }
+    const normalized = { ...own, cli };
+    delete normalized.extends;
+    delete normalized.cliOptions;
+    function record(value, prefix = "") {
+      for (const [key, entry] of Object.entries(value)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (entry && typeof entry === "object" && !Array.isArray(entry)) record(entry, path);
+        else sources[path] = filepath;
+      }
+    }
+    record(normalized);
+    active.delete(filepath);
+    return mergeConfig(inherited, normalized);
+  }
+  const config = load(file);
+  function stringList(value, path) {
+    if (value !== undefined && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")))
+      throw new Error(`${path} must be an array of strings in ${file}`);
+  }
+  for (const name of ["include", "exclude", "files"]) stringList(config[name], name);
+  for (const section of ["check", "lint", "format", "tasks"]) {
+    const value = config.cli?.[section];
+    if (value !== undefined && (!value || typeof value !== "object" || Array.isArray(value)))
+      throw new Error(`cli.${section} must be an object in ${file}`);
+  }
+  for (const [name, value] of Object.entries(config.cli?.check || {})) {
+    if (!["format", "lint", "types"].includes(name) || typeof value !== "boolean")
+      throw new Error(`cli.check.${name} must be a boolean check named format, lint, or types`);
+  }
+  for (const section of ["lint", "format"]) {
+    const options = config.cli?.[section] || {};
+    const engine = options.engine;
+    const expected = section === "lint" ? "eslint" : "prettier";
+    if (engine !== undefined && engine !== expected) throw new Error(`cli.${section}.engine must be "${expected}"`);
+    for (const name of ["include", "exclude"]) stringList(options[name], `cli.${section}.${name}`);
+    for (const name of section === "lint" ? ["rules", "languageOptions", "options"] : ["options"]) {
+      const value = options[name];
+      if (value !== undefined && (!value || typeof value !== "object" || Array.isArray(value)))
+        throw new Error(`cli.${section}.${name} must be an object in ${file}`);
+    }
+    for (const name of Object.keys(options)) {
+      if (
+        ![
+          "engine",
+          "include",
+          "exclude",
+          "options",
+          "config",
+          ...(section === "lint" ? ["rules", "languageOptions"] : []),
+        ].includes(name)
+      )
+        throw new Error(`Unknown setting cli.${section}.${name} in ${file}`);
+    }
+  }
+  for (const [name, task] of Object.entries(config.cli?.tasks || {})) {
+    if (!task || typeof task !== "object" || Array.isArray(task)) throw new Error(`cli.tasks.${name} must be an object`);
+    stringList(task.dependsOn, `cli.tasks.${name}.dependsOn`);
+    if (task.script !== undefined && typeof task.script !== "string")
+      throw new Error(`cli.tasks.${name}.script must be a package script name`);
+    for (const key of Object.keys(task))
+      if (!["dependsOn", "script"].includes(key)) throw new Error(`Unknown setting cli.tasks.${name}.${key}`);
+  }
+  return { file, config, sources };
+}

package/config.schema.json

@@ -0,0 +1,150 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "VISTTA project configuration",
+  "description": "VISTTA settings in tsconfig.json or jsconfig.json. Other TypeScript and framework properties are preserved.",
+  "type": "object",
+  "properties": {
+    "extends": {
+      "description": "Relative or package presets, applied from left to right before local settings.",
+      "oneOf": [
+        {
+          "type": "string"
+        },
+        {
+          "$ref": "#/definitions/stringList"
+        }
+      ]
+    },
+    "compilerOptions": {
+      "type": "object",
+      "description": "Compiler options used unchanged by TypeScript, with noEmit enabled for checks."
+    },
+    "include": {
+      "$ref": "#/definitions/stringList"
+    },
+    "exclude": {
+      "$ref": "#/definitions/stringList"
+    },
+    "files": {
+      "$ref": "#/definitions/stringList"
+    },
+    "cli": {
+      "$ref": "#/definitions/cli"
+    },
+    "cliOptions": {
+      "$ref": "#/definitions/cli",
+      "description": "Legacy alias. The cli block takes precedence."
+    },
+    "bundlerOptions": {
+      "type": "object"
+    }
+  },
+  "definitions": {
+    "stringList": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "cli": {
+      "type": "object",
+      "properties": {
+        "commands": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "check": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "format": {
+              "type": "boolean",
+              "default": true
+            },
+            "lint": {
+              "type": "boolean",
+              "default": true
+            },
+            "types": {
+              "type": "boolean",
+              "default": true
+            }
+          }
+        },
+        "format": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "engine": {
+              "const": "prettier",
+              "default": "prettier"
+            },
+            "options": {
+              "type": "object",
+              "description": "Prettier options overriding any discovered or referenced configuration."
+            },
+            "config": {
+              "type": "string",
+              "description": "Optional module exporting Prettier options as its default export."
+            },
+            "include": {
+              "$ref": "#/definitions/stringList"
+            },
+            "exclude": {
+              "$ref": "#/definitions/stringList"
+            }
+          }
+        },
+        "lint": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "engine": {
+              "const": "eslint",
+              "default": "eslint"
+            },
+            "rules": {
+              "type": "object",
+              "description": "ESLint rules applied after the existing or referenced flat config."
+            },
+            "languageOptions": {
+              "type": "object"
+            },
+            "options": {
+              "type": "object",
+              "description": "Additional JSON-compatible ESLint flat-config properties, such as settings or files."
+            },
+            "config": {
+              "type": "string",
+              "description": "Optional module exporting an ESLint flat config or array. Replaces config-file discovery."
+            },
+            "include": {
+              "$ref": "#/definitions/stringList"
+            },
+            "exclude": {
+              "$ref": "#/definitions/stringList"
+            }
+          }
+        },
+        "tasks": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "dependsOn": {
+                "$ref": "#/definitions/stringList"
+              },
+              "script": {
+                "type": "string",
+                "description": "A script name from the current package.json. Dependencies run first."
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

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,8 +2,12 @@ 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";
+export { default as QualityCommand } from "./commands/quality.js";
+export { default as TaskCommand } from "./commands/task.js";
 export { default as TestCommand } from "./commands/test.js";
+export { loadProjectConfig } from "./config.js";
 export { parseArgs } from "./utils.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?.();