node-modules-tools 1.1.3 → 1.2.0

package/dist/chunks/index3.mjs

@@ -0,0 +1,288 @@
+import fs from 'node:fs';
+import { join, relative } from 'pathe';
+import { x } from 'tinyexec';
+import { CLUSTER_DEP_PROD, CLUSTER_DEP_DEV, CLUSTER_DEP_OPTIONAL } from '../constants.mjs';
+
+async function getBunVersion(options) {
+  try {
+    const raw = await x("bun", ["--version"], {
+      throwOnError: true,
+      nodeOptions: { cwd: options.cwd }
+    });
+    return raw.stdout.trim();
+  } catch (err) {
+    console.error("Failed to get bun version");
+    console.error(err);
+    return void 0;
+  }
+}
+async function readBunLockfile(root) {
+  const lockfilePath = join(root, "bun.lock");
+  const lockbPath = join(root, "bun.lockb");
+  if (fs.existsSync(lockfilePath)) {
+    try {
+      const content = await fs.promises.readFile(lockfilePath, "utf-8");
+      const cleanedContent = content.replace(/,(\s*[}\]])/g, "$1");
+      return JSON.parse(cleanedContent);
+    } catch (err) {
+      console.error("Failed to parse bun.lock");
+      console.error(err);
+    }
+  }
+  if (fs.existsSync(lockbPath)) {
+    throw new Error(
+      "Binary bun.lockb format is not supported. Please use the new bun.lock format. https://bun.sh/docs/install/lockfile"
+    );
+  }
+  return null;
+}
+function parseSpec(spec) {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex <= 0)
+    return { name: spec, version: "0.0.0" };
+  return {
+    name: spec.slice(0, atIndex),
+    version: spec.slice(atIndex + 1) || "0.0.0"
+  };
+}
+function splitPackageKey(key) {
+  const result = [];
+  let index = 0;
+  while (index < key.length) {
+    if (key[index] === "@") {
+      const scopeEnd = key.indexOf("/", index + 1);
+      if (scopeEnd === -1) {
+        result.push(key.slice(index));
+        break;
+      }
+      const nameEnd = key.indexOf("/", scopeEnd + 1);
+      if (nameEnd === -1) {
+        result.push(key.slice(index));
+        break;
+      }
+      result.push(key.slice(index, nameEnd));
+      index = nameEnd + 1;
+    } else {
+      const nextSlash = key.indexOf("/", index);
+      if (nextSlash === -1) {
+        result.push(key.slice(index));
+        break;
+      }
+      result.push(key.slice(index, nextSlash));
+      index = nextSlash + 1;
+    }
+  }
+  return result;
+}
+function resolvePackageFilepath(root, key) {
+  const packages = splitPackageKey(key);
+  if (!packages.length)
+    return join(root, "node_modules");
+  const parts = [root];
+  for (const pkg of packages) {
+    parts.push("node_modules");
+    if (pkg.startsWith("@")) {
+      const slash = pkg.indexOf("/");
+      if (slash === -1) {
+        parts.push(pkg);
+      } else {
+        parts.push(pkg.slice(0, slash));
+        parts.push(pkg.slice(slash + 1));
+      }
+    } else {
+      parts.push(pkg);
+    }
+  }
+  return join(...parts);
+}
+function composeChildKey(parent, dependency) {
+  return parent ? `${parent}/${dependency}` : dependency;
+}
+function withCluster(clusters, cluster) {
+  const set = new Set(clusters);
+  set.add(cluster);
+  return set;
+}
+async function listPackageDependencies(options) {
+  const root = options.cwd;
+  const lockfile = await readBunLockfile(root);
+  if (!lockfile)
+    throw new Error("Could not find or parse bun.lock file");
+  const packages = /* @__PURE__ */ new Map();
+  const processedSpecs = /* @__PURE__ */ new Set();
+  const packageInfoByKey = /* @__PURE__ */ new Map();
+  const packageKeysByName = /* @__PURE__ */ new Map();
+  Object.entries(lockfile.packages ?? {}).forEach(([key, tuple]) => {
+    const [spec, , metadata] = tuple;
+    const { name, version } = parseSpec(spec);
+    const info = {
+      key,
+      spec,
+      name,
+      version,
+      metadata: metadata || {}
+    };
+    packageInfoByKey.set(key, info);
+    const existing = packageKeysByName.get(name);
+    if (existing)
+      existing.push(key);
+    else
+      packageKeysByName.set(name, [key]);
+  });
+  function resolveDependencyKey(parentKey, dependency) {
+    if (parentKey) {
+      const scopedKey = composeChildKey(parentKey, dependency);
+      if (packageInfoByKey.has(scopedKey))
+        return scopedKey;
+    }
+    const candidates = packageKeysByName.get(dependency);
+    if (candidates && candidates.length) {
+      if (parentKey) {
+        const nested = candidates.find((candidate) => candidate.startsWith(`${parentKey}/`));
+        if (nested)
+          return nested;
+      }
+      const direct = candidates.find((candidate) => candidate === dependency);
+      if (direct)
+        return direct;
+      return candidates[0];
+    }
+    if (!parentKey && packageInfoByKey.has(dependency))
+      return dependency;
+    return void 0;
+  }
+  function getOrCreateNode(info) {
+    let node = packages.get(info.spec);
+    if (node)
+      return node;
+    node = {
+      spec: info.spec,
+      name: info.name,
+      version: info.version,
+      filepath: resolvePackageFilepath(root, info.key),
+      dependencies: /* @__PURE__ */ new Set(),
+      workspace: false,
+      clusters: /* @__PURE__ */ new Set()
+    };
+    packages.set(node.spec, node);
+    return node;
+  }
+  function traverse(key, clusters) {
+    const info = packageInfoByKey.get(key);
+    if (!info)
+      return void 0;
+    const node = getOrCreateNode(info);
+    if (!node.workspace) {
+      for (const cluster of clusters)
+        node.clusters.add(cluster);
+    }
+    if (options.traverseFilter?.(node) === false)
+      return node;
+    if (processedSpecs.has(node.spec))
+      return node;
+    processedSpecs.add(node.spec);
+    if (options.dependenciesFilter?.(node) === false)
+      return node;
+    const directDependencies = Object.keys(info.metadata.dependencies ?? {});
+    for (const dependency of directDependencies) {
+      const childKey = resolveDependencyKey(key, dependency);
+      if (!childKey)
+        continue;
+      const childNode = traverse(childKey, clusters);
+      if (childNode)
+        node.dependencies.add(childNode.spec);
+    }
+    const optionalDependencies = Object.keys(info.metadata.optionalDependencies ?? {});
+    if (optionalDependencies.length) {
+      const clusterWithOptional = withCluster(clusters, CLUSTER_DEP_OPTIONAL);
+      for (const dependency of optionalDependencies) {
+        const childKey = resolveDependencyKey(key, dependency);
+        if (!childKey)
+          continue;
+        const childNode = traverse(childKey, clusterWithOptional);
+        if (childNode)
+          node.dependencies.add(childNode.spec);
+      }
+    }
+    return node;
+  }
+  const workspaceEntries = Object.entries(lockfile.workspaces ?? {});
+  if (!workspaceEntries.length)
+    workspaceEntries.push(["", {}]);
+  const workspaceNodeByName = /* @__PURE__ */ new Map();
+  const workspacePackages = await Promise.all(workspaceEntries.map(async ([workspacePath, workspace], index) => {
+    const workspaceData = workspace ?? {};
+    let name = workspaceData.name;
+    const workspaceRoot = join(root, workspacePath);
+    if (!name) {
+      let path = relative(root, workspaceRoot);
+      if (path === ".")
+        path = "";
+      const suffix = path.toLowerCase().replace(/[^a-z0-9-]+/g, "_").slice(0, 20);
+      name = suffix ? `#workspace-${suffix}` : index === 0 ? "#workspace-root" : `#workspace-${index + 1}`;
+    }
+    const packageJsonPath = join(workspaceRoot, "package.json");
+    let version = "0.0.0";
+    let isPrivate = false;
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const raw = await fs.promises.readFile(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (!workspaceData.name && pkg.name)
+          name = pkg.name;
+        if (pkg.version)
+          version = pkg.version;
+        if (pkg.private)
+          isPrivate = true;
+      } catch {
+      }
+    }
+    const spec = `${name}@${version}`;
+    const node = {
+      spec,
+      name,
+      version,
+      filepath: workspaceRoot,
+      dependencies: /* @__PURE__ */ new Set(),
+      workspace: true,
+      clusters: /* @__PURE__ */ new Set()
+    };
+    if (isPrivate)
+      node.private = true;
+    packages.set(spec, node);
+    workspaceNodeByName.set(name, node);
+    return { workspace: workspaceData, node };
+  }));
+  for (const { workspace, node } of workspacePackages) {
+    const depGroups = [
+      { entries: workspace.dependencies, clusters: [CLUSTER_DEP_PROD] },
+      { entries: workspace.devDependencies, clusters: [CLUSTER_DEP_DEV] },
+      { entries: workspace.optionalDependencies, clusters: [CLUSTER_DEP_OPTIONAL] }
+    ];
+    for (const { entries, clusters } of depGroups) {
+      if (!entries)
+        continue;
+      for (const dependency of Object.keys(entries)) {
+        const workspaceNode = workspaceNodeByName.get(dependency);
+        if (workspaceNode) {
+          node.dependencies.add(workspaceNode.spec);
+          continue;
+        }
+        const childKey = resolveDependencyKey(null, dependency);
+        if (!childKey)
+          continue;
+        const childNode = traverse(childKey, clusters);
+        if (childNode)
+          node.dependencies.add(childNode.spec);
+      }
+    }
+  }
+  return {
+    root,
+    packageManager: "bun",
+    packageManagerVersion: await getBunVersion(options),
+    packages
+  };
+}
+
+export { listPackageDependencies };

