node-modules-tools 0.0.6 → 0.0.8

package/dist/chunks/{pnpm.mjs → index.mjs}

@@ -36,7 +36,10 @@ async function getDependenciesTree(options) {
       cwd: options.cwd
     }
   });
-  return await import('./json-parse-stream.mjs').then((r) => r.parseJsonStream(process.process.stdout));
+  const json = await import('./json-parse-stream.mjs').then((r) => r.parseJsonStream(process.process.stdout));
+  if (!Array.isArray(json))
+    throw new Error(`Failed to parse \`pnpm ls\` output, expected an array but got: ${String(json)}`);
+  return json;
 }
 async function listPackageDependencies(options) {
   const root = await resolveRoot(options) || options.cwd;

package/dist/index.d.mts

@@ -1,35 +1,23 @@
-type PackageModuleTypeSimple = 'cjs' | 'esm';
-type PackageModuleType = 'cjs' | 'esm' | 'dual' | 'faux' | 'dts';
-interface ListPackageDependenciesOptions {
+import { AgentName } from 'package-manager-detector';
+
+interface BaseOptions {
     /**
      * Current working directory
      */
     cwd: string;
-    /**
-     * Depeth of the dependency tree
-     */
-    depth: number;
-    /**
-     * Should it list dependencies of all packages in the monorepo
-     */
-    monorepo: boolean;
-    /**
-     * Filter if a package should be included and continue traversing
-     */
-    traverseFilter?: (node: PackageNodeRaw) => boolean;
 }
-interface ListPackageDependenciesRawResult {
-    root: string;
-    packageManager: string;
-    packageManagerVersion?: string;
-    packages: Map<string, PackageNodeRaw>;
-}
-interface ListPackageDependenciesBaseResult extends ListPackageDependenciesRawResult {
-    packages: Map<string, PackageNodeBase>;
-}
-interface ListPackageDependenciesResult extends ListPackageDependenciesBaseResult {
-    packages: Map<string, PackageNode>;
+
+interface PackageInstallSizeInfo {
+    bytes: number;
+    categories: Partial<Record<FileCategory, {
+        bytes: number;
+        count: number;
+    }>>;
 }
+type FileCategory = 'comp' | 'css' | 'doc' | 'dts' | 'html' | 'image' | 'js' | 'json' | 'other' | 'test' | 'ts' | 'bin' | 'map' | 'wasm' | 'flow' | 'font';
+
+type PackageModuleTypeSimple = 'cjs' | 'esm';
+type PackageModuleType = 'cjs' | 'esm' | 'dual' | 'faux' | 'dts';
 interface PackageNodeRaw {
     /** Package Name */
     name: string;
@@ -70,17 +58,48 @@ interface PackageNode extends PackageNodeBase {
         repository?: string;
         homepage?: string;
         engines?: Record<string, string>;
+        installSize?: PackageInstallSizeInfo;
     };
 }
 
-declare const PackageModuleTypes: readonly PackageModuleType[];
+interface ListPackageDependenciesOptions extends BaseOptions {
+    /**
+     * Depeth of the dependency tree
+     */
+    depth: number;
+    /**
+     * Should it list dependencies of all packages in the monorepo
+     */
+    monorepo: boolean;
+    /**
+     * Filter if a package should be included and continue traversing
+     */
+    traverseFilter?: (node: PackageNodeRaw) => boolean;
+}
+interface ListPackageDependenciesRawResult {
+    root: string;
+    packageManager: string;
+    packageManagerVersion?: string;
+    packages: Map<string, PackageNodeRaw>;
+}
+interface ListPackageDependenciesBaseResult extends ListPackageDependenciesRawResult {
+    packages: Map<string, PackageNodeBase>;
+}
+interface ListPackageDependenciesResult extends ListPackageDependenciesBaseResult {
+    packages: Map<string, PackageNode>;
+}
+
+declare function getPackageManager(options: BaseOptions): Promise<AgentName>;
 
 /**
  * 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 listPackageDependenciesRaw(manager: AgentName, options: ListPackageDependenciesOptions): Promise<ListPackageDependenciesRawResult>;
+
+declare const PackageModuleTypes: readonly PackageModuleType[];
+
 declare function listPackageDependencies(options: ListPackageDependenciesOptions): Promise<ListPackageDependenciesResult>;
 
 /**
@@ -89,8 +108,9 @@ declare function listPackageDependencies(options: ListPackageDependenciesOptions
  *
  * - Set `module` to the resolved module type (cjs, esm, dual, faux, none).
  */
-declare function resolvePackage(pkg: PackageNodeBase): Promise<PackageNode>;
+declare function resolvePackage(_packageManager: AgentName, pkg: PackageNodeBase, _options: BaseOptions): Promise<PackageNode>;
 
 declare function stripBomTag(content: string): string;
+declare function warnOnce(message: string): void;
 
-export { type ListPackageDependenciesBaseResult, type ListPackageDependenciesOptions, type ListPackageDependenciesRawResult, type ListPackageDependenciesResult, type PackageModuleType, type PackageModuleTypeSimple, PackageModuleTypes, type PackageNode, type PackageNodeBase, type PackageNodeRaw, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag };
+export { type BaseOptions, type FileCategory, type ListPackageDependenciesBaseResult, type ListPackageDependenciesOptions, type ListPackageDependenciesRawResult, type ListPackageDependenciesResult, type PackageInstallSizeInfo, type PackageModuleType, type PackageModuleTypeSimple, PackageModuleTypes, type PackageNode, type PackageNodeBase, type PackageNodeRaw, getPackageManager, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag, warnOnce };

package/dist/index.d.ts

@@ -1,35 +1,23 @@
-type PackageModuleTypeSimple = 'cjs' | 'esm';
-type PackageModuleType = 'cjs' | 'esm' | 'dual' | 'faux' | 'dts';
-interface ListPackageDependenciesOptions {
+import { AgentName } from 'package-manager-detector';
+
+interface BaseOptions {
     /**
      * Current working directory
      */
     cwd: string;
-    /**
-     * Depeth of the dependency tree
-     */
-    depth: number;
-    /**
-     * Should it list dependencies of all packages in the monorepo
-     */
-    monorepo: boolean;
-    /**
-     * Filter if a package should be included and continue traversing
-     */
-    traverseFilter?: (node: PackageNodeRaw) => boolean;
 }
-interface ListPackageDependenciesRawResult {
-    root: string;
-    packageManager: string;
-    packageManagerVersion?: string;
-    packages: Map<string, PackageNodeRaw>;
-}
-interface ListPackageDependenciesBaseResult extends ListPackageDependenciesRawResult {
-    packages: Map<string, PackageNodeBase>;
-}
-interface ListPackageDependenciesResult extends ListPackageDependenciesBaseResult {
-    packages: Map<string, PackageNode>;
+
+interface PackageInstallSizeInfo {
+    bytes: number;
+    categories: Partial<Record<FileCategory, {
+        bytes: number;
+        count: number;
+    }>>;
 }
+type FileCategory = 'comp' | 'css' | 'doc' | 'dts' | 'html' | 'image' | 'js' | 'json' | 'other' | 'test' | 'ts' | 'bin' | 'map' | 'wasm' | 'flow' | 'font';
+
+type PackageModuleTypeSimple = 'cjs' | 'esm';
+type PackageModuleType = 'cjs' | 'esm' | 'dual' | 'faux' | 'dts';
 interface PackageNodeRaw {
     /** Package Name */
     name: string;
@@ -70,17 +58,48 @@ interface PackageNode extends PackageNodeBase {
         repository?: string;
         homepage?: string;
         engines?: Record<string, string>;
+        installSize?: PackageInstallSizeInfo;
     };
 }
 
-declare const PackageModuleTypes: readonly PackageModuleType[];
+interface ListPackageDependenciesOptions extends BaseOptions {
+    /**
+     * Depeth of the dependency tree
+     */
+    depth: number;
+    /**
+     * Should it list dependencies of all packages in the monorepo
+     */
+    monorepo: boolean;
+    /**
+     * Filter if a package should be included and continue traversing
+     */
+    traverseFilter?: (node: PackageNodeRaw) => boolean;
+}
+interface ListPackageDependenciesRawResult {
+    root: string;
+    packageManager: string;
+    packageManagerVersion?: string;
+    packages: Map<string, PackageNodeRaw>;
+}
+interface ListPackageDependenciesBaseResult extends ListPackageDependenciesRawResult {
+    packages: Map<string, PackageNodeBase>;
+}
+interface ListPackageDependenciesResult extends ListPackageDependenciesBaseResult {
+    packages: Map<string, PackageNode>;
+}
+
+declare function getPackageManager(options: BaseOptions): Promise<AgentName>;
 
 /**
  * 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 listPackageDependenciesRaw(manager: AgentName, options: ListPackageDependenciesOptions): Promise<ListPackageDependenciesRawResult>;
+
+declare const PackageModuleTypes: readonly PackageModuleType[];
+
 declare function listPackageDependencies(options: ListPackageDependenciesOptions): Promise<ListPackageDependenciesResult>;
 
 /**
@@ -89,8 +108,9 @@ declare function listPackageDependencies(options: ListPackageDependenciesOptions
  *
  * - Set `module` to the resolved module type (cjs, esm, dual, faux, none).
  */
-declare function resolvePackage(pkg: PackageNodeBase): Promise<PackageNode>;
+declare function resolvePackage(_packageManager: AgentName, pkg: PackageNodeBase, _options: BaseOptions): Promise<PackageNode>;
 
 declare function stripBomTag(content: string): string;
+declare function warnOnce(message: string): void;
 
-export { type ListPackageDependenciesBaseResult, type ListPackageDependenciesOptions, type ListPackageDependenciesRawResult, type ListPackageDependenciesResult, type PackageModuleType, type PackageModuleTypeSimple, PackageModuleTypes, type PackageNode, type PackageNodeBase, type PackageNodeRaw, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag };
+export { type BaseOptions, type FileCategory, type ListPackageDependenciesBaseResult, type ListPackageDependenciesOptions, type ListPackageDependenciesRawResult, type ListPackageDependenciesResult, type PackageInstallSizeInfo, type PackageModuleType, type PackageModuleTypeSimple, PackageModuleTypes, type PackageNode, type PackageNodeBase, type PackageNodeRaw, getPackageManager, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag, warnOnce };

package/dist/index.mjs

@@ -1,10 +1,98 @@
+import pLimit from 'p-limit';
 import { detect } from 'package-manager-detector';
 import fs from 'node:fs/promises';
-import { join } from 'pathe';
+import { join as join$1 } from 'pathe';
+import { relative, join } from 'node:path';
+
+async function getPackageManager(options) {
+  const manager = await detect({
+    cwd: options.cwd
+  });
+  if (!manager)
+    throw new Error("Cannot detect package manager in the current path");
+  return manager.name;
+}
+
+async function listPackageDependenciesRaw(manager, options) {
+  let result;
+  if (manager === "pnpm")
+    result = await import('./chunks/index.mjs').then((r) => r.listPackageDependencies(options));
+  else
+    throw new Error(`Package manager ${manager} 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;
+}
 
 const PackageModuleTypes = Object.freeze(["cjs", "esm", "dual", "faux", "dts"]);
 
 function analyzePackageModuleType(pkgJson) {
+  if (pkgJson.name?.startsWith("@types/"))
+    return "dts";
   const { exports, main, type } = pkgJson;
   let cjs;
   let esm;
@@ -102,18 +190,114 @@ function analyzePackageModuleType(pkgJson) {
   }
 }
 
+async function getPackageInstallSize(pkg) {
+  if (pkg.workspace)
+    return;
+  if (pkg.name.startsWith("#"))
+    return;
+  if (pkg.version.match(/^(?:file|link|workspace):/))
+    return;
+  const root = pkg.filepath;
+  const files = [];
+  async function traverse(dir) {
+    for (const n of await fs.readdir(dir, { withFileTypes: true })) {
+      if (n.isFile()) {
+        files.push(join(dir, n.name));
+      } else if (n.isDirectory()) {
+        if (n.name.match(/^\.|^node_modules$/))
+          continue;
+        await traverse(join(dir, n.name));
+      }
+    }
+  }
+  await traverse(root);
+  const types = files.map((f) => guessFileCategory(relative(root, f)));
+  const categories = {};
+  const sizes = await Promise.all(files.map(getSingleFileSize));
+  let bytes = 0;
+  for (let i = 0; i < files.length; i++) {
+    bytes += sizes[i];
+    const type = types[i];
+    if (!categories[type])
+      categories[type] = { bytes: 0, count: 0 };
+    categories[type].bytes += sizes[i];
+    categories[type].count += 1;
+  }
+  return {
+    bytes,
+    categories
+  };
+}
+async function getSingleFileSize(file) {
+  try {
+    const stats = await fs.stat(file);
+    return stats.size;
+  } catch {
+    return 0;
+  }
+}
+function guessFileCategory(file) {
+  const parts = file.split(/\/|\\/g);
+  const dirs = parts.slice(0, -1);
+  const base = parts.at(-1);
+  if (dirs.some((d) => d.match(/^(?:test|tests|__tests__)$/)))
+    return "test";
+  if (dirs.some((d) => d.match(/^\.\w/)) || base.startsWith("."))
+    return "other";
+  if (dirs.some((d) => d.match(/^(?:bin|binary)$/)))
+    return "bin";
+  if (base.match(/\.(?:test|tests|spec|specs)\.\w+$/i))
+    return "test";
+  if (base.match(/\.map$/i))
+    return "map";
+  if (base.match(/\.d(\.\w+)?\.[cm]?tsx?$/i))
+    return "dts";
+  if (base.match(/\.exe$/i))
+    return "bin";
+  if (base.match(/\.(?:css|scss|sass|less)$/i))
+    return "css";
+  if (base.match(/\.(?:json[c5]?|ya?ml)$/i))
+    return "json";
+  if (base.match(/\.html?$/i))
+    return "html";
+  if (base.match(/\.[cm]?jsx?$/i))
+    return "js";
+  if (base.match(/\.[cm]?tsx?$/i))
+    return "ts";
+  if (base.match(/\.(?:vue|svelte|astro)$/i))
+    return "comp";
+  if (base.match(/\.(?:png|jpe?g|gif|svg)$/i))
+    return "image";
+  if (base.match(/\.(?:md|txt|mdx|markdown|rst)$/i))
+    return "doc";
+  if (base.match(/\.(?:wasm|wat)$/i))
+    return "wasm";
+  if (base.match(/\.flow$/i))
+    return "flow";
+  if (base.match(/\.(?:ttf|otf|woff2?)$/i))
+    return "font";
+  return "other";
+}
+
 function stripBomTag(content) {
   if (content.charCodeAt(0) === 65279) {
     return content.slice(1);
   }
   return content;
 }
+const warned = /* @__PURE__ */ new Set();
+function warnOnce(message) {
+  if (warned.has(message))
+    return;
+  warned.add(message);
+  console.warn(message);
+}
 
-async function resolvePackage(pkg) {
+async function resolvePackage(_packageManager, pkg, _options) {
   const _pkg = pkg;
   if (_pkg.resolved)
     return _pkg;
-  const content = await fs.readFile(join(pkg.filepath, "package.json"), "utf-8");
+  const content = await fs.readFile(join$1(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+"))
@@ -130,94 +314,18 @@ async function resolvePackage(pkg) {
     license: json.license,
     author: typeof json.author === "string" ? json.author : json.author?.url,
     repository,
-    homepage: json.homepage
+    homepage: json.homepage,
+    installSize: await getPackageInstallSize(_pkg)
   };
   return _pkg;
 }
 
-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)));
+  const packageManager = await getPackageManager(options);
+  const result = await listPackageDependenciesRaw(packageManager, options);
+  const limit = pLimit(10);
+  await Promise.all(Array.from(result.packages.values()).map((pkg) => limit(() => resolvePackage(packageManager, pkg))));
   return result;
 }
 
-export { PackageModuleTypes, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag };
+export { PackageModuleTypes, getPackageManager, listPackageDependencies, listPackageDependenciesRaw, resolvePackage, stripBomTag, warnOnce };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-modules-tools",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Tools for inspecting node_modules",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -33,6 +33,7 @@
     "dist"
   ],
   "dependencies": {
+    "p-limit": "^6.2.0",
     "package-manager-detector": "^0.2.9",
     "pathe": "^2.0.2",
     "tinyexec": "^0.3.2"