whyinstall 0.3.1 → 0.3.2

package/dist/cli.js

@@ -14,7 +14,7 @@ const program = new commander_1.Command();
 program
     .name('whyinstall')
     .description('Find why a dependency exists in your JS/TS project')
-    .version('0.3.1')
+    .version('0.3.2')
     .argument('<package-name>', 'Package name to analyze')
     .option('-j, --json', 'Output as JSON')
     .option('-c, --cwd <path>', 'Working directory', process.cwd())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whyinstall",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "CLI tool to find why a dependency exists in your JS/TS project",
   "main": "dist/index.js",
   "bin": {
@@ -21,6 +21,16 @@
   ],
   "author": "Saumya Kushwah",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/saumyakushwah/whyinstall.git"
+  },
+  "homepage": "https://saumyakushwah.github.io/whyinstall",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "dependencies": {
     "chalk": "^4.1.2",
     "commander": "^11.1.0"

package/src/analyzer.ts

@@ -1,255 +0,0 @@
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, dirname } from 'path';
-import { PackageInfo, DependencyPath, AnalyzeResult } from './types';
-import { detectPackageManager } from './packageManager';
-import { findFilesUsingPackage } from './fileFinder';
-
-interface PackageJson {
-  name?: string;
-  version?: string;
-  description?: string;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-  optionalDependencies?: Record<string, string>;
-}
-
-function readPackageJson(path: string): PackageJson | null {
-  try {
-    if (existsSync(path)) {
-      return JSON.parse(readFileSync(path, 'utf-8'));
-    }
-  } catch {
-    // ignore
-  }
-  return null;
-}
-
-function findPackageJsonPath(packageName: string, cwd: string): string | null {
-  try {
-    const resolved = require.resolve(`${packageName}/package.json`, { paths: [cwd] });
-    return resolved;
-  } catch {
-    const nodeModulesPath = join(cwd, 'node_modules', packageName, 'package.json');
-    if (existsSync(nodeModulesPath)) {
-      return nodeModulesPath;
-    }
-    return null;
-  }
-}
-
-function findPackageInNodeModules(packageName: string, basePath: string): string | null {
-  const possiblePaths = [
-    join(basePath, 'node_modules', packageName, 'package.json'),
-    join(basePath, packageName, 'package.json')
-  ];
-  
-  for (const path of possiblePaths) {
-    if (existsSync(path)) {
-      return path;
-    }
-  }
-  
-  const parent = dirname(basePath);
-  if (parent !== basePath && parent !== '/') {
-    return findPackageInNodeModules(packageName, parent);
-  }
-  
-  return null;
-}
-
-function findPackageSize(packagePath: string): number | undefined {
-  try {
-    const stats = statSync(packagePath);
-    if (stats.isDirectory()) {
-      let totalSize = 0;
-      const files = readdirSync(packagePath);
-      for (const file of files) {
-        const filePath = join(packagePath, file);
-        try {
-          const fileStats = statSync(filePath);
-          if (fileStats.isDirectory()) {
-            const subSize = findPackageSize(filePath);
-            if (subSize) totalSize += subSize;
-          } else {
-            totalSize += fileStats.size;
-          }
-        } catch {
-          // ignore
-        }
-      }
-      return totalSize;
-    }
-  } catch {
-    // ignore
-  }
-  return undefined;
-}
-
-function getAllDependencies(pkg: PackageJson): Record<string, 'prod' | 'dev' | 'peer' | 'optional'> {
-  const deps: Record<string, 'prod' | 'dev' | 'peer' | 'optional'> = {};
-  
-  if (pkg.dependencies) {
-    for (const name of Object.keys(pkg.dependencies)) {
-      deps[name] = 'prod';
-    }
-  }
-  if (pkg.devDependencies) {
-    for (const name of Object.keys(pkg.devDependencies)) {
-      deps[name] = 'dev';
-    }
-  }
-  if (pkg.peerDependencies) {
-    for (const name of Object.keys(pkg.peerDependencies)) {
-      deps[name] = 'peer';
-    }
-  }
-  if (pkg.optionalDependencies) {
-    for (const name of Object.keys(pkg.optionalDependencies)) {
-      deps[name] = 'optional';
-    }
-  }
-  
-  return deps;
-}
-
-function findDependencyPaths(
-  targetPackage: string,
-  cwd: string,
-  maxDepth: number = 10
-): DependencyPath[] {
-  const paths: DependencyPath[] = [];
-  const visited = new Set<string>();
-  
-  interface QueueItem {
-    packageName: string;
-    chain: string[];
-    packageJsonPath: string;
-  }
-  
-  const rootPackageJson = join(cwd, 'package.json');
-  if (!existsSync(rootPackageJson)) {
-    return [];
-  }
-  
-  const queue: QueueItem[] = [{ packageName: '', chain: [], packageJsonPath: rootPackageJson }];
-  
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    
-    if (current.chain.length > maxDepth) {
-      continue;
-    }
-    
-    const pkg = readPackageJson(current.packageJsonPath);
-    if (!pkg) {
-      continue;
-    }
-    
-    const allDeps = getAllDependencies(pkg);
-    const currentPackageName = current.packageName || pkg.name || '';
-    
-    const visitKey = `${currentPackageName}:${current.packageJsonPath}`;
-    if (visited.has(visitKey)) {
-      continue;
-    }
-    visited.add(visitKey);
-    
-    for (const [depName, depType] of Object.entries(allDeps)) {
-      if (depName === targetPackage) {
-        const chain = currentPackageName 
-          ? (current.chain.length > 0 ? [...current.chain, currentPackageName, depName] : [currentPackageName, depName])
-          : [depName];
-        paths.push({
-          chain,
-          type: depType,
-          packageJsonPath: current.packageJsonPath
-        });
-      } else {
-        const depPackageJsonPath = findPackageInNodeModules(depName, dirname(current.packageJsonPath));
-        if (depPackageJsonPath) {
-          const newChain = currentPackageName 
-            ? (current.chain.length > 0 ? [...current.chain, currentPackageName] : [currentPackageName])
-            : [];
-          queue.push({
-            packageName: depName,
-            chain: newChain,
-            packageJsonPath: depPackageJsonPath
-          });
-        }
-      }
-    }
-  }
-  
-  return paths;
-}
-
-function formatSize(bytes: number | undefined): string {
-  if (!bytes) return '';
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
-
-export function analyzePackage(packageName: string, cwd: string = process.cwd()): AnalyzeResult {
-  const rootPackageJson = join(cwd, 'package.json');
-  const packageJsonPath = findPackageJsonPath(packageName, cwd);
-  if (!packageJsonPath) {
-    throw new Error(`Package "${packageName}" not found in node_modules`);
-  }
-  
-  const packageDir = dirname(packageJsonPath);
-  const pkg = readPackageJson(packageJsonPath);
-  const version = pkg?.version || 'unknown';
-  const description = pkg?.description;
-  
-  const size = findPackageSize(packageDir);
-  
-  let paths = findDependencyPaths(packageName, cwd);
-  
-  // Deduplicate paths with same chain and type
-  const pathKeys = new Set<string>();
-  paths = paths.filter(path => {
-    const key = `${path.type}:${path.chain.join('->')}`;
-    if (pathKeys.has(key)) {
-      return false;
-    }
-    pathKeys.add(key);
-    return true;
-  });
-  
-  const suggestions: string[] = [];
-  
-  if (paths.length === 0) {
-    suggestions.push(`Package "${packageName}" is not in dependency tree`);
-  } else {
-    const devPaths = paths.filter(p => p.type === 'dev');
-    const peerPaths = paths.filter(p => p.type === 'peer');
-    
-    if (devPaths.length > 0) {
-      suggestions.push(`Consider removing from devDependencies if not needed for development`);
-    }
-    if (peerPaths.length > 0) {
-      suggestions.push(`This is a peer dependency - ensure all consumers satisfy the peer requirement`);
-    }
-    
-    const directDeps = paths.filter(p => p.chain.length === 1 && p.packageJsonPath === rootPackageJson);
-    if (directDeps.length > 0 && paths.length > directDeps.length) {
-      suggestions.push(`Can be removed from direct dependencies - it's installed transitively`);
-    }
-  }
-  
-  const sourceFiles = findFilesUsingPackage(packageName, cwd);
-  
-  return {
-    package: {
-      name: packageName,
-      version,
-      description,
-      size,
-      paths,
-      sourceFiles: sourceFiles.length > 0 ? sourceFiles : undefined
-    },
-    suggestions
-  };
-}

package/src/cli.ts

@@ -1,47 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { analyzePackage } from './analyzer';
-import { formatOutput, formatSizeMap } from './formatter';
-import { detectPackageManager } from './packageManager';
-import { analyzeSizeMap } from './sizeMapAnalyzer';
-
-const program = new Command();
-
-program
-  .name('whyinstall')
-  .description('Find why a dependency exists in your JS/TS project')
-  .version('0.3.1')
-  .argument('<package-name>', 'Package name to analyze')
-  .option('-j, --json', 'Output as JSON')
-  .option('-c, --cwd <path>', 'Working directory', process.cwd())
-  .option('-s, --size-map', 'Show bundle size impact breakdown')
-  .action((packageName: string, options: { json?: boolean; cwd?: string; sizeMap?: boolean }) => {
-    try {
-      const cwd = options.cwd || process.cwd();
-      const pm = detectPackageManager(cwd);
-      
-      if (!options.json) {
-        console.log(`\n${chalk.gray(`Detected package manager: ${pm}`)}\n`);
-      }
-      
-      if (options.sizeMap) {
-        const result = analyzeSizeMap(packageName, cwd);
-        const output = formatSizeMap(result, options.json);
-        console.log(output);
-      } else {
-        const result = analyzePackage(packageName, cwd);
-        const output = formatOutput(result, options.json);
-        console.log(output);
-      }
-      
-      process.exit(0);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(chalk.red(`Error: ${message}`));
-      process.exit(1);
-    }
-  });
-
-program.parse();

package/src/fileFinder.ts

@@ -1,78 +0,0 @@
-import { readdirSync, readFileSync, statSync } from 'fs';
-import { join, extname } from 'path';
-
-const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-const IGNORE_DIRS = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage'];
-
-function shouldIgnoreDir(dirName: string): boolean {
-  return IGNORE_DIRS.includes(dirName) || dirName.startsWith('.');
-}
-
-function isSourceFile(filePath: string): boolean {
-  return SOURCE_EXTENSIONS.includes(extname(filePath));
-}
-
-export function findSourceFiles(dir: string, maxDepth: number = 5, currentDepth: number = 0): string[] {
-  if (currentDepth > maxDepth) {
-    return [];
-  }
-
-  const files: string[] = [];
-
-  try {
-    const entries = readdirSync(dir);
-    
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      
-      try {
-        const stats = statSync(fullPath);
-        
-        if (stats.isDirectory()) {
-          if (!shouldIgnoreDir(entry)) {
-            files.push(...findSourceFiles(fullPath, maxDepth, currentDepth + 1));
-          }
-        } else if (stats.isFile() && isSourceFile(fullPath)) {
-          files.push(fullPath);
-        }
-      } catch {
-        // ignore errors for individual files/dirs
-      }
-    }
-  } catch {
-    // ignore errors
-  }
-
-  return files;
-}
-
-function fileContainsPackage(filePath: string, packageName: string): boolean {
-  try {
-    const content = readFileSync(filePath, 'utf-8');
-    
-    const patterns = [
-      new RegExp(`require\\(['"]${packageName}(/.*)?['"]\\)`, 'g'),
-      new RegExp(`from\\s+['"]${packageName}(/.*)?['"]`, 'g'),
-      new RegExp(`import\\s+.*\\s+from\\s+['"]${packageName}(/.*)?['"]`, 'g'),
-      new RegExp(`import\\s+['"]${packageName}(/.*)?['"]`, 'g'),
-    ];
-    
-    return patterns.some(pattern => pattern.test(content));
-  } catch {
-    return false;
-  }
-}
-
-export function findFilesUsingPackage(packageName: string, cwd: string): string[] {
-  const sourceFiles = findSourceFiles(cwd);
-  const matchingFiles: string[] = [];
-  
-  for (const file of sourceFiles) {
-    if (fileContainsPackage(file, packageName)) {
-      const relativePath = file.replace(cwd + '/', '');
-      matchingFiles.push(relativePath);
-    }
-  }
-  
-  return matchingFiles;
-}