package/dist/constants.d.mts

@@ -1,3 +1,3 @@
-export { d as CLUSTER_DEP_DEV, e as CLUSTER_DEP_OPTIONAL, C as CLUSTER_DEP_PROD, c as PackageModuleTypes } from './shared/node-modules-tools.Dnbbfhc0.mjs';
+export { d as CLUSTER_DEP_DEV, e as CLUSTER_DEP_OPTIONAL, C as CLUSTER_DEP_PROD, c as PackageModuleTypes } from './shared/node-modules-tools.D94dzcLg.mjs';
 import 'pkg-types';
 import 'publint';

package/dist/constants.d.ts

@@ -1,3 +1,3 @@
-export { d as CLUSTER_DEP_DEV, e as CLUSTER_DEP_OPTIONAL, C as CLUSTER_DEP_PROD, c as PackageModuleTypes } from './shared/node-modules-tools.Dnbbfhc0.js';
+export { d as CLUSTER_DEP_DEV, e as CLUSTER_DEP_OPTIONAL, C as CLUSTER_DEP_PROD, c as PackageModuleTypes } from './shared/node-modules-tools.D94dzcLg.js';
 import 'pkg-types';
 import 'publint';

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { AgentName } from 'package-manager-detector';
-import { P as PackageNodeRaw, a as PackageNodeBase, b as PackageNode } from './shared/node-modules-tools.Dnbbfhc0.mjs';
-export { d as CLUSTER_DEP_DEV, e as CLUSTER_DEP_OPTIONAL, C as CLUSTER_DEP_PROD, F as FileCategory, N as NpmMeta, h as NpmMetaLatest, i as PackageInstallSizeInfo, g as PackageModuleType, f as PackageModuleTypeSimple, c as PackageModuleTypes } from './shared/node-modules-tools.Dnbbfhc0.mjs';
+import { P as PackageNodeRaw, a as PackageNodeBase, b as PackageNode } from './shared/node-modules-tools.D94dzcLg.mjs';
+export { d as CLUSTER_DEP_DEV, e as CLUSTER_DEP_OPTIONAL, C as CLUSTER_DEP_PROD, F as FileCategory, N as NpmMeta, h as NpmMetaLatest, i as PackageInstallSizeInfo, g as PackageModuleType, f as PackageModuleTypeSimple, c as PackageModuleTypes } from './shared/node-modules-tools.D94dzcLg.mjs';
 export { PackageJson } from 'pkg-types';
 export { Message as PublintMessage } from 'publint';
 export { NormalizedFunding, PackageNodeLike, ParsedFunding, ParsedLicense, constructPackageFilter, constructPackageFilters, normalizePkgAuthors, normalizePkgFundings, normalizePkgLicense, normalizePkgRepository, parseAuthor, parseFunding } from './utils.mjs';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { AgentName } from 'package-manager-detector';
