hereby 1.8.8 → 1.9.0

package/README.md

@@ -6,6 +6,7 @@
 [![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)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/jakebailey/hereby/badge)](https://securityscorecards.dev/viewer/?uri=github.com/jakebailey/hereby)
 
 > _I hereby declare thee built._
 

package/dist/cli/index.js

@@ -1,25 +1,22 @@
 import path from "node:path";
-import util from "node:util";
+import { performance } from "node:perf_hooks";
+import { types } from "node:util";
 import pc from "picocolors";
 import { formatTasks } from "./formatTasks.js";
 import { findHerebyfile, loadHerebyfile } from "./loadHerebyfile.js";
 import { getUsage, parseArgs } from "./parseArgs.js";
 import { reexec } from "./reexec.js";
 import { Runner } from "./runner.js";
-import { ExitCodeError, UserError } from "./utils.js";
+import { UserError } from "./utils.js";
 export async function main(d) {
     try {
         await mainWorker(d);
     }
     catch (e) {
-        if (e instanceof ExitCodeError) {
-            d.setExitCode(e.exitCode);
-            return;
-        }
         if (e instanceof UserError) {
             d.error(`${pc.red("Error")}: ${e.message}`);
         }
-        else if (util.types.isNativeError(e) && e.stack) {
+        else if (types.isNativeError(e) && e.stack) {
             d.error(e.stack);
         }
         else {
@@ -35,13 +32,11 @@ async function mainWorker(d) {
         d.log(getUsage());
         return;
     }
-    let herebyfilePath = (_a = args.herebyfile) !== null && _a !== void 0 ? _a : findHerebyfile(d.cwd());
-    herebyfilePath = path.resolve(d.cwd(), herebyfilePath);
-    if (await reexec(d, herebyfilePath)) {
+    const herebyfilePath = path.resolve(d.cwd(), (_a = args.herebyfile) !== null && _a !== void 0 ? _a : findHerebyfile(d.cwd()));
+    if (await reexec(herebyfilePath))
         return;
-    }
     if (args.version) {
-        d.log(`hereby ${await d.version()}`);
+        d.log(`hereby ${d.version()}`);
         return;
     }
     d.chdir(path.dirname(herebyfilePath));
@@ -53,31 +48,30 @@ async function mainWorker(d) {
     const tasks = await selectTasks(d, herebyfile, herebyfilePath, args.run);
     const taskNames = tasks.map((task) => pc.blue(task.options.name)).join(", ");
     d.log(`Using ${pc.yellow(d.simplifyPath(herebyfilePath))} to run ${taskNames}`);
-    const start = Date.now();
+    const start = performance.now();
     let errored = false;
     try {
         const runner = new Runner(d);
         await runner.runTasks(...tasks);
     }
-    catch (e) {
+    catch {
         errored = true;
         // 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);
+        d.setExitCode(1);
     }
     finally {
-        const took = Date.now() - start;
+        const took = performance.now() - start;
         d.log(`Completed ${taskNames}${errored ? pc.red(" with errors") : ""} in ${d.prettyMilliseconds(took)}`);
     }
 }
 // Exported for testing.
 export async function selectTasks(d, herebyfile, herebyfilePath, taskNames) {
     if (taskNames.length === 0) {
-        if (!herebyfile.defaultTask) {
-            throw new UserError(`No default task has been exported from ${d.simplifyPath(herebyfilePath)}; please specify a task name.`);
-        }
-        return [herebyfile.defaultTask];
+        if (herebyfile.defaultTask)
+            return [herebyfile.defaultTask];
+        throw new UserError(`No default task has been exported from ${d.simplifyPath(herebyfilePath)}; please specify a task name.`);
     }
     const tasks = [];
     for (const name of taskNames) {

package/dist/cli/loadHerebyfile.js

@@ -3,30 +3,29 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import pc from "picocolors";
 import { Task } from "../index.js";
-import { UserError } from "./utils.js";
+import { findUp, UserError } from "./utils.js";
 const herebyfileRegExp = /^herebyfile\.m?js$/i;
 export function findHerebyfile(dir) {
-    const root = path.parse(dir).root;
-    while (true) {
-        const entries = fs.readdirSync(dir);
-        const matching = entries.filter((e) => herebyfileRegExp.test(e));
+    const result = findUp(dir, (dir) => {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        const matching = entries.filter((e) => herebyfileRegExp.test(e.name));
         if (matching.length > 1) {
-            throw new UserError(`Found more than one Herebyfile: ${matching.join(", ")}`);
+            throw new UserError(`Found more than one Herebyfile: ${matching.map((e) => e.name).join(", ")}`);
         }
         if (matching.length === 1) {
-            const candidate = path.join(dir, matching[0]);
-            const stat = fs.statSync(candidate);
-            if (!stat.isFile()) {
-                throw new UserError(`${matching[0]} is not a file.`);
+            const candidate = matching[0];
+            if (!candidate.isFile()) {
+                throw new UserError(`${candidate.name} is not a file.`);
             }
-            return candidate;
+            return path.join(dir, candidate.name);
         }
-        if (entries.includes("package.json")) {
-            break; // TODO: Is this actually desirable? What about monorepos?
+        if (entries.some((e) => e.name === "package.json")) {
+            return false; // TODO: Is this actually desirable? What about monorepos?
         }
-        if (dir === root)
-            break;
-        dir = path.dirname(dir);
+        return undefined;
+    });
+    if (result) {
+        return result;
     }
     throw new UserError("Unable to find Herebyfile.");
 }
@@ -37,16 +36,16 @@ export async function loadHerebyfile(herebyfilePath) {
     const exportedTasks = new Set();
     let defaultTask;
     for (const [key, value] of Object.entries(herebyfile)) {
-        if (value instanceof Task) {
-            if (key === "default") {
-                defaultTask = value;
-            }
-            else if (exportedTasks.has(value)) {
-                throw new UserError(`Task "${pc.blue(value.options.name)}" has been exported twice.`);
-            }
-            else {
-                exportedTasks.add(value);
-            }
+        if (!(value instanceof Task))
+            continue;
+        if (key === "default") {
+            defaultTask = value;
+        }
+        else if (exportedTasks.has(value)) {
+            throw new UserError(`Task "${pc.blue(value.options.name)}" has been exported twice.`);
+        }
+        else {
+            exportedTasks.add(value);
         }
     }
     if (defaultTask) {
@@ -58,7 +57,7 @@ export async function loadHerebyfile(herebyfilePath) {
     // We check this here by walking the DAG, as some dependencies may not be
     // exported and therefore would not be seen by the above loop.
     checkTaskInvariants(exportedTasks);
-    const tasks = new Map([...exportedTasks.values()].map((task) => [task.options.name, task]));
+    const tasks = new Map([...exportedTasks].map((task) => [task.options.name, task]));
     return { tasks, defaultTask };
 }
 function checkTaskInvariants(tasks) {
@@ -68,9 +67,8 @@ function checkTaskInvariants(tasks) {
     checkTaskInvariantsWorker(tasks);
     function checkTaskInvariantsWorker(tasks) {
         for (const task of tasks) {
-            if (checkedTasks.has(task)) {
+            if (checkedTasks.has(task))
                 continue;
-            }
             if (taskStack.has(task)) {
                 throw new UserError(`Task "${pc.blue(task.options.name)}" references itself.`);
             }

package/dist/cli/parseArgs.js

@@ -14,7 +14,7 @@ export function parseArgs(argv) {
     });
     return {
         help: options["help"],
-        run: options["_"],
+        run: options._,
         herebyfile: options["herebyfile"],
         printTasks: options["tasks"] ? "normal" : (options["tasks-simple"] ? "simple" : undefined),
         version: options["version"],

package/dist/cli/reexec.js

@@ -1,12 +1,16 @@
-import { pathToFileURL } from "node:url";
-import { UserError } from "./utils.js";
-const cliExportName = "hereby/cli";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { findUp, UserError } from "./utils.js";
+const thisCLI = fileURLToPath(new URL("../cli.js", import.meta.url));
+const distCLIPath = path.join("dist", "cli.js");
+const expectedCLIPath = path.join("node_modules", "hereby", distCLIPath);
 /**
  * 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) {
+export async function reexec(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,18 +19,40 @@ export async function reexec(d, herebyfilePath) {
     // 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 then "reexec" it by importing.
-    const thisCLI = await d.resolve(cliExportName, import.meta.url);
-    let otherCLI;
-    try {
-        otherCLI = await d.resolve(cliExportName, pathToFileURL(herebyfilePath).toString());
-    }
-    catch {
+    //
+    // This code used to use `import.meta.resolve` to find `hereby/cli`, but
+    // manually encoding this behavior is faster and avoids the dependency.
+    // If Node ever makes the two-argument form of `import.meta.resolve` unflagged,
+    // we could switch to that.
+    const otherCLI = findUp(path.dirname(herebyfilePath), (dir) => {
+        const p = path.resolve(dir, expectedCLIPath);
+        // This is the typical case; we've walked up and found it in node_modules.
+        if (fs.existsSync(p))
+            return p;
+        // Otherwise, we check to see if we're self-resolving. Realistically,
+        // this only happens when developing hereby itself.
+        //
+        // Technically, this should go before the above check since self-resolution
+        // comes before node_modules resolution, but this could only happen if hereby
+        // happened to depend on itself somehow.
+        const packageJsonPath = path.join(dir, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+            if (packageJson.name === "hereby") {
+                return path.resolve(dir, distCLIPath);
+            }
+        }
+        return undefined;
+    });
+    if (!otherCLI) {
         throw new UserError("Unable to find hereby; ensure hereby is installed in your package.");
     }
-    if (thisCLI === otherCLI) {
+    if (fs.realpathSync(thisCLI) === fs.realpathSync(otherCLI)) {
         return false;
     }
-    await import(otherCLI);
+    // Note: calling pathToFileURL is required on Windows to disambiguate URLs
+    // from drive letters.
+    await import(pathToFileURL(otherCLI).toString());
     return true;
 }
 //# sourceMappingURL=reexec.js.map

package/dist/cli/runner.js

@@ -1,3 +1,4 @@
+import { performance } from "node:perf_hooks";
 import pc from "picocolors";
 export class Runner {
     constructor(_d) {
@@ -12,9 +13,8 @@ export class Runner {
         // cleanup function in a "finally" or something.
         const results = await Promise.allSettled(tasks.map((task) => {
             const cached = this._addedTasks.get(task);
-            if (cached) {
+            if (cached)
                 return cached;
-            }
             const promise = this._runTask(task);
             this._addedTasks.set(task, promise);
             return promise;
@@ -30,9 +30,8 @@ export class Runner {
         if (dependencies) {
             await this.runTasks(...dependencies);
         }
-        if (!run) {
+        if (!run)
             return;
-        }
         try {
             this.onTaskStart(task);
             await run();
@@ -44,25 +43,22 @@ export class Runner {
         }
     }
     onTaskStart(task) {
-        this._startTimes.set(task, Date.now());
-        if (this._errored) {
+        this._startTimes.set(task, performance.now());
+        if (this._errored)
             return; // Skip logging.
-        }
         this._d.log(`Starting ${pc.blue(task.options.name)}`);
     }
     onTaskFinish(task) {
-        if (this._errored) {
+        if (this._errored)
             return; // Skip logging.
-        }
-        const took = Date.now() - this._startTimes.get(task);
+        const took = performance.now() - this._startTimes.get(task);
         this._d.log(`Finished ${pc.green(task.options.name)} in ${this._d.prettyMilliseconds(took)}`);
     }
     onTaskError(task, e) {
-        if (this._errored) {
+        if (this._errored)
             return; // Skip logging.
-        }
         this._errored = true;
-        const took = Date.now() - this._startTimes.get(task);
+        const took = performance.now() - this._startTimes.get(task);
         this._d.error(`Error in ${pc.red(task.options.name)} in ${this._d.prettyMilliseconds(took)}\n${e}`);
     }
 }

package/dist/cli/utils.js

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 export function compareTaskNames(a, b) {
     return compareStrings(a.options.name, b.options.name);
 }
@@ -17,22 +16,24 @@ export function simplifyPath(p) {
     }
     return p;
 }
+export function findUp(dir, predicate) {
+    const root = path.parse(dir).root;
+    while (true) {
+        const result = predicate(dir);
+        if (result !== undefined)
+            return result;
+        if (dir === root)
+            break;
+        dir = path.dirname(dir);
+    }
+    return undefined;
+}
 /**
  * UserError is a special error that, when caught in the CLI will be printed
  * as a message only, without stacktrace. Use this instead of process.exit.
  */
 export class UserError extends Error {
 }
-/**
- * When thrown, ExitCodeError causes the process to exit with a specific error code,
- * without logging anything.
- */
-export class ExitCodeError {
-    constructor(exitCode, reason) {
-        this.exitCode = exitCode;
-        this.reason = reason;
-    }
-}
 export async function real() {
     const { default: prettyMilliseconds } = await import("pretty-ms");
     /* eslint-disable no-restricted-globals */
@@ -48,16 +49,10 @@ export async function real() {
         setExitCode: (code) => {
             process.exitCode = code;
         },
-        version: async () => {
-            const { resolve } = await import("import-meta-resolve");
-            const packageJsonPath = fileURLToPath(await resolve("hereby/package.json", import.meta.url));
-            const packageJson = await fs.promises.readFile(packageJsonPath, "utf8");
-            const { version } = JSON.parse(packageJson);
-            return version;
-        },
-        resolve: async (specifier, parent) => {
-            const { resolve } = await import("import-meta-resolve");
-            return resolve(specifier, parent);
+        version: () => {
+            const packageJsonURL = new URL("../../package.json", import.meta.url);
+            const packageJson = fs.readFileSync(packageJsonURL, "utf8");
+            return JSON.parse(packageJson).version;
         },
         prettyMilliseconds,
     };

package/dist/index.js

@@ -11,7 +11,8 @@ export class Task {
     constructor(options) {
         // Runtime typecheck; consumers of hereby may not have enabled
         // typechecking, so this is helpful.
-        var _a;
+        var _a, _b;
+        /* eslint-disable @typescript-eslint/no-unnecessary-condition */
         if (typeof options.name !== "string") {
             throw new TypeError("Task name is not a string.");
         }
@@ -21,16 +22,15 @@ export class Task {
         if (!Array.isArray(options.dependencies) && options.dependencies !== undefined) {
             throw new TypeError("Task dependencies is not an array or undefined.");
         }
-        if (options.dependencies) {
-            for (const dep of options.dependencies) {
-                if (!(dep instanceof Task)) {
-                    throw new TypeError("Task dependency is not a task.");
-                }
+        for (const dep of (_a = options.dependencies) !== null && _a !== void 0 ? _a : []) {
+            if (!(dep instanceof Task)) {
+                throw new TypeError("Task dependency is not a task.");
             }
         }
         if (typeof options.run !== "function" && options.run !== undefined) {
             throw new TypeError("Task run is not a function or undefined.");
         }
+        /* eslint-enable @typescript-eslint/no-unnecessary-condition */
         // Non-type checks.
         if (!options.name) {
             throw new Error("Task name must not be empty.");
@@ -38,7 +38,7 @@ export class Task {
         if (options.name.startsWith("-")) {
             throw new Error('Task name must not start with "-".');
         }
-        if (!((_a = options.dependencies) === null || _a === void 0 ? void 0 : _a.length) && !options.run) {
+        if (!((_b = options.dependencies) === null || _b === void 0 ? void 0 : _b.length) && !options.run) {
             throw new Error("Task must have a run function or dependencies.");
         }
         this.options = options;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hereby",
-    "version": "1.8.8",
+    "version": "1.9.0",
     "description": "A simple task runner",
     "repository": "github:jakebailey/hereby",
     "type": "module",
@@ -41,33 +41,33 @@
     "dependencies": {
         "command-line-usage": "^6.1.3",
         "fastest-levenshtein": "^1.0.16",
-        "import-meta-resolve": "^2.2.2",
         "minimist": "^1.2.8",
-        "picocolors": "^1.0.0",
+        "picocolors": "^1.0.1",
         "pretty-ms": "^8.0.0"
     },
     "devDependencies": {
         "@ava/typescript": "^3.0.1",
-        "@changesets/cli": "^2.26.2",
-        "@tsconfig/node12": "^12.1.0",
-        "@types/command-line-usage": "^5.0.3",
-        "@types/minimist": "^1.2.4",
-        "@types/node": "^20.8.10",
-        "@types/tmp": "^0.2.5",
-        "@typescript-eslint/eslint-plugin": "^6.9.1",
-        "@typescript-eslint/parser": "^6.9.1",
+        "@changesets/cli": "^2.27.7",
+        "@tsconfig/node12": "^12.1.3",
+        "@types/command-line-usage": "^5.0.4",
+        "@types/minimist": "^1.2.5",
+        "@types/node": "^20.14.10",
+        "@types/tmp": "^0.2.6",
+        "@typescript-eslint/eslint-plugin": "^7.16.1",
+        "@typescript-eslint/parser": "^7.16.1",
         "ava": "~5.0.1",
-        "c8": "^8.0.1",
-        "dprint": "^0.42.5",
-        "eslint": "^8.52.0",
+        "c8": "^10.1.2",
+        "dprint": "^0.47.2",
+        "eslint": "^8.57.0",
         "eslint-plugin-ava": "^14.0.0",
-        "eslint-plugin-simple-import-sort": "^10.0.0",
-        "eslint-plugin-unicorn": "^49.0.0",
+        "eslint-plugin-simple-import-sort": "^12.1.1",
+        "eslint-plugin-unicorn": "^54.0.0",
         "execa": "^6.1.0",
-        "moq.ts": "^10.0.8",
-        "rimraf": "^5.0.5",
-        "tmp": "^0.2.1",
-        "typescript": "^5.2.2"
+        "monocart-coverage-reports": "^2.9.2",
+        "moq.ts": "^10.1.0",
+        "rimraf": "^5.0.9",
+        "tmp": "0.2.1",
+        "typescript": "^5.5.3"
     },
     "overrides": {
         "ava": {
@@ -80,7 +80,7 @@
         "build": "tsc",
         "watch": "tsc --watch",
         "test": "ava",
-        "coverage": "c8 ava",
+        "coverage": "c8 --experimental-monocart ava",
         "prepack": "rimraf dist && npm run build"
     },
     "ava": {

package/dist/cli/index.d.ts

@@ -1,5 +0,0 @@
-import type { Task } from "../index.js";
-import { type Herebyfile } from "./loadHerebyfile.js";
-import { type D } from "./utils.js";
-export declare function main(d: D): Promise<void>;
-export declare function selectTasks(d: Pick<D, "simplifyPath">, herebyfile: Herebyfile, herebyfilePath: string, taskNames: string[]): Promise<Task[]>;