hereby 1.0.2 → 1.0.5

package/README.md

@@ -1,6 +1,8 @@
 # hereby
 
-[![npm version](https://badge.fury.io/js/hereby.svg)](https://badge.fury.io/js/hereby)
+[![npm](https://img.shields.io/npm/v/hereby.svg)](https://npmjs.com/package/hereby)
+[![node](https://img.shields.io/node/v/hereby.svg)](https://nodejs.org)
+[![install size](https://packagephobia.com/badge?p=hereby)](https://packagephobia.com/result?p=hereby)
 [![ci](https://github.com/jakebailey/hereby/actions/workflows/ci.yml/badge.svg)](https://github.com/jakebailey/hereby/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/jakebailey/hereby/branch/main/graph/badge.svg?token=YL2Z1uk5dh)](https://codecov.io/gh/jakebailey/hereby)
 
@@ -8,7 +10,10 @@
 
 # Herebyfile.mjs
 
-Tasks are defined in `Herebyfile.mjs`, like:
+Tasks are defined in `Herebyfile.mjs`. Exported tasks are available to run
+at the CLI, with support for `export default`.
+
+For example:
 
 ```js
 import { execa } from "execa";

package/dist/cli/index.js

@@ -4,71 +4,72 @@ 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.`);
+                throw new UserError(`Task "${name}" does not exist or is not exported in the Herebyfile.`);
             }
             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,8 +1,7 @@
 import chalk from "chalk";
-import foregroundChild from "foreground-child";
-import { resolve } from "import-meta-resolve";
 import { fileURLToPath, pathToFileURL } from "url";
-export async function reexec(system, herebyfilePath) {
+import { UserError } from "./utils.js";
+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
@@ -15,17 +14,23 @@ export async function reexec(system, herebyfilePath) {
     // TODO: Rather than spawning a child process, perhaps we could instead
     // import the CLI from the other version and run it.
     const thisCLI = await resolveToPath("hereby/cli", new URL(import.meta.url));
-    const otherCLI = await resolveToPath("hereby/cli", pathToFileURL(herebyfilePath));
+    let otherCLI;
+    try {
+        otherCLI = await resolveToPath("hereby/cli", pathToFileURL(herebyfilePath));
+    }
+    catch {
+        throw new UserError("Unable to find hereby; ensure hereby is installed in your package.");
+    }
     if (thisCLI === otherCLI) {
         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) {
+/* eslint-disable no-restricted-globals */
+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");
     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

@@ -3,6 +3,28 @@
  */
 export class Task {
     constructor(options) {
+        // Runtime typecheck; consumers of hereby may not have enabled
+        // typechecking, so this is helpful.
+        if (typeof options.name !== "string") {
+            throw new Error("Task name is not a string.");
+        }
+        if (typeof options.description !== "string" && typeof options.description !== "undefined") {
+            throw new Error("Task description is not a string or undefined.");
+        }
+        if (!Array.isArray(options.dependencies) && typeof options.dependencies !== "undefined") {
+            throw new Error("Task dependencies is not an array or undefined.");
+        }
+        if (options.dependencies) {
+            for (const dep of options.dependencies) {
+                if (!(dep instanceof Task)) {
+                    throw new Error("Task dependency is not a task.");
+                }
+            }
+        }
+        if (typeof options.run !== "function" && typeof options.run !== "undefined") {
+            throw new Error("Task run is not a function or undefined.");
+        }
+        // Non-type checks.
         if (!options.name) {
             throw new Error("Task name must not be empty.");
         }
@@ -12,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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hereby",
-    "version": "1.0.2",
+    "version": "1.0.5",
     "description": "A simple task runner",
     "repository": "github:jakebailey/hereby",
     "type": "module",
@@ -35,8 +35,7 @@
         "LICENSE",
         "./dist/**/*.js",
         "!**/__tests__/**",
-        "./dist/index.d.ts",
-        "!./dist/testUtils.js"
+        "./dist/index.d.ts"
     ],
     "dependencies": {
         "chalk": "^5.0.1",
@@ -57,12 +56,10 @@
         "@typescript-eslint/parser": "^5.33.1",
         "ava": "^4.3.1",
         "c8": "^7.12.0",
-        "cross-env": "^7.0.3",
         "eslint": "^8.22.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",
         "execa": "^6.1.0",
         "moq.ts": "^9.0.2",
         "prettier": "^2.7.1",
@@ -91,8 +88,6 @@
             "compile": false
         },
         "environmentVariables": {
-            "NODE_OPTIONS": "--loader=esmock",
-            "NODE_NO_WARNINGS": "1",
             "FORCE_COLOR": "0"
         }
     },