-import { P as PackageNodeRaw, a as PackageNodeBase, b as PackageNode } from './shared/node-modules-tools.Dnbbfhc0.js';
-export { d as CLUSTER_DEP_DEV, e as CLUSTER_DEP_OPTIONAL, C as CLUSTER_DEP_PROD, F as FileCategory, N as NpmMeta, h as NpmMetaLatest, i as PackageInstallSizeInfo, g as PackageModuleType, f as PackageModuleTypeSimple, c as PackageModuleTypes } from './shared/node-modules-tools.Dnbbfhc0.js';
+import { P as PackageNodeRaw, a as PackageNodeBase, b as PackageNode } from './shared/node-modules-tools.D94dzcLg.js';
+export { d as CLUSTER_DEP_DEV, e as CLUSTER_DEP_OPTIONAL, C as CLUSTER_DEP_PROD, F as FileCategory, N as NpmMeta, h as NpmMetaLatest, i as PackageInstallSizeInfo, g as PackageModuleType, f as PackageModuleTypeSimple, c as PackageModuleTypes } from './shared/node-modules-tools.D94dzcLg.js';
 export { PackageJson } from 'pkg-types';
 export { Message as PublintMessage } from 'publint';
 export { NormalizedFunding, PackageNodeLike, ParsedFunding, ParsedLicense, constructPackageFilter, constructPackageFilters, normalizePkgAuthors, normalizePkgFundings, normalizePkgLicense, normalizePkgRepository, parseAuthor, parseFunding } from './utils.js';

