@0x-jerry/x 2.4.2 → 2.5.0

package/dist/x.js

@@ -21,8 +21,7 @@ async function downloadGitRepo(opt) {
     return;
   }
   destDir = await checkDest(destDir) || "";
-  if (!destDir)
-    return;
+  if (!destDir) return;
   const gitConf = normalizeGitUrl(url);
   const zipFilePath = await downloadGitBranch(gitConf, branch);
   await fs.ensureDir(destDir);
@@ -56,8 +55,7 @@ async function checkDest(dest) {
     });
     dest = res.dest;
   }
-  if (!dest)
-    return;
+  if (!dest) return;
   dest = path.isAbsolute(dest) ? dest : path.join(cwd, dest);
   const files = fs.pathExistsSync(dest) ? await fs.readdir(dest) : null;
   if (files?.length) {
@@ -67,8 +65,7 @@ async function checkDest(dest) {
       message: `Detect files in ${pc.cyan(dest)}, override it?`,
       initial: false
     });
-    if (!res.override)
-      return;
+    if (!res.override) return;
   }
   return dest;
 }

package/dist/xn.js

@@ -98,7 +98,7 @@ async function installAction(_, opt) {
   }
   await runNpm("add", ...parameters);
   if (opt.types) {
-    const typesPackages = parameters.filter((n) => n.startsWith("-")).map((pkg) => getTypePackageName(pkg));
+    const typesPackages = parameters.filter((n) => !n.startsWith("-")).map((pkg) => getTypePackageName(pkg));
     await runNpm("add", ...typesPackages, "-D");
   }
 }

package/dist/xr.js

