ts-unused 1.0.1 → 1.0.3

package/dist/analyzeProject.js

@@ -0,0 +1,131 @@
+import path from "node:path";
+import { Project } from "ts-morph";
+import { defaultConfig } from "./config";
+import { findNeverReturnedTypes } from "./findNeverReturnedTypes";
+import { findUnusedExports } from "./findUnusedExports";
+import { findUnusedProperties } from "./findUnusedProperties";
+import { hasNoCheck } from "./hasNoCheck";
+import { createIsTestFile, isTestFile as defaultIsTestFile } from "./isTestFile";
+import { matchesFilePattern } from "./patternMatcher";
+export function analyzeProject(tsConfigPath, onProgress, targetFilePath, isTestFileOrOptions) {
+    // Handle backward compatibility: can pass IsTestFileFn directly or options object
+    let options = {};
+    if (typeof isTestFileOrOptions === "function") {
+        options = { isTestFile: isTestFileOrOptions };
+    }
+    else if (isTestFileOrOptions) {
+        options = isTestFileOrOptions;
+    }
+    const config = {
+        ...defaultConfig,
+        ...options.config,
+    };
+    // Determine the isTestFile function
+    const isTestFile = options.isTestFile
+        ? options.isTestFile
+        : config.testFilePatterns
+            ? createIsTestFile(config.testFilePatterns)
+            : defaultIsTestFile;
+    const project = new Project({
+        tsConfigFilePath: tsConfigPath,
+    });
+    const tsConfigDir = path.dirname(tsConfigPath);
+    // Get total file count for progress reporting
+    const allSourceFiles = project.getSourceFiles();
+    const filesToAnalyze = allSourceFiles.filter((sf) => {
+        if (isTestFile(sf)) {
+            return false;
+        }
+        if (hasNoCheck(sf)) {
+            return false;
+        }
+        if (targetFilePath && sf.getFilePath() !== targetFilePath) {
+            return false;
+        }
+        // Check if file should be ignored based on patterns
+        if (config.ignoreFilePatterns.length > 0 && matchesFilePattern(sf.getFilePath(), config.ignoreFilePatterns)) {
+            return false;
+        }
+        return true;
+    });
+    const totalFiles = filesToAnalyze.length;
+    let currentFile = 0;
+    const filesProcessed = new Set();
+    const progressCallback = onProgress
+        ? (filePath) => {
+            // Only increment once per file (called from both exports and properties analysis)
+            if (!filesProcessed.has(filePath)) {
+                filesProcessed.add(filePath);
+                currentFile++;
+                onProgress(currentFile, totalFiles, filePath);
+            }
+        }
+        : undefined;
+    // Build options for child functions
+    const exportOptions = {
+        ignoreFilePatterns: config.ignoreFilePatterns,
+        ignoreExports: config.ignoreExports,
+        ignoreModuleAugmentations: config.ignoreModuleAugmentations,
+    };
+    const propertyOptions = {
+        ignoreFilePatterns: config.ignoreFilePatterns,
+        ignoreProperties: config.ignoreProperties,
+        ignoreTypes: config.ignoreTypes,
+    };
+    const neverReturnedOptions = {
+        ignoreFilePatterns: config.ignoreFilePatterns,
+    };
+    // Analyze based on config flags
+    const unusedExports = config.analyzeExports
+        ? findUnusedExports(project, tsConfigDir, isTestFile, progressCallback, targetFilePath, exportOptions)
+        : [];
+    const unusedProperties = config.analyzeProperties
+        ? findUnusedProperties(project, tsConfigDir, isTestFile, progressCallback, targetFilePath, propertyOptions)
+        : [];
+    const neverReturnedTypes = config.analyzeNeverReturnedTypes
+        ? findNeverReturnedTypes(project, tsConfigDir, isTestFile, progressCallback, targetFilePath, neverReturnedOptions)
+        : [];
+    // Identify completely unused files (where all exports are unused)
+    const unusedFiles = [];
+    if (config.detectUnusedFiles) {
+        const fileExportCounts = new Map();
+        // Count total exports per file
+        for (const sourceFile of filesToAnalyze) {
+            const filePath = path.relative(tsConfigDir, sourceFile.getFilePath());
+            const exports = sourceFile.getExportedDeclarations();
+            const totalExports = exports.size;
+            if (totalExports > 0) {
+                fileExportCounts.set(filePath, { total: totalExports, unused: 0, testOnly: 0 });
+            }
+        }
+        // Count unused exports per file
+        for (const unusedExport of unusedExports) {
+            const counts = fileExportCounts.get(unusedExport.filePath);
+            if (counts) {
+                counts.unused++;
+                if (unusedExport.onlyUsedInTests) {
+                    counts.testOnly++;
+                }
+            }
+        }
+        // Identify files where all exports are unused AND not just test-only
+        // Files with any test-only exports should show individual exports with [INFO], not be listed as completely unused
+        for (const [filePath, counts] of fileExportCounts.entries()) {
+            // Only add to unusedFiles if:
+            // 1. All exports are "unused" (in the unusedExports list)
+            // 2. NONE of the exports are test-only (all are completely unused with severity: error)
+            const allExportsUnused = counts.total > 0 && counts.unused === counts.total;
+            const hasAnyTestOnlyExports = counts.testOnly > 0;
+            if (allExportsUnused && !hasAnyTestOnlyExports) {
+                unusedFiles.push(filePath);
+            }
+        }
+    }
+    const results = {
+        unusedExports,
+        unusedProperties,
+        unusedFiles,
+        neverReturnedTypes,
+    };
+    return results;
+}