package/dist/index.mjs

@@ -24,6 +24,8 @@ async function listPackageDependenciesRaw(manager, options) {
     result = await import('./chunks/index.mjs').then((r) => r.listPackageDependencies(options));
   else if (manager === "npm")
     result = await import('./chunks/index2.mjs').then((r) => r.listPackageDependencies(options));
+  else if (manager === "bun")
+    result = await import('./chunks/index3.mjs').then((r) => r.listPackageDependencies(options));
   else
     throw new Error(`Package manager ${manager} is not yet supported`);
   return populateRawResult(result);

package/dist/shared/{node-modules-tools.Dnbbfhc0.d.mts → node-modules-tools.D94dzcLg.d.mts}

@@ -80,8 +80,8 @@ interface NpmMetaLatest extends NpmMeta {
      */
     fetechedAt: number;
     /**
-     * We calculate a smart "TTL" based on how open the package updates.
-     * If this timestemp is greater than the current time, the meta should be discarded.
+     * We calculate a smart "TTL" based on how often the package updates.
+     * If this timestamp is greater than the current time, the meta should be discarded.
      */
     vaildUntil: number;
 }

package/dist/shared/{node-modules-tools.Dnbbfhc0.d.ts → node-modules-tools.D94dzcLg.d.ts}

@@ -80,8 +80,8 @@ interface NpmMetaLatest extends NpmMeta {
      */
     fetechedAt: number;
     /**
-     * We calculate a smart "TTL" based on how open the package updates.
-     * If this timestemp is greater than the current time, the meta should be discarded.
+     * We calculate a smart "TTL" based on how often the package updates.
+     * If this timestamp is greater than the current time, the meta should be discarded.
      */
     vaildUntil: number;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-modules-tools",
   "type": "module",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "Tools for inspecting node_modules",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -29,16 +29,16 @@
   "dependencies": {
     "js-yaml": "^4.1.0",
     "p-limit": "^6.2.0",
-    "package-manager-detector": "^1.3.0",
+    "package-manager-detector": "^1.5.0",
     "pathe": "^2.0.3",
     "pkg-types": "^2.3.0",
-    "publint": "^0.3.13",
-    "semver": "^7.7.2",
+    "publint": "^0.3.15",
+    "semver": "^7.7.3",
     "tinyexec": "^1.0.1"
   },
   "devDependencies": {
-    "@pnpm/list": "^1000.1.1",
-    "@pnpm/types": "^1000.8.0",
+    "@pnpm/list": "^1000.1.3",
+    "@pnpm/types": "^1000.9.0",
     "@types/js-yaml": "^4.0.9",
     "@types/stream-json": "^1.7.8",
     "stream-json": "^1.9.1",