hereby 1.6.3 → 1.7.0

package/README.md

@@ -3,7 +3,7 @@
 [![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)
-![tokei](https://img.shields.io/tokei/lines/github/jakebailey/hereby.svg)
+[![tokei](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/jakebailey/hereby/gh-pages/tokei.json)](https://github.com/XAMPPRocky/tokei)
 [![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)
 
@@ -108,7 +108,7 @@ well.
 `hereby` does not support running tasks in series; specifying multiple tasks at
 the CLI or as dependencies of another task will run them in parallel. This
 matches the behavior of tools like `make`, which like `hereby` intend to encode
-a dedpendency graph of tasks, not act as a script.
+a dependency graph of tasks, not act as a script.
 
 In general, if you're trying to emulate a serial task, you will likely be better
 served by writing out explicit dependencies for your tasks.

package/dist/cli/formatTasks.js

@@ -1,5 +1,5 @@
-import chalk from "chalk";
 import commandLineUsage from "command-line-usage";
+import pc from "picocolors";
 import { stringSorter, taskSorter } from "./utils.js";
 export function formatTasks(format, tasks, defaultTask) {
     tasks = tasks
@@ -15,8 +15,8 @@ export function formatTasks(format, tasks, defaultTask) {
         content: tasks.map((task) => {
             var _a;
             const name = task !== defaultTask
-                ? chalk.blue(task.options.name)
-                : `${chalk.green(task.options.name)} (default)`;
+                ? pc.blue(task.options.name)
+                : `${pc.green(task.options.name)} (default)`;
             const descriptionParts = [];
             if (task.options.description) {
                 descriptionParts.push(task.options.description);
@@ -26,7 +26,7 @@ export function formatTasks(format, tasks, defaultTask) {
                 const depNames = deps
                     .map((task) => task.options.name)
                     .sort(stringSorter)
-                    .map((v) => chalk.blue(v));
+                    .map((v) => pc.blue(v));
                 descriptionParts.push(`Depends on: ${depNames.join(", ")}`);
             }
             return { name, description: descriptionParts.join("\n") };

package/dist/cli/index.js

@@ -1,6 +1,5 @@
-import chalk from "chalk";
-import { closest, distance } from "fastest-levenshtein";
 import path from "path";
+import pc from "picocolors";
 import { formatTasks } from "./formatTasks.js";
 import { findHerebyfile, loadHerebyfile } from "./loadHerebyfile.js";
 import { getUsage, parseArgs } from "./parseArgs.js";
@@ -16,7 +15,7 @@ export async function main(d) {
             d.setExitCode(e.exitCode);
         }
         else if (e instanceof UserError) {
-            d.error(`${chalk.red("Error")}: ${e.message}`);
+            d.error(`${pc.red("Error")}: ${e.message}`);
             d.setExitCode(1);
         }
         else {
@@ -37,7 +36,7 @@ async function mainWorker(d) {
         return;
     }
     if (args.version) {
-        d.log(`hereby ${d.version}`);
+        d.log(`hereby ${await d.version()}`);
         return;
     }
     d.chdir(path.dirname(herebyfilePath));
@@ -46,9 +45,9 @@ async function mainWorker(d) {
         d.log(formatTasks(args.printTasks, herebyfile.tasks, herebyfile.defaultTask));
         return;
     }
-    const tasks = selectTasks(d, herebyfile, herebyfilePath, args.run);
-    const taskNames = tasks.map((t) => t.options.name).sort().map((name) => chalk.blue(name)).join(", ");
-    d.log(`Using ${chalk.yellow(d.simplifyPath(herebyfilePath))} to run ${taskNames}`);
+    const tasks = await selectTasks(d, herebyfile, herebyfilePath, args.run);
+    const taskNames = tasks.map((t) => t.options.name).sort().map((name) => pc.blue(name)).join(", ");
+    d.log(`Using ${pc.yellow(d.simplifyPath(herebyfilePath))} to run ${taskNames}`);
     const start = Date.now();
     let errored = false;
     try {
@@ -64,28 +63,31 @@ async function mainWorker(d) {
     }
     finally {
         const took = Date.now() - start;
-        d.log(`Completed ${taskNames}${errored ? chalk.red(" with errors") : ""} in ${d.prettyMilliseconds(took)}`);
+        d.log(`Completed ${taskNames}${errored ? pc.red(" with errors") : ""} in ${d.prettyMilliseconds(took)}`);
     }
 }
 // Exported for testing.
-export function selectTasks(d, herebyfile, herebyfilePath, taskNames) {
+export async function selectTasks(d, herebyfile, herebyfilePath, taskNames) {
     const allTasks = new Map();
     for (const task of herebyfile.tasks) {
         allTasks.set(task.options.name, task);
     }
     if (taskNames && taskNames.length > 0) {
-        return taskNames.map((name) => {
+        const tasks = [];
+        for (const name of taskNames) {
             const task = allTasks.get(name);
             if (!task) {
                 let message = `Task "${name}" does not exist or is not exported from ${d.simplifyPath(herebyfilePath)}.`;
+                const { closest, distance } = await import("fastest-levenshtein");
                 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;
-        });
+            tasks.push(task);
+        }
+        return tasks;
     }
     if (!herebyfile.defaultTask) {
         throw new UserError(`No default task has been exported from ${d.simplifyPath(herebyfilePath)}; please specify a task name.`);

package/dist/cli/loadHerebyfile.js

@@ -1,6 +1,6 @@
-import chalk from "chalk";
-import { promises as fs } from "fs";
+import fs from "fs";
 import path from "path";
+import pc from "picocolors";
 import { pathToFileURL } from "url";
 import { Task } from "../index.js";
 import { UserError } from "./utils.js";
@@ -10,14 +10,14 @@ const allFilenames = new Set(extensions.map((e) => filenames.map((f) => `${f}.${
 export async function findHerebyfile(dir) {
     const root = path.parse(dir).root;
     for (; dir !== root; dir = path.dirname(dir)) {
-        const entries = await fs.readdir(dir);
+        const entries = await fs.promises.readdir(dir);
         const matching = entries.filter((e) => allFilenames.has(e));
         if (matching.length > 1) {
             throw new UserError(`Found more than one Herebyfile: ${matching.join(", ")}`);
         }
         if (matching.length === 1) {
             const candidate = path.join(dir, matching[0]);
-            const stat = await fs.stat(candidate);
+            const stat = await fs.promises.stat(candidate);
             if (!stat.isFile()) {
                 throw new UserError(`${matching[0]} is not a file.`);
             }
@@ -39,7 +39,7 @@ export async function loadHerebyfile(herebyfilePath) {
                 defaultTask = value;
             }
             else if (exportedTasks.has(value)) {
-                throw new UserError(`Task "${chalk.blue(value.options.name)}" has been exported twice.`);
+                throw new UserError(`Task "${pc.blue(value.options.name)}" has been exported twice.`);
             }
             else {
                 exportedTasks.add(value);
@@ -72,11 +72,11 @@ function checkTaskInvariants(tasks) {
                 continue;
             }
             if (taskStack.has(task)) {
-                throw new UserError(`Task "${chalk.blue(task.options.name)}" references itself.`);
+                throw new UserError(`Task "${pc.blue(task.options.name)}" references itself.`);
             }
             const name = task.options.name;
             if (seenNames.has(name)) {
-                throw new UserError(`Task "${chalk.blue(name)}" was declared twice.`);
+                throw new UserError(`Task "${pc.blue(name)}" was declared twice.`);
             }
             seenNames.add(name);
             if (task.options.dependencies) {

package/dist/cli/reexec.js

@@ -1,17 +1,20 @@
-import { fileURLToPath, pathToFileURL } from "url";
+import { pathToFileURL } from "url";
 import { UserError } from "./utils.js";
+const cliExportName = "hereby/cli";
+/**
+ * Checks to see if we need to re-exec another version of hereby.
+ * If this function returns true, the caller should return immediately
+ * and do no further work.
+ */
 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
-    // are compatible (in fact, are guaranteed not to be as Task is a class).
+    // are compatible (in fact, they are guaranteed not to as Task is a class).
     //
     // Rather than trying to fix this by messing around with Node's resolution
     // (which won't work in ESM anyway), instead opt to figure out the location
-    // of hereby as imported by the Herebyfile, and fork to execute it instead.
-    //
-    // TODO: Rather than spawning a child process, perhaps we could instead
-    // import the CLI from the other version and run it.
+    // of hereby as imported by the Herebyfile, and then "reexec" it by importing.
     if (d.isPnP) {
         // When we are running within PnP, we can't really figure out what to
         // do. import-meta-resolve doesn't implement this, so we can't do
@@ -21,10 +24,10 @@ export async function reexec(d, herebyfilePath) {
         // a mismatch.
         return false;
     }
-    const thisCLI = await resolveToPath("hereby/cli", new URL(import.meta.url));
+    const thisCLI = await d.resolve(cliExportName, import.meta.url);
     let otherCLI;
     try {
-        otherCLI = await resolveToPath("hereby/cli", pathToFileURL(herebyfilePath));
+        otherCLI = await d.resolve(cliExportName, pathToFileURL(herebyfilePath).toString());
     }
     catch {
         throw new UserError("Unable to find hereby; ensure hereby is installed in your package.");
@@ -32,11 +35,7 @@ export async function reexec(d, herebyfilePath) {
     if (thisCLI === otherCLI) {
         return false;
     }
-    const args = [...d.execArgv, otherCLI, ...d.argv.slice(2)];
-    d.foregroundChild(d.execPath, args);
+    await import(otherCLI);
     return true;
-    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,5 +1,5 @@
 import assert from "assert";
-import chalk from "chalk";
+import pc from "picocolors";
 export class Runner {
     constructor(d) {
         this._addedTasks = new WeakMap();
@@ -49,14 +49,14 @@ export class Runner {
         if (this._errored) {
             return; // Skip logging.
         }
-        this._d.log(`Starting ${chalk.blue(task.options.name)}`);
+        this._d.log(`Starting ${pc.blue(task.options.name)}`);
     }
     onTaskFinish(task) {
         if (this._errored) {
             return; // Skip logging.
         }
         const took = Date.now() - checkDefined(this._startTimes.get(task));
-        this._d.log(`Finished ${chalk.green(task.options.name)} in ${this._d.prettyMilliseconds(took)}`);
+        this._d.log(`Finished ${pc.green(task.options.name)} in ${this._d.prettyMilliseconds(took)}`);
     }
     onTaskError(task, e) {
         if (this._errored) {
@@ -64,7 +64,7 @@ export class Runner {
         }
         this._errored = true;
         const took = Date.now() - checkDefined(this._startTimes.get(task));
-        this._d.error(`Error in ${chalk.red(task.options.name)} in ${this._d.prettyMilliseconds(took)}\n${e}`);
+        this._d.error(`Error in ${pc.red(task.options.name)} in ${this._d.prettyMilliseconds(took)}\n${e}`);
     }
 }
 function checkDefined(value) {

package/dist/cli/utils.js

@@ -1,4 +1,4 @@
-import { promises as fs } from "fs";
+import fs from "fs";
 import os from "os";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -40,12 +40,8 @@ export class ExitCodeError {
     }
 }
 export async function real() {
-    const { default: foregroundChild } = await import("foreground-child");
-    const { resolve } = await import("import-meta-resolve");
+    const importResolve = memoize(async () => (await import("import-meta-resolve")).resolve);
     const { default: prettyMilliseconds } = await import("pretty-ms");
-    const packageJsonPath = fileURLToPath(await resolve("hereby/package.json", import.meta.url));
-    const packageJson = await fs.readFile(packageJsonPath, "utf-8");
-    const { version } = JSON.parse(packageJson);
     /* eslint-disable no-restricted-globals */
     return {
         log: console.log,
@@ -56,17 +52,28 @@ export async function real() {
         chdir: process.chdir,
         simplifyPath,
         argv: process.argv,
-        execArgv: process.execArgv,
-        execPath: process.execPath,
         setExitCode: (code) => {
             process.exitCode = code;
         },
-        version,
+        version: async () => {
+            // Not bothering to memoize this function; it will only be called once.
+            const resolve = await importResolve();
+            const packageJsonPath = fileURLToPath(await resolve("hereby/package.json", import.meta.url));
+            const packageJson = await fs.promises.readFile(packageJsonPath, "utf-8");
+            const { version } = JSON.parse(packageJson);
+            return version;
+        },
         isPnP: !!process.versions["pnp"],
-        foregroundChild,
-        resolve,
+        resolve: async (specifier, parent) => {
+            const resolve = await importResolve();
+            return resolve(specifier, parent);
+        },
         prettyMilliseconds,
     };
     /* eslint-enable no-restricted-globals */
 }
+function memoize(fn) {
+    let value;
+    return () => (value !== null && value !== void 0 ? value : (value = fn()));
+}
 //# sourceMappingURL=utils.js.map

package/dist/index.js

@@ -2,6 +2,14 @@
  * A hereby Task. To get an instance, call `test`.
  */
 export class Task {
+    /* @internal */
+    get options() {
+        return this._options;
+    }
+    /* @internal */
+    static create(options) {
+        return new Task(options);
+    }
     constructor(options) {
         // Runtime typecheck; consumers of hereby may not have enabled
         // typechecking, so this is helpful.
@@ -37,14 +45,6 @@ export class Task {
         }
         this._options = options;
     }
-    /* @internal */
-    get options() {
-        return this._options;
-    }
-    /* @internal */
-    static create(options) {
-        return new Task(options);
-    }
 }
 /**
  * Creates a new Task.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hereby",
-    "version": "1.6.3",
+    "version": "1.7.0",
     "description": "A simple task runner",
     "repository": "github:jakebailey/hereby",
     "type": "module",
@@ -38,12 +38,11 @@
         "./dist/index.d.ts"
     ],
     "dependencies": {
-        "chalk": "^5.1.2",
         "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",
+        "import-meta-resolve": "^2.2.1",
+        "picocolors": "^1.0.0",
         "pretty-ms": "^8.0.0"
     },
     "devDependencies": {
@@ -51,22 +50,26 @@
         "@tsconfig/node12": "^1.0.11",
         "@types/command-line-args": "^5.2.0",
         "@types/command-line-usage": "^5.0.2",
-        "@types/node": "^14.18.32",
+        "@types/node": "^14.18.36",
         "@types/tmp": "^0.2.3",
-        "@typescript-eslint/eslint-plugin": "^5.40.1",
-        "@typescript-eslint/parser": "^5.40.1",
-        "ava": "^5.0.1",
+        "@typescript-eslint/eslint-plugin": "^5.48.2",
+        "@typescript-eslint/parser": "^5.48.2",
+        "ava": "~5.0.1",
         "c8": "^7.12.0",
-        "dprint": "^0.32.2",
-        "eslint": "^8.26.0",
-        "eslint-plugin-ava": "^13.2.0",
-        "eslint-plugin-simple-import-sort": "^8.0.0",
+        "dprint": "^0.34.4",
+        "eslint": "^8.32.0",
+        "eslint-plugin-ava": "^14.0.0",
+        "eslint-plugin-simple-import-sort": "^9.0.0",
         "execa": "^6.1.0",
         "moq.ts": "^9.0.2",
-        "release-it": "^15.5.0",
-        "rimraf": "^3.0.2",
+        "rimraf": "^4.1.1",
         "tmp": "^0.2.1",
-        "typescript": "~4.8.4"
+        "typescript": "~4.9.4"
+    },
+    "overrides": {
+        "ava": {
+            "emittery": "1.0.0"
+        }
     },
     "packageManager": "npm@8.17.0",
     "volta": {
@@ -88,7 +91,7 @@
             "compile": false
         },
         "environmentVariables": {
-            "FORCE_COLOR": "0"
+            "NO_COLOR": "1"
         }
     },
     "c8": {