@0x-jerry/x 2.5.0 → 2.6.0

package/dist/chunk-WA6Z2RU3.js

@@ -0,0 +1,26 @@
+// src/utils.ts
+import { existsSync } from "fs";
+import { run } from "@0x-jerry/utils/node";
+async function exec(script, params, env) {
+  const cmd = [script, ...params].join(" ");
+  await run(cmd, env);
+}
+function exists(path) {
+  return existsSync(path);
+}
+function flagOptionToStringArray(opt) {
+  return Object.entries(opt).map(([_key, value]) => {
+    const key = (_key.length === 1 ? "-" : "--") + _key;
+    if (typeof value === "string" || typeof value === "number") {
+      return [key, String(value)];
+    } else {
+      return [key];
+    }
+  }).flat();
+}
+
+export {
+  exec,
+  exists,
+  flagOptionToStringArray
+};

package/dist/xn.d.ts

@@ -1,12 +1 @@
 #!/usr/bin/env node
-/**
- *
- * @param pkg
- *
- * getPackageName('lodash@latest') => @types/lodash
- * getPackageName('@babel/core') => @types/babel__core
- *
- */
-declare function getTypePackageName(pkg: string): string;
-
-export { getTypePackageName };

package/dist/xn.js

@@ -1,18 +1,71 @@
 #!/usr/bin/env node
 import {
   exec,
-  exists
-} from "./chunk-O5N22U5G.js";
+  exists,
+  flagOptionToStringArray
+} from "./chunk-WA6Z2RU3.js";
 
 // src/xn.ts
 import { sliver } from "@0x-jerry/silver";
 
-// src/commands/npm.ts
-import { join } from "path";
+// src/commands/dep/deno.ts
+import { pathExists } from "fs-extra";
+import path from "path";
+var DenoDependencyManager = class {
+  check() {
+    const cwd = process.cwd();
+    return pathExists(path.join(cwd, "deno.json")) || pathExists(path.join(cwd, "deno.jsonc"));
+  }
+  async install(option) {
+    await exec("deno", ["cache"]);
+  }
+  async add(modules, option) {
+    await exec("deno", ["add", ...modules]);
+  }
+  async remove(modules, option) {
+    throw new Error("Deno not support remove modules");
+  }
+  async upgrade(modules, option) {
+    throw new Error("Deno not support upgrade modules");
+  }
+};
+
+// src/commands/dep/node.ts
+import path2, { join } from "path";
 import pc from "picocolors";
 import { readFile } from "fs/promises";
+import { pathExists as pathExists2 } from "fs-extra";
+var NodeDependencyManager = class {
+  async check() {
+    return pathExists2(path2.join(process.cwd(), "package.json"));
+  }
+  async install(option) {
+    await runDepManagerCommand("install");
+  }
+  async add(modules, option = {}) {
+    await runDepManagerCommand("add", ...modules);
+    if (option.type) {
+      const typeModules = modules.map((pkg) => getTypePackageName(pkg));
+      await runDepManagerCommand("add", ...typeModules, "-D");
+    }
+  }
+  async remove(modules, option = {}) {
+    await runDepManagerCommand(
+      "remove",
+      ...modules,
+      ...flagOptionToStringArray(option)
+    );
+  }
+  async upgrade(modules, option = {}) {
+    await runDepManagerCommand(
+      "upgrade",
+      ...modules,
+      ...flagOptionToStringArray(option)
+    );
+  }
+};
 var { yellow } = pc;