@@ -7,101 +7,130 @@ import {
 import { sliver } from "@0x-jerry/silver";
 
 // src/commands/run.ts
-import path, { join, resolve } from "path";
-import pc from "picocolors";
-import jsonc from "jsonc-parser";
-import { readFile, readdir } from "fs/promises";
-import { existsSync } from "fs";
-var { red, cyan } = pc;
-async function runScript(command, params = []) {
-  const [scriptExecuteContent, allScripts] = await getScriptContent(command);
-  if (scriptExecuteContent) {
-    await exec(scriptExecuteContent, params, makeEnv());
-    return;
+import path4 from "path";
+
+// src/commands/run/node.ts
+import { pathExists } from "fs-extra";
+import path from "path";
+import { readdir, readFile } from "fs/promises";
+var NodeTaskDetecter = class {
+  async binaryPaths(cwd) {
+    const envPaths = [];
+    let dir = cwd;
+    do {
+      const binPath = path.join(dir, "node_modules", ".bin");
+      if (await pathExists(binPath)) {
+        envPaths.push(binPath);
+      }
+      dir = path.resolve(dir, "..");
+    } while (dir !== path.resolve(dir, ".."));
+    return envPaths;
   }
-  console.log(
-    red("["),
-    cyan(`${command}`),
-    red("] not exists in the list: "),
-    allScripts.map((name) => cyan(name)).join(", ")
-  );
-}
-function makeEnv() {
-  const cwd = process.cwd();
-  const env = process.env;
-  const envPaths = process.env.PATH?.split(path.delimiter) || [];
-  let dir = cwd;
-  do {
-    const binPath = join(dir, "node_modules", ".bin");
-    if (existsSync(binPath)) {
-      envPaths.push(binPath);
-    }
-    dir = resolve(dir, "..");
-  } while (dir !== resolve(dir, ".."));
-  env.PATH = envPaths.join(path.delimiter);
-  return env;
-}
-async function getPackageScripts() {
-  const scripts = /* @__PURE__ */ new Map();
-  const cwd = process.cwd();
-  const pkgPath = join(cwd, "package.json");
-  try {
-    const text = await readFile(pkgPath, { encoding: "utf-8" });
+  check(cwd) {
+    return pathExists(path.join(cwd, "package.json"));
+  }
+  async task(cwd, taskName) {
+    return (await this.tasks(cwd))[taskName];
+  }
+  async tasks(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    const text = await readFile(pkgPath, "utf8");
     const json = JSON.parse(text);
-    Object.entries(json.scripts).forEach(([name, content]) => {
-      scripts.set(name, content);
-    });
-  } catch (_error) {
+    const tasks = json.scripts || {};
+    {
+      let dir = cwd;
+      do {
+        const binPath = path.join(dir, "node_modules", ".bin");
+        if (await pathExists(binPath)) {
+          const files = await readdir(binPath);
+          for (const filename of files) {
+            tasks[filename] ??= filename;
+          }
+        }
+        dir = path.resolve(dir, "..");
+      } while (dir !== path.resolve(dir, ".."));
+    }
+    return tasks;
   }
-  return scripts;
-}
-async function getBinScripts() {
-  const binCommands = /* @__PURE__ */ new Map();
-  let dir = process.cwd();
-  do {
-    const binPath = join(dir, "node_modules", ".bin");
-    try {
-      for (const file of await readdir(binPath)) {
-        binCommands.set(file, file);
-      }
-    } catch (_error) {
+};
+
+// src/commands/run/deno.ts
+import { parse } from "jsonc-parser";
+import { pathExists as pathExists2 } from "fs-extra";
+import path2 from "path";
+import { readFile as readFile2 } from "fs/promises";
+var DenoTaskDetecter = class {
+  check(cwd) {
+    return pathExists2(path2.join(cwd, "deno.json")) || pathExists2(path2.join(cwd, "deno.jsonc"));
+  }
+  async task(cwd, taskName) {
+    return (await this.tasks(cwd))[taskName];
+  }
+  async tasks(cwd) {
+    let tasks = {};
+    let denoConfigPath = path2.join(cwd, "deno.json");
+    if (!await pathExists2(denoConfigPath)) {
+      denoConfigPath = path2.join(cwd, "deno.jsonc");
     }
-    dir = resolve(dir, "..");
-  } while (dir !== resolve(dir, ".."));
-  return binCommands;
-}
-async function getDenoTasks() {
-  const tasks = /* @__PURE__ */ new Map();
-  const cwd = process.cwd();
-  try {
-    let txt = "";
-    try {
-      const denoConf = join(cwd, "deno.json");
-      txt = await readFile(denoConf, { encoding: "utf-8" });
-    } catch (_error) {
-      const denoConf = join(cwd, "deno.jsonc");
-      txt = await readFile(denoConf, { encoding: "utf-8" });
+    if (await pathExists2(denoConfigPath)) {
+      const text = await readFile2(denoConfigPath, "utf8");
+      const json = parse(text);
+      tasks = json.tasks || {};
     }
-    if (!txt) {
-      return tasks;
+    return tasks;
+  }
+};
+
+// src/commands/run/rust.ts
+import { pathExists as pathExists3 } from "fs-extra";
+import path3 from "path";
+var RustTaskDetecter = class {
+  check(cwd) {
+    return pathExists3(path3.join(cwd, "Cargo.toml"));
+  }
+  async task(_cwd, _taskName) {
+    return "cargo run";
+  }
+};
+
+// src/commands/run.ts
+async function runScript(command, params = []) {
+  const taskDetectors = [
+    new NodeTaskDetecter(),
+    new DenoTaskDetecter(),
+    new RustTaskDetecter()
+  ];
+  const cwd = process.cwd();
+  for (const taskDetector of taskDetectors) {
+    if (await taskDetector.check(cwd)) {
+      const task = await taskDetector.task(cwd, command);
+      if (task) {
+        const env = makeEnv(await taskDetector.binaryPaths?.(cwd) || []);
+        await exec(task, params, env);
+        break;
+      }
     }
-    const json = jsonc.parse(txt);
-    Object.entries(json.tasks).forEach(([name, content]) => {
-      tasks.set(name, content);
-    });
-  } catch (_error) {
   }
-  return tasks;
+  await exec(command, params, makeEnv([]));
 }
-async function getScriptContent(cmd = "") {
-  const tasks = await getDenoTasks();
-  const scripts = await getPackageScripts();
-  const binCommands = await getBinScripts();
-  const executeContent = tasks.get(cmd) || scripts.get(cmd) || binCommands.get(cmd) || false;
-  const uniq = [
-    .../* @__PURE__ */ new Set([...tasks.keys(), ...scripts.keys(), ...binCommands.keys()])
+function makeEnv(extraPaths) {
+  const env = process.env;
+  const envPaths = process.env.PATH?.split(path4.delimiter) || [];
+  env.PATH = [...envPaths, ...extraPaths].join(path4.delimiter);
+  return env;
+}
+async function getAvailableCommands() {
+  const taskDetectors = [
+    new NodeTaskDetecter(),
+    new DenoTaskDetecter(),
+    new RustTaskDetecter()
   ];
-  return [executeContent, uniq];
+  const cwd = process.cwd();
+  const p = taskDetectors.map(
+    async (t) => await t.check(cwd) ? Object.keys(await t.tasks?.(cwd) || {}) : []
+  );
+  const tasks = await Promise.all(p);
+  return tasks.flat();
 }
 
 // src/xr.ts
@@ -111,7 +140,7 @@ var ins = sliver`
 xr [@command:command] #stopEarly, run command quickly. ${defaultAction}
 `;
 ins.type("command", async () => {
-  const [_, allScripts] = await getScriptContent();
+  const allScripts = await getAvailableCommands();
   return allScripts;
 });
 async function defaultAction(_, arg) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0x-jerry/x",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/0x-jerry/x.git"
@@ -43,13 +43,13 @@
     "clean": true
   },
   "dependencies": {
-    "@0x-jerry/silver": "^0.1.7",
-    "@0x-jerry/utils": "^2.2.7",
+    "@0x-jerry/silver": "^0.1.8",
+    "@0x-jerry/utils": "^2.4.2",
     "decompress": "^4.2.1",
     "fs-extra": "^11.2.0",
     "global-agent": "^3.0.0",
-    "got": "^14.2.1",
-    "jsonc-parser": "^3.2.1",
+    "got": "^14.4.1",
+    "jsonc-parser": "^3.3.1",
     "ora": "^8.0.1",
     "picocolors": "^1.0.1",
     "prompts": "^2.4.2"
@@ -59,12 +59,12 @@
     "@types/decompress": "^4.2.7",
     "@types/fs-extra": "^11.0.4",
     "@types/global-agent": "^2.1.3",
-    "@types/node": "^20.12.12",
+    "@types/node": "^20.14.11",
     "@types/prompts": "^2.4.9",
-    "@vitest/coverage-v8": "^1.6.0",
-    "tsup": "^8.0.2",
-    "tsx": "^4.10.4",
-    "typescript": "^5.4.5",
-    "vitest": "^1.6.0"
+    "@vitest/coverage-v8": "^2.0.3",
+    "tsup": "^8.1.2",
+    "tsx": "^4.16.2",
+    "typescript": "^5.5.3",
+    "vitest": "^2.0.3"
   }
 }