node-modules-tools 0.0.1 → 0.0.2

package/dist/chunks/pnpm.mjs

@@ -1,5 +1,14 @@
+import { relative, dirname } from 'pathe';
 import { x } from 'tinyexec';
 
+async function resolveRoot(options) {
+  const raw = await x("pnpm", ["root", "-w"], { throwOnError: true, nodeOptions: { cwd: options.cwd } });
+  return dirname(raw.stdout.trim());
+}
+async function getPnpmVersion(options) {
+  const raw = await x("pnpm", ["--version"], { throwOnError: true, nodeOptions: { cwd: options.cwd } });
+  return raw.stdout.trim();
+}
 async function getDependenciesTree(options) {
   const args = ["ls", "--json", "--no-optional", "--depth", String(options.depth)];
   if (options.monorepo)
@@ -9,71 +18,92 @@ async function getDependenciesTree(options) {
   return tree;
 }
 async function listPackageDependencies(options) {
+  const root = await resolveRoot(options) || options.cwd;
   const tree = await getDependenciesTree(options);
-  const specs = /* @__PURE__ */ new Map();
-  const map = /* @__PURE__ */ new WeakMap();
+  const packages = /* @__PURE__ */ new Map();
+  const workspacePackages = tree.map((pkg) => {
+    let name = pkg.name;
+    if (!name) {
+      let path = relative(root, pkg.path);
+      if (path === ".")
+        path = "";
+      const suffix = path.toLowerCase().replace(/[^a-z0-9-]+/g, "_").slice(0, 20);
+      name = suffix ? `#workspace-${suffix}` : "#workspace-root";
+    }
+    const version = pkg.version || "0.0.0";
+    const node = {
+      spec: `${name}@${version}`,
+      name,
+      version,
+      filepath: pkg.path,
+      dependencies: /* @__PURE__ */ new Set(),
+      workspace: true
+    };
+    if (pkg.private)
+      node.private = true;
+    packages.set(node.spec, node);
+    return {
+      pkg,
+      node
+    };
+  });
+  const mapNormalize = /* @__PURE__ */ new WeakMap();
   function normalize(raw) {
-    let node = map.get(raw);
+    let node = mapNormalize.get(raw);
     if (node)
       return node;
-    node = {
-      spec: `${raw.from}@${raw.version}`,
+    let version = raw.version;
+    if (version.includes(":")) {
+      const workspaceMapping = workspacePackages.find((i) => i.pkg.path === raw.path);
+      if (workspaceMapping)
+        version = workspaceMapping.node.version;
+    }
+    const spec = `${raw.from}@${version}`;
+    node = packages.get(spec) || {
+      spec,
       name: raw.from,
-      version: raw.version,
-      path: raw.path,
-      dependencies: /* @__PURE__ */ new Set(),
-      dependents: /* @__PURE__ */ new Set(),
-      flatDependents: /* @__PURE__ */ new Set(),
-      flatDependencies: /* @__PURE__ */ new Set(),
-      nestedLevels: /* @__PURE__ */ new Set(),
-      dev: false,
-      prod: false,
-      optional: false
+      version,
+      filepath: raw.path,
+      dependencies: /* @__PURE__ */ new Set()
     };
-    map.set(raw, node);
+    mapNormalize.set(raw, node);
     return node;
   }
-  function traverse(_node, level, mode, directImporter, nestedImporter) {
-    const node = normalize(_node);
-    if (directImporter)
-      node.dependents.add(directImporter);
-    for (const im of nestedImporter)
-      node.flatDependents.add(im);
-    node.nestedLevels.add(level);
-    if (mode === "dev")
-      node.dev = true;
-    if (mode === "prod")
-      node.prod = true;
-    if (mode === "optional")
-      node.optional = true;
+  function traverse(raw, level, mode) {
+    const node = normalize(raw);
+    if (!node.workspace) {
+      if (mode === "dev")
+        node.dev = true;
+      if (mode === "prod")
+        node.prod = true;
+      if (mode === "optional")
+        node.optional = true;
+    }
     if (options.traverseFilter?.(node) === false)
-      return;
-    if (specs.has(node.spec))
-      return;
-    specs.set(node.spec, node);
-    for (const dep of Object.values(_node.dependencies || {})) {
-      traverse(dep, level + 1, mode, node.spec, [...nestedImporter, node.spec]);
+      return node;
+    if (packages.has(node.spec))
+      return node;
+    packages.set(node.spec, node);
+    for (const dep of Object.values(raw.dependencies || {})) {
+      const resolvedDep = traverse(dep, level + 1, mode);
+      node.dependencies.add(resolvedDep.spec);
     }
+    return node;
   }
-  for (const pkg of tree) {
+  for (const { pkg, node } of workspacePackages) {
     for (const dep of Object.values(pkg.dependencies || {})) {
-      traverse(dep, 1, "prod", undefined, []);
+      const result = traverse(dep, 1, "prod");
+      node.dependencies.add(result.spec);
     }
     for (const dep of Object.values(pkg.devDependencies || {})) {
-      traverse(dep, 1, "dev", undefined, []);
-    }
-  }
-  const packages = [...specs.values()].sort((a, b) => a.spec.localeCompare(b.spec));
-  for (const pkg of packages) {
-    for (const dep of pkg.flatDependents) {
-      const node = specs.get(dep);
-      if (node)
-        node.flatDependencies.add(pkg.spec);
+      const result = traverse(dep, 1, "dev");
+      node.dependencies.add(result.spec);
     }
   }
   return {
-    cwd: options.cwd,
+    root,
     packageManager: "pnpm",
+    packageManagerVersion: await getPnpmVersion(options),
     packages
   };
 }

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 type PackageModuleTypeSimple = 'cjs' | 'esm';
-type PackageModuleType = 'cjs' | 'esm' | 'dual' | 'faux' | 'none';
+type PackageModuleType = 'cjs' | 'esm' | 'dual' | 'faux' | 'dts';
 interface ListPackageDependenciesOptions {
     /**
      * Current working directory
@@ -16,14 +16,21 @@ interface ListPackageDependenciesOptions {
     /**
      * Filter if a package should be included and continue traversing
      */
-    traverseFilter?: (node: PackageNode) => boolean;
+    traverseFilter?: (node: PackageNodeRaw) => boolean;
 }
-interface ListPackageDependenciesResult {
-    cwd: string;
+interface ListPackageDependenciesRawResult {
+    root: string;
     packageManager: string;
-    packages: PackageNode[];
+    packageManagerVersion?: string;
+    packages: Map<string, PackageNodeRaw>;
+}
+interface ListPackageDependenciesBaseResult extends ListPackageDependenciesRawResult {
+    packages: Map<string, PackageNodeBase>;
 }
-interface PackageNode {
+interface ListPackageDependenciesResult extends ListPackageDependenciesBaseResult {
+    packages: Map<string, PackageNode>;
+}
+interface PackageNodeRaw {
     /** Package Name */
     name: string;
     /** Version */
@@ -31,39 +38,49 @@ interface PackageNode {
     /** Combined name and version using `@` */
     spec: string;
     /** Absolute file path of the package */
-    path: string;
+    filepath: string;
     /** Direct dependencies of this package */
     dependencies: Set<string>;
+    /** Is this package from local workspace */
+    workspace?: boolean;
+    /** Is this package private */
+    private?: boolean;
+    /** Is this package part of devDependencies */
+    dev?: boolean;
+    /** Is this package part of dependencies */
+    prod?: boolean;
+    /** Is this package part of optionalDependencies */
+    optional?: boolean;
+}
+interface PackageNodeBase extends PackageNodeRaw {
     /** Direct dependents of this package */
     dependents: Set<string>;
+    /** The lowest depth of this package */
+    depth: number;
     /** All nested dependencies of this package */
     flatDependencies: Set<string>;
     /** All nested  dependents of this package */
     flatDependents: Set<string>;
-    /** Nested levels of this package */
-    nestedLevels: Set<number>;
-    /** Is this package part of devDependencies */
-    dev: boolean;
-    /** Is this package part of dependencies */
-    prod: boolean;
-    /** Is this package part of optionalDependencies */
-    optional: boolean;
 }
-interface ResolvedPackageNode extends PackageNode {
+interface PackageNode extends PackageNodeBase {
     resolved: {
         module: PackageModuleType;
         license?: string;
         author?: string;
         repository?: string;
+        homepage?: string;
         engines?: Record<string, string>;
     };
 }
 
+declare const PackageModuleTypes: readonly PackageModuleType[];
+
 /**
  * List dependencies of packages in the current project.
  *
  * This function will automatically detect the package manager in the current project, and list the dependencies of the packages.
  */
+declare function listPackageDependenciesRaw(options: ListPackageDependenciesOptions): Promise<ListPackageDependenciesRawResult>;
 declare function listPackageDependencies(options: ListPackageDependenciesOptions): Promise<ListPackageDependenciesResult>;
 
 /**
@@ -72,6 +89,8 @@ declare function listPackageDependencies(options: ListPackageDependenciesOptions
  *
  * - Set `module` to the resolved module type (cjs, esm, dual, faux, none).
  */
-declare function resolvePackage(pkg: PackageNode): Promise<ResolvedPackageNode>;
+declare function resolvePackage(pkg: PackageNodeBase): Promise<PackageNode>;
+
+declare function stripBomTag(content: string): string;
 
-export { type ListPackageDependenciesOptions, type ListPackageDependenciesResult, type PackageModuleType, type PackageModuleTypeSimple, type PackageNode, type ResolvedPackageNode, listPackageDependencies, resolvePackage };
+export { type ListPackageDependenciesBaseResult, type ListPackageDependenciesOptions, type ListPackageDependenciesRawResult, type ListPackageDependenciesResult, type PackageModuleType, type PackageModuleTypeSimple, PackageModuleTypes, type PackageNode, type PackageNodeBase, type PackageNodeRaw, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 type PackageModuleTypeSimple = 'cjs' | 'esm';
-type PackageModuleType = 'cjs' | 'esm' | 'dual' | 'faux' | 'none';
+type PackageModuleType = 'cjs' | 'esm' | 'dual' | 'faux' | 'dts';
 interface ListPackageDependenciesOptions {
     /**
      * Current working directory
@@ -16,14 +16,21 @@ interface ListPackageDependenciesOptions {
     /**
      * Filter if a package should be included and continue traversing
      */
-    traverseFilter?: (node: PackageNode) => boolean;
+    traverseFilter?: (node: PackageNodeRaw) => boolean;
 }
-interface ListPackageDependenciesResult {
-    cwd: string;
+interface ListPackageDependenciesRawResult {
+    root: string;
     packageManager: string;
-    packages: PackageNode[];
+    packageManagerVersion?: string;
+    packages: Map<string, PackageNodeRaw>;
+}
+interface ListPackageDependenciesBaseResult extends ListPackageDependenciesRawResult {
+    packages: Map<string, PackageNodeBase>;
 }
-interface PackageNode {
+interface ListPackageDependenciesResult extends ListPackageDependenciesBaseResult {
+    packages: Map<string, PackageNode>;
+}
+interface PackageNodeRaw {
     /** Package Name */
     name: string;
     /** Version */
@@ -31,39 +38,49 @@ interface PackageNode {
     /** Combined name and version using `@` */
     spec: string;
     /** Absolute file path of the package */
-    path: string;
+    filepath: string;
     /** Direct dependencies of this package */
     dependencies: Set<string>;
+    /** Is this package from local workspace */
+    workspace?: boolean;
+    /** Is this package private */
+    private?: boolean;
+    /** Is this package part of devDependencies */
+    dev?: boolean;
+    /** Is this package part of dependencies */
+    prod?: boolean;
+    /** Is this package part of optionalDependencies */
+    optional?: boolean;
+}
+interface PackageNodeBase extends PackageNodeRaw {
     /** Direct dependents of this package */
     dependents: Set<string>;
+    /** The lowest depth of this package */
+    depth: number;
     /** All nested dependencies of this package */
     flatDependencies: Set<string>;
     /** All nested  dependents of this package */
     flatDependents: Set<string>;
-    /** Nested levels of this package */
-    nestedLevels: Set<number>;
-    /** Is this package part of devDependencies */
-    dev: boolean;
-    /** Is this package part of dependencies */
-    prod: boolean;
-    /** Is this package part of optionalDependencies */
-    optional: boolean;
 }
-interface ResolvedPackageNode extends PackageNode {
+interface PackageNode extends PackageNodeBase {
     resolved: {
         module: PackageModuleType;
         license?: string;
         author?: string;
         repository?: string;
+        homepage?: string;
         engines?: Record<string, string>;
     };
 }
 
+declare const PackageModuleTypes: readonly PackageModuleType[];
+
 /**
  * List dependencies of packages in the current project.
  *
  * This function will automatically detect the package manager in the current project, and list the dependencies of the packages.
  */
+declare function listPackageDependenciesRaw(options: ListPackageDependenciesOptions): Promise<ListPackageDependenciesRawResult>;
 declare function listPackageDependencies(options: ListPackageDependenciesOptions): Promise<ListPackageDependenciesResult>;
 
 /**
@@ -72,6 +89,8 @@ declare function listPackageDependencies(options: ListPackageDependenciesOptions
  *
  * - Set `module` to the resolved module type (cjs, esm, dual, faux, none).
  */
-declare function resolvePackage(pkg: PackageNode): Promise<ResolvedPackageNode>;
+declare function resolvePackage(pkg: PackageNodeBase): Promise<PackageNode>;
+
+declare function stripBomTag(content: string): string;
 
-export { type ListPackageDependenciesOptions, type ListPackageDependenciesResult, type PackageModuleType, type PackageModuleTypeSimple, type PackageNode, type ResolvedPackageNode, listPackageDependencies, resolvePackage };
+export { type ListPackageDependenciesBaseResult, type ListPackageDependenciesOptions, type ListPackageDependenciesRawResult, type ListPackageDependenciesResult, type PackageModuleType, type PackageModuleTypeSimple, PackageModuleTypes, type PackageNode, type PackageNodeBase, type PackageNodeRaw, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag };

package/dist/index.mjs

@@ -1,18 +1,8 @@
 import { detect } from 'package-manager-detector';
 import fs from 'node:fs/promises';
-import { join } from 'node:path';
+import { join } from 'pathe';
 
-async function listPackageDependencies(options) {
-  const manager = await detect({
-    cwd: options.cwd
-  });
-  if (!manager)
-    throw new Error("Cannot detect package manager in the current patch");
-  if (manager.name === "pnpm")
-    return await import('./chunks/pnpm.mjs').then((r) => r.listPackageDependencies(options));
-  else
-    throw new Error(`Package manager ${manager.name} is not yet supported`);
-}
+const PackageModuleTypes = Object.freeze(["cjs", "esm", "dual", "faux", "dts"]);
 
 function analyzePackageModuleType(pkgJson) {
   const { exports, main, type } = pkgJson;
@@ -52,8 +42,8 @@ function analyzePackageModuleType(pkgJson) {
     return "esm";
   if (fauxEsm)
     return "faux";
-  if (!esm && !cjs)
-    return "none";
+  if (!esm && !cjs && !pkgJson.main && !pkgJson.exports && pkgJson.types)
+    return "dts";
   return "cjs";
   function analyzeThing(value, path) {
     if (value && typeof value === "object") {
@@ -123,16 +113,111 @@ async function resolvePackage(pkg) {
   const _pkg = pkg;
   if (_pkg.resolved)
     return _pkg;
-  const content = await fs.readFile(join(pkg.path, "package.json"), "utf-8");
+  const content = await fs.readFile(join(pkg.filepath, "package.json"), "utf-8");
   const json = JSON.parse(stripBomTag(content));
+  let repository = typeof json.repository === "string" ? json.repository : json.repository?.url;
+  if (repository?.startsWith("git+"))
+    repository = repository.slice(4);
+  if (repository?.endsWith(".git"))
+    repository = repository.slice(0, -4);
+  if (repository?.startsWith("git://"))
+    repository = `https://${repository.slice(6)}`;
+  if (json.repository && typeof json.repository !== "string" && json.repository.directory)
+    repository += `/tree/HEAD/${json.repository.directory}`;
   _pkg.resolved = {
     module: analyzePackageModuleType(json),
     engines: json.engines,
     license: json.license,
     author: typeof json.author === "string" ? json.author : json.author?.url,
-    repository: typeof json.repository === "string" ? json.repository : json.repository?.url
+    repository,
+    homepage: json.homepage
   };
   return _pkg;
 }
 
-export { listPackageDependencies, resolvePackage };
+async function listPackageDependenciesRaw(options) {
+  const manager = await detect({
+    cwd: options.cwd
+  });
+  if (!manager)
+    throw new Error("Cannot detect package manager in the current patch");
+  let result;
+  if (manager.name === "pnpm")
+    result = await import('./chunks/pnpm.mjs').then((r) => r.listPackageDependencies(options));
+  else
+    throw new Error(`Package manager ${manager.name} is not yet supported`);
+  return populateRawResult(result);
+}
+function populateRawResult(input) {
+  const result = {
+    ...input,
+    packages: /* @__PURE__ */ new Map()
+  };
+  for (const [spec, pkg] of input.packages) {
+    const node = Object.assign(pkg, {
+      dependents: /* @__PURE__ */ new Set(),
+      flatDependencies: /* @__PURE__ */ new Set(),
+      flatDependents: /* @__PURE__ */ new Set(),
+      depth: pkg.workspace ? 0 : Infinity
+    });
+    result.packages.set(spec, node);
+  }
+  for (const pkg of result.packages.values()) {
+    for (const dep of pkg.dependencies) {
+      result.packages.get(dep)?.dependents.add(pkg.spec);
+    }
+  }
+  function resloveFlatDependencies(pkg) {
+    const postTasks = [];
+    function traverseDependencies(node, seen = /* @__PURE__ */ new Set()) {
+      for (const dep of node.dependencies) {
+        const level = node.depth + 1;
+        const depNode = result.packages.get(dep);
+        if (!node.workspace) {
+          if (node.dev)
+            depNode.dev = true;
+          if (node.prod)
+            depNode.prod = true;
+          if (node.optional)
+            depNode.optional = true;
+        }
+        if (depNode.depth > level)
+          depNode.depth = level;
+        if (seen.has(depNode))
+          continue;
+        pkg.flatDependencies.add(dep);
+        seen.add(depNode);
+        postTasks.push(() => {
+          depNode.flatDependents.add(pkg.spec);
+        });
+        traverseDependencies(depNode, seen);
+      }
+    }
+    function traverseDependents(node) {
+      for (const dep of node.dependents) {
+        if (pkg.flatDependents.has(dep))
+          continue;
+        pkg.flatDependents.add(dep);
+        const parentNode = result.packages.get(dep);
+        postTasks.push(() => {
+          parentNode.flatDependencies.add(pkg.spec);
+        });
+        traverseDependents(parentNode);
+      }
+    }
+    traverseDependencies(pkg);
+    traverseDependents(pkg);
+    for (const task of postTasks)
+      task();
+  }
+  for (const pkg of result.packages.values())
+    resloveFlatDependencies(pkg);
+  return result;
+}
+async function listPackageDependencies(options) {
+  const result = await listPackageDependenciesRaw(options);
+  await Promise.all(Array.from(result.packages.values()).map(async (pkg) => resolvePackage(pkg)));
+  return result;
+}
+
+export { PackageModuleTypes, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-modules-tools",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Tools for inspecting node_modules",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -33,12 +33,13 @@
     "dist"
   ],
   "dependencies": {
-    "package-manager-detector": "^0.2.8",
+    "package-manager-detector": "^0.2.9",
+    "pathe": "^2.0.2",
     "tinyexec": "^0.3.2"
   },
   "devDependencies": {
-    "@pnpm/list": "^1000.0.5",
-    "@pnpm/types": "^1000.1.0",
+    "@pnpm/list": "^1000.0.6",
+    "@pnpm/types": "^1000.1.1",
     "pkg-types": "^1.3.1",
     "unbuild": "^3.3.1"
   },