package/src/formatter.ts

@@ -1,126 +0,0 @@
-import chalk from 'chalk';
-import { AnalyzeResult, DependencyPath, SizeMapResult } from './types';
-
-function formatSize(bytes: number | undefined): string {
-  if (!bytes) return '';
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
-
-function formatChain(chain: string[], isLast: boolean): string {
-  if (chain.length === 0) return '';
-  
-  const parts: string[] = [];
-  
-  for (let i = 0; i < chain.length; i++) {
-    const isLastInChain = i === chain.length - 1;
-    let prefix: string;
-    let indent = '';
-    
-    if (i === 0) {
-      prefix = '';
-      indent = '   ';
-    } else {
-      indent = '   ' + ' '.repeat((i - 1) * 3);
-      if (isLastInChain) {
-        prefix = '└─> ';
-      } else {
-        prefix = '├─> ';
-      }
-    }
-    
-    let packageName = chain[i];
-    if (packageName.includes('node_modules/')) {
-      packageName = chalk.gray(packageName.replace(/.*node_modules\//, 'node_modules/'));
-    } else if (packageName.includes('/')) {
-      packageName = chalk.white(packageName);
-    } else {
-      packageName = chalk.cyan(packageName);
-    }
-    
-    parts.push(`${indent}${prefix}${packageName}`);
-  }
-  
-  return parts.join('\n');
-}
-
-function getTypeLabel(type: DependencyPath['type']): string {
-  const labels = {
-    prod: chalk.green('prod'),
-    dev: chalk.yellow('dev'),
-    peer: chalk.blue('peer'),
-    optional: chalk.gray('optional')
-  };
-  return labels[type] || type;
-}
-
-export function formatOutput(result: AnalyzeResult, json: boolean = false): string {
-  if (json) {
-    return JSON.stringify(result, null, 2);
-  }
-  
-  const { package: pkg, suggestions } = result;
-  const sizeStr = pkg.size ? formatSize(pkg.size) : '';
-  const sizeDisplay = sizeStr ? ` (${sizeStr})` : '';
-  
-  let output = '';
-  output += chalk.bold.cyan(`${pkg.name}`) + chalk.gray(` v${pkg.version}`) + chalk.dim(`${sizeDisplay}`) + '\n';
-  if (pkg.description) {
-    output += chalk.white(`  ${pkg.description}\n`);
-  }
-  output += '\n' + chalk.dim(`  installed via ${pkg.paths.length} path${pkg.paths.length !== 1 ? 's' : ''}\n\n`);
-  
-  if (pkg.paths.length === 0) {
-    output += chalk.yellow('  No dependency paths found.\n');
-  } else {
-    pkg.paths.forEach((path, index) => {
-      const pathNum = chalk.gray(`${index + 1}.`);
-      const typeLabel = getTypeLabel(path.type);
-      
-      let chainDisplay = path.chain.length > 0 ? path.chain : [pkg.name];
-      
-      output += `${pathNum} ${typeLabel}\n`;
-      output += formatChain(chainDisplay, index === pkg.paths.length - 1);
-      output += '\n';
-    });
-  }
-  
-  if (pkg.sourceFiles && pkg.sourceFiles.length > 0) {
-    output += '\n' + chalk.bold(`Used in (${pkg.sourceFiles.length}):`) + '\n';
-    pkg.sourceFiles.forEach((file) => {
-      output += `  ${chalk.blue(file)}\n`;
-    });
-  }
-  
-  if (suggestions.length > 0) {
-    output += '\n' + chalk.bold('Suggested actions:') + '\n';
-    suggestions.forEach((suggestion, index) => {
-      output += `  ${index + 1}. ${chalk.gray(suggestion)}\n`;
-    });
-  }
-  
-  return output;
-}
-
-export function formatSizeMap(result: SizeMapResult, json: boolean = false): string {
-  if (json) {
-    return JSON.stringify(result, null, 2);
-  }
-
-  let output = '';
-  output += chalk.bold.cyan(`Size map for: ${result.packageName}\n\n`);
-  output += chalk.bold(`${result.packageName} total impact: `) + chalk.green(formatSize(result.totalSize)) + '\n\n';
-  output += chalk.bold('Breakdown:\n');
-
-  for (const item of result.breakdown) {
-    const sizeStr = formatSize(item.size);
-    output += chalk.gray('- ') + chalk.white(item.name) + chalk.gray(': ') + chalk.yellow(sizeStr) + '\n';
-  }
-
-  if (result.percentOfNodeModules !== undefined && result.percentOfNodeModules > 0) {
-    output += '\n' + chalk.dim(`This package contributes ${result.percentOfNodeModules.toFixed(1)}% of your vendor bundle.\n`);
-  }
-
-  return output;
-}

package/src/packageManager.ts

@@ -1,25 +0,0 @@
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { PackageManager } from './types';
-
-export function detectPackageManager(cwd: string = process.cwd()): PackageManager {
-  if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
-    return 'pnpm';
-  }
-  if (existsSync(join(cwd, 'yarn.lock'))) {
-    return 'yarn';
-  }
-  if (existsSync(join(cwd, 'package-lock.json'))) {
-    return 'npm';
-  }
-  return 'npm';
-}
-
-export function getLockFilePath(cwd: string, pm: PackageManager): string {
-  const paths = {
-    npm: 'package-lock.json',
-    yarn: 'yarn.lock',
-    pnpm: 'pnpm-lock.yaml'
-  };
-  return join(cwd, paths[pm]);
-}

package/src/sizeMapAnalyzer.ts

@@ -1,145 +0,0 @@
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, dirname, extname } from 'path';
-import { SizeMapResult, SizeBreakdown } from './types';
-
-interface PackageJson {
-  name?: string;
-  dependencies?: Record<string, string>;
-}
-
-const JS_EXTENSIONS = new Set(['.js', '.mjs', '.cjs']);
-const EXCLUDE_DIRS = new Set(['test', 'tests', '__tests__', 'docs', 'doc', 'types', '@types', 'typings', '.d.ts']);
-
-function readPackageJson(path: string): PackageJson | null {
-  try {
-    if (existsSync(path)) {
-      return JSON.parse(readFileSync(path, 'utf-8'));
-    }
-  } catch {}
-  return null;
-}
-
-function shouldExclude(name: string): boolean {
-  const lower = name.toLowerCase();
-  return EXCLUDE_DIRS.has(lower) || lower.endsWith('.d.ts') || lower.startsWith('.');
-}
-
-function calculateJsSize(dir: string): number {
-  let total = 0;
-  try {
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-      if (shouldExclude(entry)) continue;
-      const fullPath = join(dir, entry);
-      try {
-        const stats = statSync(fullPath);
-        if (stats.isDirectory()) {
-          if (entry !== 'node_modules') {
-            total += calculateJsSize(fullPath);
-          }
-        } else if (JS_EXTENSIONS.has(extname(entry).toLowerCase())) {
-          total += stats.size;
-        }
-      } catch {}
-    }
-  } catch {}
-  return total;
-}
-
-function getNodeModulesSize(cwd: string): number {
-  const nmPath = join(cwd, 'node_modules');
-  let total = 0;
-  
-  function walkDir(dir: string): void {
-    try {
-      const entries = readdirSync(dir);
-      for (const entry of entries) {
-        const fullPath = join(dir, entry);
-        try {
-          const stats = statSync(fullPath);
-          if (stats.isDirectory()) {
-            walkDir(fullPath);
-          } else if (JS_EXTENSIONS.has(extname(entry).toLowerCase())) {
-            total += stats.size;
-          }
-        } catch {}
-      }
-    } catch {}
-  }
-  
-  walkDir(nmPath);
-  return total;
-}
-
-function findPackagePath(packageName: string, cwd: string): string | null {
-  const directPath = join(cwd, 'node_modules', packageName);
-  if (existsSync(directPath)) return directPath;
-  
-  // Handle scoped packages
-  if (packageName.startsWith('@')) {
-    const parts = packageName.split('/');
-    const scopedPath = join(cwd, 'node_modules', parts[0], parts[1]);
-    if (existsSync(scopedPath)) return scopedPath;
-  }
-  return null;
-}
-
-function getDependencyTree(packagePath: string, cwd: string, visited: Set<string> = new Set()): SizeBreakdown[] {
-  const breakdown: SizeBreakdown[] = [];
-  const pkgJsonPath = join(packagePath, 'package.json');
-  const pkg = readPackageJson(pkgJsonPath);
-  
-  if (!pkg?.dependencies) return breakdown;
-  
-  for (const depName of Object.keys(pkg.dependencies)) {
-    if (visited.has(depName)) continue;
-    visited.add(depName);
-    
-    // Check nested node_modules first
-    let depPath = join(packagePath, 'node_modules', depName);
-    if (!existsSync(depPath)) {
-      depPath = join(cwd, 'node_modules', depName);
-    }
-    
-    if (existsSync(depPath)) {
-      const size = calculateJsSize(depPath);
-      if (size > 0) {
-        breakdown.push({ name: depName, size });
-      }
-      // Recursively get sub-dependencies
-      const subDeps = getDependencyTree(depPath, cwd, visited);
-      breakdown.push(...subDeps);
-    }
-  }
-  
-  return breakdown;
-}
-
-export function analyzeSizeMap(packageName: string, cwd: string = process.cwd()): SizeMapResult {
-  const packagePath = findPackagePath(packageName, cwd);
-  if (!packagePath) {
-    throw new Error(`Package "${packageName}" not found in node_modules`);
-  }
-  
-  const ownSize = calculateJsSize(packagePath);
-  const visited = new Set<string>([packageName]);
-  const depBreakdown = getDependencyTree(packagePath, cwd, visited);
-  
-  const breakdown: SizeBreakdown[] = [
-    { name: packageName, size: ownSize },
-    ...depBreakdown.sort((a, b) => b.size - a.size)
-  ];
-  
-  const totalSize = breakdown.reduce((sum, item) => sum + item.size, 0);
-  const nodeModulesSize = getNodeModulesSize(cwd);
-  const percentOfNodeModules = nodeModulesSize > 0 ? (totalSize / nodeModulesSize) * 100 : 0;
-  
-  return {
-    packageName,
-    totalSize,
-    breakdown,
-    nodeModulesSize,
-    percentOfNodeModules
-  };
-}
-

package/src/types.ts

@@ -1,34 +0,0 @@
-export interface DependencyPath {
-  chain: string[];
-  type: 'prod' | 'dev' | 'peer' | 'optional';
-  packageJsonPath?: string;
-}
-
-export interface PackageInfo {
-  name: string;
-  version: string;
-  description?: string;
-  size?: number;
-  paths: DependencyPath[];
-  sourceFiles?: string[];
-}
-
-export interface AnalyzeResult {
-  package: PackageInfo;
-  suggestions: string[];
-}
-
-export type PackageManager = 'npm' | 'yarn' | 'pnpm';
-
-export interface SizeBreakdown {
-  name: string;
-  size: number;
-}
-
-export interface SizeMapResult {
-  packageName: string;
-  totalSize: number;
-  breakdown: SizeBreakdown[];
-  nodeModulesSize?: number;
-  percentOfNodeModules?: number;
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}