package/dist/analyzeTypeAliases.d.ts

@@ -0,0 +1,9 @@
+import { type Project, type SourceFile, type TypeAliasDeclaration, type TypeElementTypes } from "ts-morph";
+import type { IsTestFileFn, UnusedPropertyResult } from "./types";
+export interface AnalyzeTypeAliasesOptions {
+    ignoreProperties?: string[];
+    ignoreTypes?: string[];
+}
+export declare function analyzeTypeLiteralMember(member: TypeElementTypes, typeName: string, sourceFile: SourceFile, tsConfigDir: string, isTestFile: IsTestFileFn, results: UnusedPropertyResult[], project: Project, options?: AnalyzeTypeAliasesOptions): void;
+export declare function analyzeTypeAlias(typeAlias: TypeAliasDeclaration, sourceFile: SourceFile, tsConfigDir: string, isTestFile: IsTestFileFn, results: UnusedPropertyResult[], project: Project, options?: AnalyzeTypeAliasesOptions): void;
+export declare function analyzeTypeAliases(sourceFile: SourceFile, tsConfigDir: string, isTestFile: IsTestFileFn, results: UnusedPropertyResult[], project: Project, options?: AnalyzeTypeAliasesOptions): void;

package/dist/analyzeTypeAliases.js

@@ -0,0 +1,70 @@
+import path from "node:path";
+import { Node } from "ts-morph";
+import { extractTodoComment } from "./extractTodoComment";
+import { isPropertyUnused } from "./isPropertyUnused";
+import { matchesPattern } from "./patternMatcher";
+export function analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isTestFile, results, project, options = {}) {
+    const { ignoreProperties = [] } = options;
+    if (!Node.isPropertySignature(member)) {
+        return;
+    }
+    const propertyName = member.getName();
+    // Skip ignored properties
+    if (ignoreProperties.length > 0 && matchesPattern(propertyName, ignoreProperties)) {
+        return;
+    }
+    const usage = isPropertyUnused(member, isTestFile, project);
+    if (!usage.isUnusedOrTestOnly) {
+        return;
+    }
+    const relativePath = path.relative(tsConfigDir, sourceFile.getFilePath());
+    const todoComment = extractTodoComment(member);
+    // Determine severity: warning for TODO, info for test-only, error for completely unused
+    let severity = "error";
+    if (todoComment) {
+        severity = "warning";
+    }
+    else if (usage.onlyUsedInTests) {
+        severity = "info";
+    }
+    const startPos = member.getStart();
+    const lineStartPos = member.getStartLinePos();
+    const character = startPos - lineStartPos + 1;
+    const endCharacter = character + propertyName.length;
+    const result = {
+        filePath: relativePath,
+        typeName,
+        propertyName,
+        line: member.getStartLineNumber(),
+        character,
+        endCharacter,
+        todoComment,
+        severity,
+        onlyUsedInTests: usage.onlyUsedInTests,
+    };
+    results.push(result);
+}
+export function analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, results, project, options = {}) {
+    const { ignoreTypes = [] } = options;
+    const typeName = typeAlias.getName();
+    // Skip ignored types
+    if (ignoreTypes.length > 0 && matchesPattern(typeName, ignoreTypes)) {
+        return;
+    }
+    const typeNode = typeAlias.getTypeNode();
+    if (!typeNode) {
+        return;
+    }
+    if (!Node.isTypeLiteral(typeNode)) {
+        return;
+    }
+    for (const member of typeNode.getMembers()) {
+        analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isTestFile, results, project, options);
+    }
+}
+export function analyzeTypeAliases(sourceFile, tsConfigDir, isTestFile, results, project, options = {}) {
+    const typeAliases = sourceFile.getTypeAliases();
+    for (const typeAlias of typeAliases) {
+        analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, results, project, options);
+    }
+}

