hereby 1.0.3 → 1.0.6

package/dist/cli/index.js

@@ -1,74 +1,81 @@
 import chalk from "chalk";
+import { closest, distance } from "fastest-levenshtein";
 import path from "path";
 import { formatTasks } from "./formatTasks.js";
 import { findHerebyfile, loadHerebyfile } from "./loadHerebyfile.js";
 import { getUsage, parseArgs } from "./parseArgs.js";
 import { reexec } from "./reexec.js";
-import { runTasksWithCLIRunner } from "./runner.js";
+import { CLIRunner } from "./runner.js";
 import { ExitCodeError, simplifyPath, UserError } from "./utils.js";
-export async function main(system) {
+export async function main(d) {
     try {
-        await mainWorker(system);
+        await mainWorker(d);
     }
     catch (e) {
         if (e instanceof ExitCodeError) {
-            system.process.exitCode = e.exitCode;
+            d.setExitCode(e.exitCode);
         }
         else if (e instanceof UserError) {
-            system.error(`${chalk.red("Error")}: ${e.message}`);
-            system.process.exitCode = 1;
+            d.error(`${chalk.red("Error")}: ${e.message}`);
+            d.setExitCode(1);
         }
         else {
             throw e;
         }
     }
 }
-async function mainWorker(system) {
-    const args = parseArgs(system.process.argv.slice(2));
+async function mainWorker(d) {
+    const args = parseArgs(d.argv.slice(2));
     if (args.help) {
-        system.log(getUsage());
+        d.log(getUsage());
         return;
     }
-    let herebyfilePath = args.herebyfile ?? (await findHerebyfile(system.process.cwd()));
-    herebyfilePath = path.resolve(system.process.cwd(), herebyfilePath);
-    if (await reexec(system, herebyfilePath)) {
+    let herebyfilePath = args.herebyfile ?? (await findHerebyfile(d.cwd()));
+    herebyfilePath = path.resolve(d.cwd(), herebyfilePath);
+    if (await reexec(d, herebyfilePath)) {
         return;
     }
-    system.process.chdir(path.dirname(herebyfilePath));
+    d.chdir(path.dirname(herebyfilePath));
+    d.log(`Using ${simplifyPath(herebyfilePath)}`);
     const herebyfile = await loadHerebyfile(herebyfilePath);
     if (args.printTasks) {
-        system.log(formatTasks(herebyfile.tasks, herebyfile.defaultTask));
+        d.log(formatTasks(herebyfile.tasks, herebyfile.defaultTask));
         return;
     }
+    const tasks = selectTasks(herebyfile, args.run);
+    try {
+        const runner = new CLIRunner(d);
+        await runner.runTasks(...tasks);
+    }
+    catch (e) {
+        // We will have already printed some message here.
+        // Set the error code and let the process run to completion,
+        // so we don't end up with an unflushed output.
+        throw new ExitCodeError(1, e);
+    }
+}
+export function selectTasks(herebyfile, taskNames) {
     const allTasks = new Map();
     for (const task of herebyfile.tasks) {
         allTasks.set(task.options.name, task);
     }
-    let tasks;
-    if (args.run && args.run.length > 0) {
-        tasks = args.run.map((name) => {
+    if (taskNames && taskNames.length > 0) {
+        return taskNames.map((name) => {
             const task = allTasks.get(name);
             if (!task) {
-                throw new UserError(`Task ${name} does not exist or is not exported in the Herebyfile.`);
+                let message = `Task "${name}" does not exist or is not exported in the Herebyfile.`;
+                const candidate = closest(name, Array.from(allTasks.keys()));
+                if (distance(name, candidate) < name.length * 0.4) {
+                    message += ` Did you mean "${candidate}?"`;
+                }
+                throw new UserError(message);
             }
             return task;
         });
     }
-    else {
-        if (!herebyfile.defaultTask) {
-            throw new UserError("No default task defined; please specify a task name.");
-        }
-        tasks = [herebyfile.defaultTask];
-    }
-    system.log(`Using ${simplifyPath(herebyfilePath)}`);
-    try {
-        await runTasksWithCLIRunner(system, ...tasks);
-    }
-    catch {
-        // We will have already printed some message here.
-        // Set the error code and let the process run to completion,
-        // so we don't end up with an unflushed output.
-        throw new ExitCodeError(1);
+    if (!herebyfile.defaultTask) {
+        throw new UserError("No default task defined; please specify a task name.");
     }
+    return [herebyfile.defaultTask];
 }
 //# sourceMappingURL=index.js.map

package/dist/cli/reexec.js

@@ -1,9 +1,7 @@
 import chalk from "chalk";
-import foregroundChild from "foreground-child";
-import { resolve } from "import-meta-resolve";
 import { fileURLToPath, pathToFileURL } from "url";
 import { UserError } from "./utils.js";
-export async function reexec(system, herebyfilePath) {
+export async function reexec(d, herebyfilePath) {
     // If hereby is installed globally, but run against a Herebyfile in some
     // other package, that Herebyfile's import will resolve to a different
     // installation of the hereby package. There's no guarantee that the two
@@ -27,12 +25,12 @@ export async function reexec(system, herebyfilePath) {
         return false;
     }
     // TODO: If this turns out to be common, remove this warning.
-    system.error(`${chalk.yellow("Warning")}: re-running hereby as imported by the Herebyfile.`);
-    const args = [...system.process.execArgv, otherCLI, ...system.process.argv.slice(2)];
-    foregroundChild(system.process.execPath, args);
+    d.error(`${chalk.yellow("Warning")}: re-running hereby as imported by the Herebyfile.`);
+    const args = [...d.execArgv, otherCLI, ...d.argv.slice(2)];
+    d.foregroundChild(d.execPath, args);
     return true;
-}
-async function resolveToPath(specifier, url) {
-    return fileURLToPath(new URL(await resolve(specifier, url.toString())));
+    async function resolveToPath(specifier, url) {
+        return fileURLToPath(new URL(await d.resolve(specifier, url.toString())));
+    }
 }
 //# sourceMappingURL=reexec.js.map

package/dist/cli/runner.js

@@ -1,38 +1,33 @@
 import assert from "assert";
 import chalk from "chalk";
-import prettyMilliseconds from "pretty-ms";
 import { Runner } from "../runner.js";
-export function runTasksWithCLIRunner(system, ...tasks) {
-    return new CLIRunner({ system, concurrency: system.numCPUs }).runTasks(...tasks);
-}
-class CLIRunner extends Runner {
-    constructor(options) {
-        super(options);
+export class CLIRunner extends Runner {
+    constructor(d) {
+        super({ concurrency: d.numCPUs });
         this._errored = false;
         this._startTimes = new WeakMap();
-        this._system = options.system;
+        this._d = d;
     }
     onTaskStart(task) {
         this._startTimes.set(task, Date.now());
         if (this._errored) {
             return; // Skip logging.
         }
-        this._system.log(`Starting ${chalk.blue(task.options.name)}`);
+        this._d.log(`Starting ${chalk.blue(task.options.name)}`);
     }
     onTaskFinish(task) {
         if (this._errored) {
             return; // Skip logging.
         }
         const took = Date.now() - checkDefined(this._startTimes.get(task));
-        this._system.log(`Finished ${chalk.green(task.options.name)} in ${prettyMilliseconds(took)}`);
+        this._d.log(`Finished ${chalk.green(task.options.name)} in ${this._d.prettyMilliseconds(took)}`);
     }
     onTaskError(task, e) {
         if (this._errored) {
             return; // Skip logging.
         }
         this._errored = true;
-        this._system.error(`Error in ${chalk.red(task.options.name)}`);
-        this._system.error(`${e}`);
+        this._d.error(`Error in ${chalk.red(task.options.name)}\n${e}`);
     }
 }
 function checkDefined(value) {

package/dist/cli/utils.js

@@ -31,20 +31,34 @@ export class UserError extends Error {
  * without logging anything.
  */
 export class ExitCodeError {
-    constructor(exitCode) {
+    constructor(exitCode, reason) {
         this.exitCode = exitCode;
+        this.reason = reason;
     }
 }
-export function createSystem(process) {
+export async function real() {
+    const { default: foregroundChild } = await import("foreground-child");
+    const { resolve } = await import("import-meta-resolve");
+    const { default: prettyMilliseconds } = await import("pretty-ms");
+    /* eslint-disable no-restricted-globals */
     return {
-        log(message) {
-            process.stdout.write(message + "\n");
+        log: console.log,
+        error: console.error,
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        cwd: process.cwd,
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        chdir: process.chdir,
+        argv: process.argv,
+        execArgv: process.execArgv,
+        execPath: process.execPath,
+        setExitCode: (code) => {
+            process.exitCode = code;
         },
-        error(message) {
-            process.stderr.write(message + "\n");
-        },
-        process,
         numCPUs: os.cpus().length,
+        foregroundChild,
+        resolve,
+        prettyMilliseconds,
     };
+    /* eslint-enable no-restricted-globals */
 }
 //# sourceMappingURL=utils.js.map

package/dist/cli.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import { main } from "./cli/index.js";
-import { createSystem } from "./cli/utils.js";
-// eslint-disable-next-line no-restricted-globals
-await main(createSystem(process));
+import { real } from "./cli/utils.js";
+await main(await real());
 //# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -24,6 +24,7 @@ export interface TaskOptions {
  * A hereby Task. To get an instance, call `test`.
  */
 export declare class Task {
+    private _options;
     private constructor();
 }
 /**

package/dist/index.js

@@ -34,7 +34,11 @@ export class Task {
         if (!options.dependencies?.length && !options.run) {
             throw new Error("Task must have at run function or dependencies.");
         }
-        this.options = options;
+        this._options = options;
+    }
+    /* @internal */
+    get options() {
+        return this._options;
     }
     /* @internal */
     static create(options) {

package/dist/runner.js

@@ -1,8 +1,12 @@
-import PQueue from "p-queue";
+import pLimit from "p-limit";
 export class Runner {
     constructor(options) {
         this._addedTasks = new WeakMap();
-        this._queue = new PQueue({ concurrency: options?.concurrency ?? Infinity });
+        this._limiter = (fn) => fn();
+        const concurrency = options?.concurrency;
+        if (concurrency !== undefined) {
+            this._limiter = pLimit(concurrency);
+        }
     }
     async runTasks(...tasks) {
         await Promise.all(tasks.map((task) => {
@@ -24,7 +28,7 @@ export class Runner {
         if (!run) {
             return;
         }
-        return this._queue.add(async () => {
+        return this._limiter(async () => {
             try {
                 this.onTaskStart?.(task);
                 await run();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hereby",
-    "version": "1.0.3",
+    "version": "1.0.6",
     "description": "A simple task runner",
     "repository": "github:jakebailey/hereby",
     "type": "module",
@@ -35,16 +35,16 @@
         "LICENSE",
         "./dist/**/*.js",
         "!**/__tests__/**",
-        "./dist/index.d.ts",
-        "!./dist/testUtils.js"
+        "./dist/index.d.ts"
     ],
     "dependencies": {
         "chalk": "^5.0.1",
         "command-line-args": "^5.2.1",
         "command-line-usage": "^6.1.3",
+        "fastest-levenshtein": "^1.0.16",
         "foreground-child": "^2.0.0",
         "import-meta-resolve": "^2.1.0",
-        "p-queue": "^7.3.0",
+        "p-limit": "^4.0.0",
         "pretty-ms": "^8.0.0"
     },
     "devDependencies": {
@@ -52,24 +52,22 @@
         "@tsconfig/node14": "^1.0.3",
         "@types/command-line-args": "^5.2.0",
         "@types/command-line-usage": "^5.0.2",
-        "@types/node": "^14.18.24",
-        "@typescript-eslint/eslint-plugin": "^5.33.1",
-        "@typescript-eslint/parser": "^5.33.1",
-        "ava": "^4.3.1",
+        "@types/node": "^14.18.28",
+        "@typescript-eslint/eslint-plugin": "^5.36.2",
+        "@typescript-eslint/parser": "^5.36.2",
+        "ava": "^4.3.3",
         "c8": "^7.12.0",
-        "cross-env": "^7.0.3",
-        "eslint": "^8.22.0",
+        "eslint": "^8.23.0",
         "eslint-config-prettier": "^8.5.0",
         "eslint-plugin-ava": "^13.2.0",
-        "eslint-plugin-simple-import-sort": "^7.0.0",
-        "esmock": "^1.9.4",
+        "eslint-plugin-simple-import-sort": "^8.0.0",
         "execa": "^6.1.0",
         "moq.ts": "^9.0.2",
         "prettier": "^2.7.1",
-        "release-it": "^15.3.0",
+        "release-it": "^15.4.1",
         "rimraf": "^3.0.2",
         "tempy": "^3.0.0",
-        "typescript": "^4.7.4"
+        "typescript": "~4.8.3"
     },
     "packageManager": "npm@8.17.0",
     "volta": {
@@ -91,8 +89,6 @@
             "compile": false
         },
         "environmentVariables": {
-            "NODE_OPTIONS": "--loader=esmock",
-            "NODE_NO_WARNINGS": "1",
             "FORCE_COLOR": "0"
         }
     },