-var npmCommandMapper = {
+var depInstallerCommandMapper = {
   install: {
     npm: "i",
     yarn: "install",
@@ -25,6 +78,12 @@ var npmCommandMapper = {
     pnpm: "i",
     bun: "add"
   },
+  remove: {
+    npm: "uninstall",
+    yarn: "remove",
+    pnpm: "uninstall",
+    bun: "remove"
+  },
   upgrade: {
     npm: "up",
     yarn: "upgrade",
@@ -32,7 +91,7 @@ var npmCommandMapper = {
     bun: "update"
   }
 };
-async function runNpm(action, ...params) {
+async function runDepManagerCommand(action, ...params) {
   if (!await getPkgJson()) {
     console.log(
       yellow(
@@ -41,19 +100,19 @@ async function runNpm(action, ...params) {
     );
     return;
   }
-  const npmCommand = await detectNpmCommand();
-  const actionName = npmCommandMapper[action][npmCommand];
-  await exec(npmCommand, [actionName, ...params]);
+  const depInstallerCommand = await detectPkgManagerCommand();
+  const actionName = depInstallerCommandMapper[action][depInstallerCommand];
+  await exec(depInstallerCommand, [actionName, ...params]);
 }
-async function detectNpmCommand(cwd = process.cwd()) {
-  const bunLockFile = join(cwd, "bun.lockb");
-  if (exists(bunLockFile)) {
-    return "bun";
-  }
+async function detectPkgManagerCommand(cwd = process.cwd()) {
   const pnpmLockFile = join(cwd, "pnpm-lock.yaml");
   if (exists(pnpmLockFile)) {
     return "pnpm";
   }
+  const bunLockFile = join(cwd, "bun.lockb");
+  if (exists(bunLockFile)) {
+    return "bun";
+  }
   const yarnLockFile = join(cwd, "yarn.lock");
   if (exists(yarnLockFile)) {
     return "yarn";
@@ -73,52 +132,104 @@ async function getPkgJson(cwd = process.cwd()) {
     return false;
   }
 }
+function getTypePackageName(pkg) {
+  const idx = pkg.lastIndexOf("@");
+  const name = idx > 0 ? pkg.slice(0, idx) : pkg;
+  if (name.includes("@")) {
+    const [scope, pkgName] = name.split("/");
+    return `@types/${scope.slice(1)}__${pkgName}`;
+  } else {
+    return `@types/${name}`;
+  }
+}
+
+// src/commands/dep/rust.ts
+import { pathExists as pathExists3 } from "fs-extra";
+import path3 from "path";
+var RustDependencyManager = class {
+  check() {
+    return pathExists3(path3.join(process.cwd(), "Cargo.toml"));
+  }
+  async install(option) {
+    await exec("cargo", ["check"]);
+  }
+  async add(modules, option) {
+    await exec("cargo", ["add", ...modules]);
+  }
+  async remove(modules, option) {
+    await exec("cargo", ["remove", ...modules]);
+  }
+  async upgrade(modules, option) {
+    await exec("cargo", ["update", ...modules]);
+  }
+};
+
+// src/commands/depManager.ts
+var DepManager = class {
+  managers = [
+    new NodeDependencyManager(),
+    new DenoDependencyManager(),
+    new RustDependencyManager()
+  ];
+  async check() {
+    return false;
+  }
+  async _getManager() {
+    for (const m of this.managers) {
+      if (await m.check()) {
+        return m;
+      }
+    }
+  }
+  async install(option) {
+    ;
+    (await this._getManager())?.install(option);
+  }
+  async add(modules, option) {
+    ;
+    (await this._getManager())?.add(modules, option);
+  }
+  async remove(modules, option) {
+    ;
+    (await this._getManager())?.remove(modules, option);
+  }
+  async upgrade(modules, option) {
+    ;
+    (await this._getManager())?.upgrade(modules, option);
+  }
+};
 
 // src/xn.ts
 sliver`
 @help @autocompletion
 
-xn, install npm package quickly. ${defaultAction}
+xn, install dependency quickly, support node/deno/cargo. ${defaultAction}
+
+i/install [...modules] #stopEarly, install dependencies. ${installAction}
 
-i/install [module] #stopEarly, install npm package quickly. ${installAction}
+-t --types @bool, install package's types too, only effect node project.
 
--t --types @bool, install package's types too.
+up/upgrade [...modules] #stopEarly, upgrade dependencies. ${upgradeAction}
 
-up/upgrade #stopEarly, upgrade npm packages. ${upgradeAction}
+rm/remove <...modules> #stopEarly, remove dependencies. ${removeAction}
 `;
 async function defaultAction() {
-  await runNpm("install");
+  await new DepManager().install();
 }
 async function installAction(_, opt) {
-  const parameters = opt._;
-  const installOnly = !parameters.length;
+  const params = opt._;
+  const installOnly = !params.length;
   if (installOnly) {
-    await runNpm("install");
+    await new DepManager().install(opt);
     return;
   }
-  await runNpm("add", ...parameters);
-  if (opt.types) {
-    const typesPackages = parameters.filter((n) => !n.startsWith("-")).map((pkg) => getTypePackageName(pkg));
-    await runNpm("add", ...typesPackages, "-D");
-  }
-}
-function getTypePackageName(pkg) {
-  const idx = pkg.lastIndexOf("@");
-  const name = idx > 0 ? pkg.slice(0, idx) : pkg;
-  if (name.includes("@")) {
-    const [scope, pkgName] = name.split("/");
-    return `@types/${scope.slice(1)}__${pkgName}`;
-  } else {
-    return `@types/${name}`;
-  }
+  await new DepManager().add(params, opt);
 }
 async function upgradeAction(_, opt) {
   const params = opt._;
-  if (opt.L) {
-    params.push("-L");
-  }
-  await runNpm("upgrade", ...params);
+  await new DepManager().upgrade(params, opt);
+}
+async function removeAction(_, opt) {
+  const params = opt._;
+  await new DepManager().remove(params, opt);
 }
-export {
-  getTypePackageName
-};

package/dist/xr.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import {
   exec
-} from "./chunk-O5N22U5G.js";
+} from "./chunk-WA6Z2RU3.js";
 
 // src/xr.ts
 import { sliver } from "@0x-jerry/silver";
 
 // src/commands/run.ts
 import path4 from "path";
+import pc from "picocolors";
 
 // src/commands/run/node.ts
 import { pathExists } from "fs-extra";
@@ -107,11 +108,17 @@ async function runScript(command, params = []) {
       if (task) {
         const env = makeEnv(await taskDetector.binaryPaths?.(cwd) || []);
         await exec(task, params, env);
-        break;
+        return;
       }
     }
   }
-  await exec(command, params, makeEnv([]));
+  const allScripts = await getAvailableCommands();
+  console.log(
+    pc.red("["),
+    pc.cyan(`${command}`),
+    pc.red("] not exists in the list: "),
+    allScripts.map((name) => pc.cyan(name)).join(", ")
+  );
 }
 function makeEnv(extraPaths) {
   const env = process.env;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0x-jerry/x",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/0x-jerry/x.git"
@@ -25,8 +25,8 @@
     "dev:xr": "tsx src/xr.ts",
     "dev:xn": "tsx src/xn.ts",
     "dev:x": "tsx src/x.ts",
-    "test": "vitest",
-    "ci:test": "vitest run",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build",
     "release": "x-release"
   },

package/dist/chunk-O5N22U5G.js

@@ -1,15 +0,0 @@
-// src/utils.ts
-import { existsSync } from "fs";
-import { run } from "@0x-jerry/utils/node";
-async function exec(script, params, env) {
-  const cmd = [script, ...params].join(" ");
-  await run(cmd, env);
-}
-function exists(path) {
-  return existsSync(path);
-}
-
-export {
-  exec,
-  exists
-};