package/dist/checkExportUsage.d.ts

@@ -0,0 +1,7 @@
+import { Node, type SourceFile } from "ts-morph";
+import type { IsTestFileFn, UnusedExportResult } from "./types";
+export interface CheckExportOptions {
+    ignoreExports?: string[];
+    ignoreModuleAugmentations?: boolean;
+}
+export declare function checkExportUsage(exportName: string, declarations: readonly Node[], sourceFile: SourceFile, tsConfigDir: string, isTestFile: IsTestFileFn, options?: CheckExportOptions): UnusedExportResult | null;

package/dist/checkExportUsage.js

@@ -0,0 +1,126 @@
+import path from "node:path";
+import { Node } from "ts-morph";
+import { matchesPattern } from "./patternMatcher";
+function getExportKind(declaration) {
+    if (Node.isFunctionDeclaration(declaration)) {
+        return "function";
+    }
+    if (Node.isClassDeclaration(declaration)) {
+        return "class";
+    }
+    if (Node.isInterfaceDeclaration(declaration)) {
+        return "interface";
+    }
+    if (Node.isTypeAliasDeclaration(declaration)) {
+        return "type";
+    }
+    if (Node.isEnumDeclaration(declaration)) {
+        return "enum";
+    }
+    if (Node.isModuleDeclaration(declaration)) {
+        return "namespace";
+    }
+    if (Node.isVariableDeclaration(declaration)) {
+        const parent = declaration.getParent();
+        if (Node.isVariableDeclarationList(parent)) {
+            const declarationKind = parent.getDeclarationKind();
+            if (declarationKind === "const") {
+                return "const";
+            }
+        }
+        return "variable";
+    }
+    return "export";
+}
+function getNameNode(declaration) {
+    if (Node.isFunctionDeclaration(declaration) ||
+        Node.isClassDeclaration(declaration) ||
+        Node.isInterfaceDeclaration(declaration) ||
+        Node.isTypeAliasDeclaration(declaration) ||
+        Node.isEnumDeclaration(declaration) ||
+        Node.isVariableDeclaration(declaration)) {
+        return declaration.getNameNode();
+    }
+    return undefined;
+}
+/**
+ * Checks if a declaration is a module augmentation (declare module "...").
+ */
+function isModuleAugmentation(declaration) {
+    if (Node.isModuleDeclaration(declaration)) {
+        // Module augmentations have a string literal as name (e.g., "library-name")
+        const nameNode = declaration.getNameNode();
+        if (Node.isStringLiteral(nameNode)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isTestFile, options = {}) {
+    const { ignoreExports = [], ignoreModuleAugmentations = true } = options;
+    const firstDeclaration = declarations[0];
+    if (!firstDeclaration) {
+        return null;
+    }
+    // Check if export should be ignored
+    if (ignoreExports.length > 0 && matchesPattern(exportName, ignoreExports)) {
+        return null;
+    }
+    // Check if this is a module augmentation that should be ignored
+    if (ignoreModuleAugmentations && isModuleAugmentation(firstDeclaration)) {
+        return null;
+    }
+    // Only report symbols defined in this file, not re-exports
+    const declarationSourceFile = firstDeclaration.getSourceFile();
+    if (declarationSourceFile.getFilePath() !== sourceFile.getFilePath()) {
+        return null;
+    }
+    if (!Node.isReferenceFindable(firstDeclaration)) {
+        return null;
+    }
+    const references = firstDeclaration.findReferences();
+    // Count references by type
+    let totalReferences = 0;
+    let testReferences = 0;
+    let nonTestReferences = 0;
+    for (const refGroup of references) {
+        const refs = refGroup.getReferences();
+        for (const ref of refs) {
+            const refSourceFile = ref.getSourceFile();
+            totalReferences++;
+            if (isTestFile(refSourceFile)) {
+                testReferences++;
+            }
+            else {
+                nonTestReferences++;
+            }
+        }
+    }
+    // An export is unused if it only has 1 reference (the definition itself)
+    const onlyUsedInTests = nonTestReferences === 1 && testReferences > 0;
+    if (totalReferences > 1 && !onlyUsedInTests) {
+        return null; // Used in production code
+    }
+    const kind = getExportKind(firstDeclaration);
+    const relativePath = path.relative(tsConfigDir, sourceFile.getFilePath());
+    // Determine severity: info for test-only, error for completely unused
+    const severity = onlyUsedInTests ? "info" : "error";
+    // Get the name node for accurate position highlighting
+    const nameNode = getNameNode(firstDeclaration);
+    const positionNode = nameNode || firstDeclaration;
+    const startPos = positionNode.getStart();
+    const lineStartPos = positionNode.getStartLinePos();
+    const character = startPos - lineStartPos + 1;
+    const endCharacter = character + exportName.length;
+    const result = {
+        filePath: relativePath,
+        exportName,
+        line: firstDeclaration.getStartLineNumber(),
+        character,
+        endCharacter,
+        kind,
+        severity,
+        onlyUsedInTests,
+    };
+    return result;
+}

package/dist/checkGitStatus.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check which files have local git changes (modified, staged, or untracked)
+ * Note: Checks the entire git repository, not just the working directory
+ * @param workingDir - The directory to check git status in (used to find git root)
+ * @returns Set of absolute file paths that have local changes
+ */
+export declare function checkGitStatus(workingDir: string): Set<string>;

package/dist/checkGitStatus.js

@@ -0,0 +1,49 @@
+import { execSync } from "node:child_process";
+import path from "node:path";
+/**
+ * Check which files have local git changes (modified, staged, or untracked)
+ * Note: Checks the entire git repository, not just the working directory
+ * @param workingDir - The directory to check git status in (used to find git root)
+ * @returns Set of absolute file paths that have local changes
+ */
+export function checkGitStatus(workingDir) {
+    const changedFiles = new Set();
+    try {
+        // Get the git root directory first
+        // git status --porcelain returns paths relative to git root, not cwd
+        const gitRoot = execSync("git rev-parse --show-toplevel", {
+            cwd: workingDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+        // Run git status --porcelain to get list of changed files
+        // --porcelain gives machine-readable output
+        const output = execSync("git status --porcelain", {
+            cwd: workingDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"], // Ignore stderr to avoid errors when not in git repo
+        });
+        // Parse the output
+        // Format: "XY filename" where X is staged status, Y is unstaged status
+        const lines = output.trim().split("\n");
+        for (const line of lines) {
+            if (!line)
+                continue;
+            // Extract filename (skip first 3 characters which are status codes and space)
+            const filename = line.slice(3).trim();
+            // Handle renamed files (format: "old -> new")
+            const actualFilename = filename.includes(" -> ") ? filename.split(" -> ")[1] : filename;
+            if (actualFilename) {
+                // Git status returns paths relative to git root, not cwd
+                const absolutePath = path.resolve(gitRoot, actualFilename);
+                changedFiles.add(absolutePath);
+            }
+        }
+    }
+    catch (_error) {
+        // If git command fails (e.g., not in a git repo), return empty set
+        // This allows the tool to work in non-git directories
+        return changedFiles;
+    }
+    return changedFiles;
+}