@aklinker1/check 1.2.0 → 1.3.0

package/dist/cli.mjs

@@ -20,6 +20,11 @@ const main = defineCommand({
       type: "boolean",
       alias: "d",
       description: "Enable debug logs"
+    },
+    binDir: {
+      type: "string",
+      alias: "b",
+      description: "Directory where binaries are located"
     }
   },
   async run(ctx) {

package/dist/index.mjs

@@ -5,12 +5,17 @@ import { createTaskList } from "./tasklist/index.mjs";
 import { relative, resolve, sep } from "node:path";
 import { isCI } from "ci-info";
 export async function check(options = {}) {
-  const { debug: debug2, fix = !isCI, root } = options;
+  const {
+    debug: debug2,
+    fix = !isCI,
+    root = process.cwd(),
+    binDir = "node_modules/.bin"
+  } = options;
   if (debug2) {
     process.env.DEBUG = "true";
   }
   console.log();
-  const tools = await findInstalledTools(root);
+  const tools = await findInstalledTools({ root, binDir });
   if (tools.length === 0) {
     console.log("No tools detected! Run with --debug for more info");
     console.log();
@@ -21,7 +26,7 @@ export async function check(options = {}) {
     async ({ input: tool, fail, succeed, warn }) => {
       const startTime = performance.now();
       const fn = fix ? tool.fix ?? tool.check : tool.check;
-      const problems2 = await fn(root);
+      const problems2 = await fn();
       problems2.forEach((problem) => {
         problem.file = resolve(root ?? process.cwd(), problem.file);
       });
@@ -80,13 +85,11 @@ export async function check(options = {}) {
   console.log();
   process.exit(problems.length);
 }
-async function findInstalledTools(root) {
-  const status = await p(ALL_TOOLS).map(async (tool) => {
-    const t = typeof tool === "function" ? await tool(root) : tool;
-    return {
-      tool: t,
-      isInstalled: await t.isInstalled(root)
-    };
+async function findInstalledTools(opts) {
+  const status = await p(ALL_TOOLS).map(async (def) => {
+    const tool = await def(opts);
+    const isInstalled = await tool.isInstalled();
+    return { tool, isInstalled };
   }).promise;
   if (isDebug()) {
     const getTools = (isInstalled) => status.filter((item) => item.isInstalled === isInstalled).map((item) => item.tool.name).join(", ");

package/dist/tools/eslint.d.ts

@@ -1,3 +1,3 @@
-import type { OutputParser, Tool } from "../types";
-export declare const eslint: Tool;
+import type { OutputParser, ToolDefinition } from "../types";
+export declare const eslint: ToolDefinition;
 export declare const parseOuptut: OutputParser;

package/dist/tools/eslint.mjs

@@ -1,19 +1,23 @@
 import { isBinInstalled, execAndParse } from "../utils.mjs";
-const bin = "node_modules/.bin/eslint";
-const args = [
-  ".",
-  "--ext",
-  ".js,.ts,.jsx,.tsx,.mjs,.mts,.cjs,.cts,.vue",
-  "--format",
-  "compact",
-  "--max-warnings",
-  "0"
-];
-export const eslint = {
-  name: "ESLint",
-  isInstalled: (root) => isBinInstalled(bin, root),
-  check: (root) => execAndParse(root, bin, args, parseOuptut),
-  fix: (root) => execAndParse(root, bin, [...args, "--fix"], parseOuptut)
+import { resolve } from "node:path";
+export const eslint = ({ binDir, root }) => {
+  const bin = resolve(root, binDir, "eslint");
+  const checkArgs = [
+    ".",
+    "--ext",
+    ".js,.ts,.jsx,.tsx,.mjs,.mts,.cjs,.cts,.vue",
+    "--format",
+    "compact",
+    "--max-warnings",
+    "0"
+  ];
+  const fixArgs = [...checkArgs, "--fix"];
+  return {
+    name: "ESLint",
+    isInstalled: () => isBinInstalled(bin),
+    check: () => execAndParse(bin, checkArgs, root, parseOuptut),
+    fix: () => execAndParse(bin, fixArgs, root, parseOuptut)
+  };
 };
 export const parseOuptut = ({ stdout, stderr }) => {
   return `${stdout}

package/dist/tools/index.d.ts

@@ -1 +1 @@
-export declare const ALL_TOOLS: (import("..").Tool | ((root: string | undefined) => Promise<import("..").Tool>))[];
+export declare const ALL_TOOLS: import("..").ToolDefinition[];

package/dist/tools/prettier.d.ts

@@ -1,3 +1,3 @@
-import type { Tool, OutputParser } from "../types";
-export declare const prettier: Tool;
+import type { OutputParser, ToolDefinition } from "../types";
+export declare const prettier: ToolDefinition;
 export declare const parseOuptut: OutputParser;

package/dist/tools/prettier.mjs

@@ -1,12 +1,15 @@
 import { execAndParse, isBinInstalled } from "../utils.mjs";
-const bin = "node_modules/.bin/prettier";
-const checkArgs = [".", "--list-different"];
-const fixArgs = [".", "-w"];
-export const prettier = {
-  name: "Prettier",
-  isInstalled: (root) => isBinInstalled(bin, root),
-  check: (root) => execAndParse(root, bin, checkArgs, parseOuptut),
-  fix: (root) => execAndParse(root, bin, fixArgs, parseOuptut)
+import { resolve } from "node:path";
+export const prettier = ({ binDir, root }) => {
+  const bin = resolve(root, binDir, "prettier");
+  const checkArgs = [".", "--list-different"];
+  const fixArgs = [".", "-w"];
+  return {
+    name: "Prettier",
+    isInstalled: () => isBinInstalled(bin),
+    check: () => execAndParse(bin, checkArgs, root, parseOuptut),
+    fix: () => execAndParse(bin, fixArgs, root, parseOuptut)
+  };
 };
 export const parseOuptut = ({ stdout, stderr }) => {
   if (stderr.trim()) {

package/dist/tools/publint.d.ts

@@ -1,3 +1,3 @@
-import type { OutputParser, Tool } from "../types";
-export declare const publint: Tool;
+import type { OutputParser, ToolDefinition } from "../types";
+export declare const publint: ToolDefinition;
 export declare const parseOuptut: OutputParser;

package/dist/tools/publint.mjs

@@ -1,10 +1,15 @@
 import { isBinInstalled, execAndParse } from "../utils.mjs";
-const bin = "node_modules/.bin/publint";
+import { resolve } from "node:path";
+const bin = "publint";
 const args = [];
-export const publint = {
-  name: "Publint",
-  isInstalled: (root) => isBinInstalled(bin, root),
-  check: (root) => execAndParse(root, bin, args, parseOuptut)
+export const publint = ({ binDir, root }) => {
+  const bin2 = resolve(root, binDir, "publint");
+  const args2 = [];
+  return {
+    name: "Publint",
+    isInstalled: () => isBinInstalled(bin2),
+    check: () => execAndParse(bin2, args2, root, parseOuptut)
+  };
 };
 export const parseOuptut = ({ stdout }) => {
   let kind = "warning";

package/dist/tools/typescript.d.ts

@@ -1,3 +1,3 @@
-import type { Tool, OutputParser } from "../types";
-export declare const typescript: (root: string | undefined) => Promise<Tool>;
+import type { OutputParser, ToolDefinition } from "../types";
+export declare const typescript: ToolDefinition;
 export declare const parseOuptut: OutputParser;

package/dist/tools/typescript.mjs

@@ -1,23 +1,27 @@
 import { debug, execAndParse, isBinInstalled } from "../utils.mjs";
-const tsc = {
-  bin: "node_modules/.bin/tsc",
-  args: ["--noEmit", "--pretty", "false"]
-};
-const vueTsc = {
-  bin: "node_modules/.bin/vue-tsc",
-  args: ["--noEmit", "--pretty", "false"]
-};
-export const typescript = async (root) => {
-  const isVueTsc = await isBinInstalled(vueTsc.bin, root);
+import { resolve } from "node:path";
+export const typescript = async ({
+  root,
+  binDir
+}) => {
+  const tsc = {
+    bin: resolve(root, binDir, "tsc"),
+    args: ["--noEmit", "--pretty", "false"]
+  };
+  const vueTsc = {
+    bin: resolve(root, binDir, "vue-tsc"),
+    args: ["--noEmit", "--pretty", "false"]
+  };
+  const isVueTsc = await isBinInstalled(vueTsc.bin);
   debug("TypeScript: Is vue-tsc installed? " + isVueTsc);
   const cmd = isVueTsc ? vueTsc : tsc;
   const name = isVueTsc ? "TypeScript (Vue)" : "Typescript";
   return {
     name,
     // Always check if tsc is installed
-    isInstalled: (root2) => isBinInstalled(tsc.bin, root2),
+    isInstalled: () => isBinInstalled(tsc.bin),
     // Execute the other TSC binary if necessary
-    check: async (root2) => execAndParse(root2, cmd.bin, cmd.args, parseOuptut)
+    check: async () => execAndParse(cmd.bin, cmd.args, root, parseOuptut)
   };
 };
 export const parseOuptut = ({ stdout }) => {

package/dist/types.d.ts

@@ -13,7 +13,12 @@ export interface CheckOptions {
      * Set to true to enable debug logs.
      */
     debug?: boolean;
+    binDir?: string;
 }
+export type ToolDefinition = (opts: {
+    root: string;
+    binDir: string;
+}) => Promise<Tool> | Tool;
 export interface Tool {
     /**
      * Name of tool shown in the console output.
@@ -22,15 +27,15 @@ export interface Tool {
     /**
      * Check if the tool is installed.
      */
-    isInstalled: (root: string | undefined) => Promise<boolean>;
+    isInstalled: () => Promise<boolean>;
     /**
      * Run the tool, only checking for problems.
      */
-    check: (root: string | undefined) => Promise<Problem[]>;
+    check: () => Promise<Problem[]>;
     /**
      * Run the tool, but fix problems if possible. If the tool doesn't support fixing problems, `check` will be called instead.
      */
-    fix?: (root: string | undefined) => Promise<Problem[]>;
+    fix?: () => Promise<Problem[]>;
 }
 export interface Problem {
     location?: CodeLocation;

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import type { OutputParser, Problem } from "./types";
-export declare function isBinInstalled(bin: string, root?: string): Promise<boolean>;
-export declare function execAndParse(root: string | undefined, bin: string, args: string[], parser: OutputParser): Promise<Problem[]>;
+export declare function isBinInstalled(bin: string): Promise<boolean>;
+export declare function execAndParse(bin: string, args: string[], cwd: string, parser: OutputParser): Promise<Problem[]>;
 export declare function isDebug(): boolean;
 export declare const bold: (str: string) => string;
 export declare const dim: (str: string) => string;

package/dist/utils.mjs

@@ -1,22 +1,17 @@
 import { spawn } from "node:child_process";
 import { stat } from "fs/promises";
-import { resolve } from "node:path";
-function resolveRoot(root, ...path) {
-  return root != null ? resolve(root, ...path) : resolve(...path);
-}
-export async function isBinInstalled(bin, root) {
+export async function isBinInstalled(bin) {
   try {
-    const binPath = resolveRoot(root, bin);
     if (isDebug())
-      debug(`Checking if binary exists: ${binPath}`);
-    await stat(resolveRoot(root, bin));
+      debug(`Checking if binary exists: ${bin}`);
+    await stat(bin);
     return true;
   } catch (err) {
     return false;
   }
 }
 function exec(cmd, args, opts) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const child = spawn(cmd, args, { ...opts, shell: true });
     let stderr = "";
     let stdout = "";
@@ -30,16 +25,16 @@ function exec(cmd, args, opts) {
       reject(error);
     });
     child.on("close", (exitCode) => {
-      resolve2({ stderr, stdout, exitCode });
+      resolve({ stderr, stdout, exitCode });
     });
   });
 }
-export async function execAndParse(root, bin, args, parser) {
-  const res = await exec(resolveRoot(root, bin), args, { cwd: root });
+export async function execAndParse(bin, args, cwd, parser) {
+  const res = await exec(bin, args, { cwd });
   if (res.exitCode == null)
     throw Error("Exit code was null");
   if (isDebug())
-    console.debug({ bin, args, root, ...res });
+    console.debug({ bin, args, cwd, ...res });
   return parser({
     code: res.exitCode,
     stderr: res.stderr,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aklinker1/check",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/aklinker1/check"