@0x-jerry/x 2.12.6 → 2.12.8

package/dist/{chunk-WWG7Y7EF.js → chunk-P2FBA3GW.js}

@@ -1,5 +1,5 @@
 // package.json
-var version = "2.12.6";
+var version = "2.12.8";
 
 export {
   version

package/dist/chunk-RDZVDWJQ.js

@@ -0,0 +1,81 @@
+// src/utils.ts
+import { existsSync } from "fs";
+import { exec as _exec } from "@0x-jerry/utils/node";
+async function exec(script, params, opt) {
+  const cmd = [script, ...params].join(" ");
+  await _exec(cmd, opt);
+}
+function exists(path2) {
+  return existsSync(path2);
+}
+function flagOptionToStringArray(opt) {
+  return Object.entries(opt).flatMap(([_key, value]) => {
+    const key = (_key.length === 1 ? "-" : "--") + _key;
+    if (typeof value === "string" || typeof value === "number") {
+      return [key, String(value)];
+    }
+    return [key];
+  });
+}
+
+// src/commands/utils/node.ts
+import { readFile } from "fs/promises";
+import path from "path";
+async function detectPackageRoot(cwd, subProjectInfo) {
+  const pkg = await getPkgJson(cwd);
+  if (!pkg) {
+    return detectParentDir(subProjectInfo);
+  }
+  const pm = await detectPkgManagerCommand(cwd);
+  const info = {
+    pkgDir: cwd,
+    package: pkg,
+    pm,
+    subProject: subProjectInfo
+  };
+  if (pm) {
+    return info;
+  }
+  return detectParentDir(info);
+  async function detectParentDir(subProjectInfo2) {
+    const parentDir = path.dirname(cwd);
+    if (parentDir === cwd) {
+      return subProjectInfo2 ?? null;
+    }
+    return detectPackageRoot(parentDir, subProjectInfo2);
+  }
+}
+async function detectPkgManagerCommand(cwd = process.cwd()) {
+  const pnpmLockFile = path.join(cwd, "pnpm-lock.yaml");
+  if (exists(pnpmLockFile)) {
+    return "pnpm";
+  }
+  const bunLockFile = path.join(cwd, "bun.lock");
+  if (exists(bunLockFile)) {
+    return "bun";
+  }
+  const yarnLockFile = path.join(cwd, "yarn.lock");
+  if (exists(yarnLockFile)) {
+    return "yarn";
+  }
+  const jsonLockFile = path.join(cwd, "package-lock.json");
+  if (exists(jsonLockFile)) {
+    return "npm";
+  }
+  return null;
+}
+async function getPkgJson(cwd = process.cwd()) {
+  const jsonFile = path.join(cwd, "package.json");
+  try {
+    const txt = await readFile(jsonFile, { encoding: "utf-8" });
+    return JSON.parse(txt);
+  } catch (_error) {
+    return false;
+  }
+}
+
+export {
+  exec,
+  flagOptionToStringArray,
+  detectPackageRoot
+};

package/dist/x.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   version
-} from "./chunk-WWG7Y7EF.js";
+} from "./chunk-P2FBA3GW.js";
 
 // src/x.ts
 import { sliver } from "@0x-jerry/silver";

package/dist/xn.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
+  detectPackageRoot,
   exec,
-  exists,
   flagOptionToStringArray
-} from "./chunk-ELIYGHQS.js";
+} from "./chunk-RDZVDWJQ.js";
 import {
   version
-} from "./chunk-WWG7Y7EF.js";
+} from "./chunk-P2FBA3GW.js";
 
 // src/xn.ts
 import { sliver } from "@0x-jerry/silver";
@@ -34,13 +34,12 @@ var DenoDependencyManager = class {
 };
 
 // src/commands/dep/node.ts
-import { readFile } from "fs/promises";
-import path2, { join } from "path";
-import { pathExists as pathExists2 } from "fs-extra";
 import pc from "picocolors";
 var NodeDependencyManager = class {
   async check() {
-    return pathExists2(path2.join(process.cwd(), "package.json"));
+    const cwd = process.cwd();
+    const pkgInfo = await detectPackageRoot(cwd);
+    return !!pkgInfo;
   }
   async install(option) {
     await runDepManagerCommand("install");
@@ -100,7 +99,9 @@ var depInstallerCommandMapper = {
   }
 };
 async function runDepManagerCommand(action, ...params) {
-  if (!await getPkgJson()) {
+  const cwd = process.cwd();
+  const pkgInfo = await detectPackageRoot(cwd);
+  if (!pkgInfo) {
     console.log(
       yellow(
         `Can't find package.json! Please ensure that current path is a node project.`
@@ -108,37 +109,9 @@ async function runDepManagerCommand(action, ...params) {
     );
     return;
   }
-  const depInstallerCommand = await detectPkgManagerCommand();
-  const actionName = depInstallerCommandMapper[action][depInstallerCommand];
-  await exec(depInstallerCommand, [actionName, ...params]);
-}
-async function detectPkgManagerCommand(cwd = process.cwd()) {
-  const pnpmLockFile = join(cwd, "pnpm-lock.yaml");
-  if (exists(pnpmLockFile)) {
-    return "pnpm";
-  }
-  const bunLockFile = join(cwd, "bun.lock");
-  if (exists(bunLockFile)) {
-    return "bun";
-  }
-  const yarnLockFile = join(cwd, "yarn.lock");
-  if (exists(yarnLockFile)) {
-    return "yarn";
-  }
-  const jsonLockFile = join(cwd, "package-lock.json");
-  if (exists(jsonLockFile)) {
-    return "npm";
-  }
-  return "pnpm";
-}
-async function getPkgJson(cwd = process.cwd()) {
-  const jsonFile = join(cwd, "package.json");
-  try {
-    const txt = await readFile(jsonFile, { encoding: "utf-8" });
-    return JSON.parse(txt);
-  } catch (_error) {
-    return false;
-  }
+  const pm = pkgInfo.pm || "pnpm";
+  const actionName = depInstallerCommandMapper[action][pm];
+  await exec(pm, [actionName, ...params]);
 }
 function getTypePackageName(pkg) {
   const idx = pkg.lastIndexOf("@");
@@ -151,11 +124,11 @@ function getTypePackageName(pkg) {
 }
 
 // src/commands/dep/rust.ts
-import path3 from "path";
-import { pathExists as pathExists3 } from "fs-extra";
+import path2 from "path";
+import { pathExists as pathExists2 } from "fs-extra";
 var RustDependencyManager = class {
   check() {
-    return pathExists3(path3.join(process.cwd(), "Cargo.toml"));
+    return pathExists2(path2.join(process.cwd(), "Cargo.toml"));
   }
   async install(option) {
     await exec("cargo", ["check"]);

package/dist/xr.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
+  detectPackageRoot,
   exec
-} from "./chunk-ELIYGHQS.js";
+} from "./chunk-RDZVDWJQ.js";
 import {
   version
-} from "./chunk-WWG7Y7EF.js";
+} from "./chunk-P2FBA3GW.js";
 
 // src/xr.ts
 import { sliver } from "@0x-jerry/silver";
@@ -19,8 +20,9 @@ import path from "path";
 import { pathExists } from "fs-extra";
 import { parse } from "jsonc-parser";
 var DenoTaskDetecter = class {
-  check(cwd) {
-    return pathExists(path.join(cwd, "deno.json")) || pathExists(path.join(cwd, "deno.jsonc"));
+  async check(cwd) {
+    const has = await (pathExists(path.join(cwd, "deno.json")) || pathExists(path.join(cwd, "deno.jsonc")));
+    return has ? cwd : void 0;
   }
   async task(cwd, taskName) {
     return (await this.tasks(cwd))[taskName];
@@ -41,7 +43,7 @@ var DenoTaskDetecter = class {
 };
 
 // src/commands/run/node.ts
-import { readdir, readFile as readFile2 } from "fs/promises";
+import { readdir } from "fs/promises";
 import path2 from "path";
 import { pathExists as pathExists2 } from "fs-extra/esm";
 var NodeTaskDetecter = class {
@@ -57,20 +59,29 @@ var NodeTaskDetecter = class {
     } while (dir !== path2.resolve(dir, ".."));
     return envPaths;
   }
-  check(cwd) {
-    return pathExists2(path2.join(cwd, "package.json"));
+  async check(cwd) {
+    const rootPkgInfo = await detectPackageRoot(cwd);
+    return getClosestProjectInfo(rootPkgInfo)?.pkgDir;
   }
   async task(cwd, taskName) {
     return (await this.tasks(cwd))[taskName];
   }
   async tasks(cwd) {
-    const pkgPath = path2.join(cwd, "package.json");
-    const text = await readFile2(pkgPath, "utf8");
-    const json = JSON.parse(text);
-    const tasks = json.scripts || {};
+    const rootPkgInfo = await detectPackageRoot(cwd);
+    const tasks = getClosestProjectInfo(rootPkgInfo)?.package.scripts || {};
     return tasks;
   }
 };
+function getClosestProjectInfo(rootPkgInfo) {
+  if (!rootPkgInfo) {
+    return void 0;
+  }
+  let pkgInfo = rootPkgInfo;
+  while (pkgInfo.subProject) {
+    pkgInfo = pkgInfo.subProject;
+  }
+  return pkgInfo;
+}
 async function getBinariesPairs() {
   let dir = process.cwd();
   const binaries = {};
@@ -91,8 +102,8 @@ async function getBinariesPairs() {
 import path3 from "path";
 import { pathExists as pathExists3 } from "fs-extra";
 var RustTaskDetecter = class {
-  check(cwd) {
-    return pathExists3(path3.join(cwd, "Cargo.toml"));
+  async check(cwd) {
+    return await pathExists3(path3.join(cwd, "Cargo.toml")) ? cwd : void 0;
   }
   async task(_cwd, _taskName) {
     return "cargo run";
@@ -106,13 +117,14 @@ async function runScript(command, params = []) {
     new DenoTaskDetecter(),
     new RustTaskDetecter()
   ];
-  const cwd = process.cwd();
+  let cwd = process.cwd();
   for (const taskDetector of taskDetectors) {
-    if (await taskDetector.check(cwd)) {
-      const task = await taskDetector.task(cwd, command);
+    const workspaceDir = await taskDetector.check(cwd);
+    if (workspaceDir) {
+      const task = await taskDetector.task(workspaceDir, command);
       if (task) {
-        const env = makeEnv(await taskDetector.binaryPaths?.(cwd) || []);
-        await exec(task, params, { env });
+        const env = makeEnv(await taskDetector.binaryPaths?.(workspaceDir) || []);
+        await exec(task, params, { env, cwd: workspaceDir });
         return;
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0x-jerry/x",
-  "version": "2.12.6",
+  "version": "2.12.8",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/0x-jerry/x.git"

package/dist/chunk-ELIYGHQS.js

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