ts-unused 1.0.1 → 1.0.3

package/dist/fixProject.js

@@ -0,0 +1,549 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Project, SyntaxKind } from "ts-morph";
+import { analyzeProject } from "./analyzeProject";
+import { checkGitStatus } from "./checkGitStatus";
+import { isTestFile as defaultIsTestFile } from "./isTestFile";
+export function fixProject(tsConfigPath, onProgress, isTestFile = defaultIsTestFile) {
+    const results = {
+        fixedExports: 0,
+        fixedProperties: 0,
+        fixedNeverReturnedTypes: 0,
+        deletedFiles: 0,
+        skippedFiles: [],
+        errors: [],
+    };
+    // Analyze the project to find unused items
+    const analysis = analyzeProject(tsConfigPath, undefined, undefined, isTestFile);
+    // Get the directory containing tsconfig
+    const tsConfigDir = path.dirname(path.resolve(tsConfigPath));
+    // Check git status to avoid modifying files with local changes
+    const filesWithChanges = checkGitStatus(tsConfigDir);
+    // Create ts-morph project for making fixes
+    const project = new Project({
+        tsConfigFilePath: tsConfigPath,
+    });
+    // Fix unused files first (delete them)
+    const deletedFiles = new Set();
+    for (const relativeFilePath of analysis.unusedFiles) {
+        const absoluteFilePath = path.resolve(tsConfigDir, relativeFilePath);
+        if (filesWithChanges.has(absoluteFilePath)) {
+            onProgress?.(`Skipped: ${relativeFilePath} (has local git changes)`);
+            results.skippedFiles.push(relativeFilePath);
+            continue;
+        }
+        try {
+            onProgress?.(`Deleting: ${relativeFilePath} (all exports unused)`);
+            fs.unlinkSync(absoluteFilePath);
+            deletedFiles.add(relativeFilePath);
+            results.deletedFiles++;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.errors.push({ file: relativeFilePath, error: errorMessage });
+            onProgress?.(`Error deleting ${relativeFilePath}: ${errorMessage}`);
+        }
+    }
+    // Clean up files that only contain broken imports after deletions
+    if (deletedFiles.size > 0) {
+        cleanupBrokenImports(project, tsConfigDir, deletedFiles, filesWithChanges, onProgress, results);
+    }
+    // Group never-returned types by file (process BEFORE exports to avoid removing functions)
+    const neverReturnedByFile = new Map();
+    for (const neverReturned of analysis.neverReturnedTypes || []) {
+        // Only fix ERROR severity items
+        if (neverReturned.severity !== "error") {
+            continue;
+        }
+        if (!neverReturnedByFile.has(neverReturned.filePath)) {
+            neverReturnedByFile.set(neverReturned.filePath, []);
+        }
+        neverReturnedByFile.get(neverReturned.filePath)?.push(neverReturned);
+    }
+    // Create a set of unused export names for quick lookup (only ERROR severity)
+    const unusedExportNames = new Set();
+    for (const unusedExport of analysis.unusedExports) {
+        if (unusedExport.severity === "error") {
+            unusedExportNames.add(`${unusedExport.filePath}:${unusedExport.exportName}`);
+        }
+    }
+    // Fix never-returned types first (before removing exports)
+    for (const [relativeFilePath, neverReturnedItems] of neverReturnedByFile.entries()) {
+        const absoluteFilePath = path.resolve(tsConfigDir, relativeFilePath);
+        // Skip if file was deleted
+        if (analysis.unusedFiles.includes(relativeFilePath)) {
+            continue;
+        }
+        if (filesWithChanges.has(absoluteFilePath)) {
+            if (!results.skippedFiles.includes(relativeFilePath)) {
+                onProgress?.(`Skipped: ${relativeFilePath} (has local git changes)`);
+                results.skippedFiles.push(relativeFilePath);
+            }
+            continue;
+        }
+        try {
+            const sourceFile = project.getSourceFile(absoluteFilePath);
+            if (!sourceFile) {
+                continue;
+            }
+            onProgress?.(`Fixing: ${relativeFilePath}`);
+            if (neverReturnedItems) {
+                for (const neverReturned of neverReturnedItems) {
+                    // Skip if the function itself is unused (will be removed)
+                    const exportKey = `${relativeFilePath}:${neverReturned.functionName}`;
+                    if (unusedExportNames.has(exportKey)) {
+                        continue;
+                    }
+                    if (removeNeverReturnedType(sourceFile, neverReturned.functionName, neverReturned.neverReturnedType)) {
+                        onProgress?.(`  ✓ Removed never-returned type '${neverReturned.neverReturnedType}' from ${neverReturned.functionName}`);
+                        results.fixedNeverReturnedTypes++;
+                    }
+                }
+            }
+            sourceFile.saveSync();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.errors.push({ file: relativeFilePath, error: errorMessage });
+            onProgress?.(`Error fixing ${relativeFilePath}: ${errorMessage}`);
+        }
+    }
+    // Group unused exports by file (only ERROR severity)
+    const exportsByFile = new Map();
+    for (const unusedExport of analysis.unusedExports) {
+        // Only fix ERROR severity items (skip INFO for test-only, WARNING for TODOs)
+        if (unusedExport.severity !== "error") {
+            continue;
+        }
+        if (!exportsByFile.has(unusedExport.filePath)) {
+            exportsByFile.set(unusedExport.filePath, []);
+        }
+        exportsByFile.get(unusedExport.filePath)?.push(unusedExport);
+    }
+    // Fix unused exports
+    for (const [relativeFilePath, exports] of exportsByFile.entries()) {
+        const absoluteFilePath = path.resolve(tsConfigDir, relativeFilePath);
+        // Skip if file was deleted
+        if (analysis.unusedFiles.includes(relativeFilePath)) {
+            continue;
+        }
+        if (filesWithChanges.has(absoluteFilePath)) {
+            onProgress?.(`Skipped: ${relativeFilePath} (has local git changes)`);
+            results.skippedFiles.push(relativeFilePath);
+            continue;
+        }
+        try {
+            const sourceFile = project.getSourceFile(absoluteFilePath);
+            if (!sourceFile) {
+                continue;
+            }
+            // Only log if we haven't already logged for this file (from never-returned types)
+            if (!neverReturnedByFile.has(relativeFilePath)) {
+                onProgress?.(`Fixing: ${relativeFilePath}`);
+            }
+            for (const unusedExport of exports) {
+                if (removeExport(sourceFile, unusedExport.exportName)) {
+                    onProgress?.(`  ✓ Removed unused export: ${unusedExport.exportName}`);
+                    results.fixedExports++;
+                }
+            }
+            sourceFile.saveSync();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.errors.push({ file: relativeFilePath, error: errorMessage });
+            onProgress?.(`Error fixing ${relativeFilePath}: ${errorMessage}`);
+        }
+    }
+    // Group unused properties by file (only ERROR severity)
+    const propertiesByFile = new Map();
+    for (const unusedProperty of analysis.unusedProperties) {
+        // Only fix ERROR severity items (skip INFO for test-only, WARNING for TODOs)
+        if (unusedProperty.severity !== "error") {
+            continue;
+        }
+        if (!propertiesByFile.has(unusedProperty.filePath)) {
+            propertiesByFile.set(unusedProperty.filePath, []);
+        }
+        propertiesByFile.get(unusedProperty.filePath)?.push(unusedProperty);
+    }
+    // Fix unused properties
+    for (const [relativeFilePath, properties] of propertiesByFile.entries()) {
+        const absoluteFilePath = path.resolve(tsConfigDir, relativeFilePath);
+        // Skip if file was deleted
+        if (analysis.unusedFiles.includes(relativeFilePath)) {
+            continue;
+        }
+        if (filesWithChanges.has(absoluteFilePath)) {
+            // Only add to skipped list if not already added
+            if (!results.skippedFiles.includes(relativeFilePath)) {
+                onProgress?.(`Skipped: ${relativeFilePath} (has local git changes)`);
+                results.skippedFiles.push(relativeFilePath);
+            }
+            continue;
+        }
+        try {
+            const sourceFile = project.getSourceFile(absoluteFilePath);
+            if (!sourceFile) {
+                continue;
+            }
+            // Only log if we haven't already logged for this file (from exports or never-returned)
+            if (!exportsByFile.has(relativeFilePath) && !neverReturnedByFile.has(relativeFilePath)) {
+                onProgress?.(`Fixing: ${relativeFilePath}`);
+            }
+            for (const unusedProperty of properties) {
+                if (removeProperty(sourceFile, unusedProperty.typeName, unusedProperty.propertyName)) {
+                    onProgress?.(`  ✓ Removed unused property: ${unusedProperty.typeName}.${unusedProperty.propertyName}`);
+                    results.fixedProperties++;
+                }
+            }
+            sourceFile.saveSync();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.errors.push({ file: relativeFilePath, error: errorMessage });
+            onProgress?.(`Error fixing ${relativeFilePath}: ${errorMessage}`);
+        }
+    }
+    return results;
+}
+/**
+ * Remove an export from a source file
+ */
+function removeExport(sourceFile, exportName) {
+    // Find all exported declarations with this name
+    const exportedDeclarations = sourceFile.getExportedDeclarations();
+    const declarations = exportedDeclarations.get(exportName);
+    if (!declarations || declarations.length === 0) {
+        return false;
+    }
+    for (const declaration of declarations) {
+        // For variable declarations, we need to remove the VariableStatement
+        if (declaration.getKind() === SyntaxKind.VariableDeclaration) {
+            const variableStatement = declaration.getFirstAncestorByKind(SyntaxKind.VariableStatement);
+            if (variableStatement) {
+                variableStatement.remove();
+                continue;
+            }
+        }
+        // Remove the node if it has a remove method
+        if ("remove" in declaration && typeof declaration.remove === "function") {
+            declaration.remove();
+        }
+    }
+    return true;
+}
+/**
+ * Remove a property from an interface or type alias
+ */
+function removeProperty(sourceFile, typeName, propertyName) {
+    // Find interface declarations
+    const interfaces = sourceFile.getInterfaces();
+    for (const iface of interfaces) {
+        if (iface.getName() === typeName) {
+            const property = iface.getProperty(propertyName);
+            if (property) {
+                property.remove();
+                return true;
+            }
+        }
+    }
+    // Find type alias declarations
+    const typeAliases = sourceFile.getTypeAliases();
+    for (const typeAlias of typeAliases) {
+        if (typeAlias.getName() === typeName) {
+            const typeNode = typeAlias.getTypeNode();
+            if (typeNode && typeNode.getKind() === SyntaxKind.TypeLiteral) {
+                const typeLiteral = typeNode.asKindOrThrow(SyntaxKind.TypeLiteral);
+                const members = typeLiteral.getMembers();
+                for (const member of members) {
+                    if (member.getKind() === SyntaxKind.PropertySignature) {
+                        const propSig = member.asKind(SyntaxKind.PropertySignature);
+                        if (propSig?.getName() === propertyName) {
+                            propSig.remove();
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Remove a never-returned type from a function's return type union
+ */
+function removeNeverReturnedType(sourceFile, functionName, neverReturnedType) {
+    // Find the function
+    const functions = sourceFile.getFunctions();
+    for (const func of functions) {
+        if (func.getName() === functionName) {
+            const returnTypeNode = func.getReturnTypeNode();
+            if (!returnTypeNode) {
+                return false;
+            }
+            // Get the actual type (resolved) to check if it's a union
+            const returnType = returnTypeNode.getType();
+            // For Promise types, unwrap to get inner type
+            let typeToCheck = returnType;
+            let isPromise = false;
+            const symbol = returnType.getSymbol();
+            if (symbol?.getName() === "Promise") {
+                const typeArgs = returnType.getTypeArguments();
+                if (typeArgs.length > 0 && typeArgs[0]) {
+                    typeToCheck = typeArgs[0];
+                    isPromise = true;
+                }
+            }
+            // Check if it's a union type
+            if (!typeToCheck.isUnion()) {
+                return false;
+            }
+            const unionTypes = typeToCheck.getUnionTypes();
+            // Check if any of the union branches is an inline object type or enum literal
+            const hasInlineObjectType = unionTypes.some((ut) => ut.getSymbol()?.getName() === "__type");
+            const hasEnumLiteral = unionTypes.some((ut) => ut.isEnumLiteral());
+            if (hasInlineObjectType || hasEnumLiteral) {
+                // Use source text manipulation for inline object types and enum literals
+                const originalTypeText = returnTypeNode.getText();
+                // For Promise types, we need to extract the inner type text
+                let typeTextToModify = originalTypeText;
+                let promiseWrapper = "";
+                if (isPromise) {
+                    const promiseMatch = originalTypeText.match(/^Promise<(.+)>$/s);
+                    if (promiseMatch?.[1]) {
+                        typeTextToModify = promiseMatch[1];
+                        promiseWrapper = "Promise<>";
+                    }
+                }
+                // Split the union by | but handle nested structures
+                const branches = splitUnionType(typeTextToModify);
+                // Normalize the type to remove for comparison
+                const normalizedRemove = normalizeTypeText(neverReturnedType === "true" || neverReturnedType === "false" ? "boolean" : neverReturnedType);
+                // Filter out the branch to remove
+                const remainingBranches = branches.filter((branch) => {
+                    const trimmed = branch.trim();
+                    // Normalize boolean for comparison
+                    const normalized = normalizeTypeText(trimmed === "true" || trimmed === "false" ? "boolean" : trimmed);
+                    return normalized !== normalizedRemove;
+                });
+                if (remainingBranches.length === 0 || remainingBranches.length === branches.length) {
+                    // Either all removed (shouldn't happen) or nothing matched
+                    return false;
+                }
+                // Build the new return type
+                let newReturnType = remainingBranches.join(" | ");
+                // Wrap in Promise if needed
+                if (promiseWrapper) {
+                    newReturnType = `Promise<${newReturnType}>`;
+                }
+                // Replace the return type
+                func.setReturnType(newReturnType);
+                return true;
+            }
+            else {
+                // Use the old approach for named types (interfaces, type aliases, enums)
+                const typesToKeep = [];
+                for (const ut of unionTypes) {
+                    const symbol = ut.getSymbol();
+                    const typeName = symbol?.getName() || ut.getText();
+                    // Normalize boolean
+                    const normalizedName = typeName === "true" || typeName === "false" ? "boolean" : typeName;
+                    const normalizedRemove = neverReturnedType === "true" || neverReturnedType === "false" ? "boolean" : neverReturnedType;
+                    if (normalizedName !== normalizedRemove && !typesToKeep.includes(typeName)) {
+                        typesToKeep.push(typeName);
+                    }
+                }
+                // Build the new return type
+                let newReturnType;
+                if (typesToKeep.length === 1 && typesToKeep[0]) {
+                    newReturnType = typesToKeep[0];
+                }
+                else if (typesToKeep.length > 1) {
+                    newReturnType = typesToKeep.join(" | ");
+                }
+                if (!newReturnType) {
+                    // All types removed, shouldn't happen
+                    return false;
+                }
+                // Wrap in Promise if needed
+                if (isPromise) {
+                    newReturnType = `Promise<${newReturnType}>`;
+                }
+                // Replace the return type
+                func.setReturnType(newReturnType);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Split a union type string by | while respecting nested structures
+ */
+function splitUnionType(typeText) {
+    const branches = [];
+    let current = "";
+    let depth = 0;
+    let inString = false;
+    let stringChar = "";
+    for (let i = 0; i < typeText.length; i++) {
+        const char = typeText[i];
+        const prevChar = i > 0 ? typeText[i - 1] : "";
+        // Handle string literals
+        if ((char === '"' || char === "'") && prevChar !== "\\") {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === stringChar) {
+                inString = false;
+                stringChar = "";
+            }
+        }
+        if (!inString) {
+            // Track depth for nested structures
+            if (char === "{" || char === "<" || char === "(") {
+                depth++;
+            }
+            else if (char === "}" || char === ">" || char === ")") {
+                depth--;
+            }
+            else if (char === "|" && depth === 0) {
+                // Found a top-level union separator
+                branches.push(current);
+                current = "";
+                continue;
+            }
+        }
+        current += char;
+    }
+    // Add the last branch
+    if (current) {
+        branches.push(current);
+    }
+    return branches;
+}
+/**
+ * Normalize type text for comparison by removing optional trailing semicolons
+ */
+function normalizeTypeText(typeText) {
+    // Remove semicolons before closing braces/brackets
+    return typeText
+        .replace(/;\s*([}\]>])/g, " $1")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * Clean up files that have broken imports after file deletions
+ * If a file only contains re-exports from deleted files, remove those exports or delete the file
+ */
+function cleanupBrokenImports(project, tsConfigDir, deletedFiles, filesWithChanges, onProgress, results) {
+    // Refresh the project to detect errors after deletions
+    const sourceFiles = project.getSourceFiles();
+    for (const sourceFile of sourceFiles) {
+        const relativePath = path.relative(tsConfigDir, sourceFile.getFilePath());
+        const absolutePath = sourceFile.getFilePath();
+        // Skip if file has git changes
+        if (filesWithChanges.has(absolutePath)) {
+            continue;
+        }
+        // Check for broken imports/exports
+        const exportDeclarations = sourceFile.getExportDeclarations();
+        let hasValidExports = false;
+        const brokenExports = [];
+        for (const exportDecl of exportDeclarations) {
+            const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+            if (moduleSpecifier) {
+                // Resolve the import path
+                const resolvedPath = resolveImportPath(sourceFile.getFilePath(), moduleSpecifier);
+                const relativeResolvedPath = resolvedPath ? path.relative(tsConfigDir, resolvedPath) : null;
+                // Check if it references a deleted file
+                if (relativeResolvedPath && deletedFiles.has(relativeResolvedPath)) {
+                    brokenExports.push(exportDecl);
+                }
+                else {
+                    hasValidExports = true;
+                }
+            }
+            else {
+                // Export without module specifier (e.g., export { foo })
+                hasValidExports = true;
+            }
+        }
+        // Also check if file has any non-export declarations
+        const hasOwnDeclarations = sourceFile.getFunctions().length > 0 ||
+            sourceFile.getClasses().length > 0 ||
+            sourceFile.getInterfaces().length > 0 ||
+            sourceFile.getTypeAliases().length > 0 ||
+            sourceFile.getVariableDeclarations().length > 0 ||
+            sourceFile.getEnums().length > 0;
+        if (hasOwnDeclarations) {
+            hasValidExports = true;
+        }
+        // If file only has broken re-exports, delete it
+        if (brokenExports.length > 0 && !hasValidExports) {
+            try {
+                onProgress?.(`Deleting: ${relativePath} (only re-exports from deleted files)`);
+                fs.unlinkSync(absolutePath);
+                if (results) {
+                    results.deletedFiles++;
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (results) {
+                    results.errors.push({ file: relativePath, error: errorMessage });
+                }
+                onProgress?.(`Error deleting ${relativePath}: ${errorMessage}`);
+            }
+        }
+        // Otherwise, just remove the broken export declarations
+        else if (brokenExports.length > 0) {
+            try {
+                onProgress?.(`Fixing: ${relativePath}`);
+                for (const exportDecl of brokenExports) {
+                    const moduleSpec = exportDecl.getModuleSpecifierValue();
+                    exportDecl.remove();
+                    onProgress?.(`  ✓ Removed broken re-export from: ${moduleSpec}`);
+                }
+                sourceFile.saveSync();
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (results) {
+                    results.errors.push({ file: relativePath, error: errorMessage });
+                }
+                onProgress?.(`Error fixing ${relativePath}: ${errorMessage}`);
+            }
+        }
+    }
+}
+/**
+ * Resolve an import path to an absolute file path
+ */
+function resolveImportPath(fromFile, importPath) {
+    const fromDir = path.dirname(fromFile);
+    // Handle relative imports
+    if (importPath.startsWith(".")) {
+        const resolved = path.resolve(fromDir, importPath);
+        // Try with different extensions
+        const extensions = [".ts", ".tsx", ".js", ".jsx"];
+        for (const ext of extensions) {
+            const withExt = resolved + ext;
+            if (fs.existsSync(withExt)) {
+                return withExt;
+            }
+        }
+        // Try as index file
+        for (const ext of extensions) {
+            const indexFile = path.join(resolved, `index${ext}`);
+            if (fs.existsSync(indexFile)) {
+                return indexFile;
+            }
+        }
+        // Return as-is if no extension found (might be a directory or invalid)
+        return `${resolved}.ts`;
+    }
+    return null;
+}

package/dist/formatResults.d.ts

@@ -0,0 +1,2 @@
+import type { AnalysisResults } from "./types";
+export declare function formatResults(results: AnalysisResults, tsConfigDir: string): string;

package/dist/formatResults.js

@@ -0,0 +1,112 @@
+import path from "node:path";
+function getSeverityMarker(severity) {
+    const markers = {
+        error: "[ERROR]",
+        warning: "[WARNING]",
+        info: "[INFO]",
+    };
+    return markers[severity];
+}
+function formatExportLine(item) {
+    const marker = getSeverityMarker(item.severity);
+    if (item.onlyUsedInTests) {
+        return `  ${item.exportName}:${item.line}:${item.character}-${item.endCharacter} ${marker} (Used only in tests)`;
+    }
+    return `  ${item.exportName}:${item.line}:${item.character}-${item.endCharacter} ${marker} (Unused ${item.kind})`;
+}
+function formatPropertyLine(item) {
+    const status = item.onlyUsedInTests ? "Used only in tests" : "Unused property";
+    const todoSuffix = item.todoComment ? `: [TODO] ${item.todoComment}` : "";
+    const marker = getSeverityMarker(item.severity);
+    return `  ${item.typeName}.${item.propertyName}:${item.line}:${item.character}-${item.endCharacter} ${marker} (${status}${todoSuffix})`;
+}
+function formatNeverReturnedLine(item) {
+    const marker = getSeverityMarker(item.severity);
+    return `  ${item.functionName}:${item.line}:${item.character}-${item.endCharacter} ${marker} (Type '${item.neverReturnedType}' in return type is never returned)`;
+}
+function formatGroupedItems(items, formatter, tsConfigDir, cwd) {
+    const lines = [];
+    const grouped = groupByFile(items);
+    for (const [filePath, groupItems] of grouped.entries()) {
+        // filePath is relative to tsConfigDir, convert to absolute then to relative from cwd
+        const absolutePath = path.resolve(tsConfigDir, filePath);
+        const relativePath = path.relative(cwd, absolutePath);
+        lines.push(relativePath);
+        for (const item of groupItems) {
+            lines.push(formatter(item));
+        }
+        lines.push("");
+    }
+    return lines;
+}
+export function formatResults(results, tsConfigDir) {
+    const lines = [];
+    const cwd = process.cwd();
+    // Create a set of unused export names (interfaces/types) for quick lookup
+    const unusedExportNames = new Set();
+    for (const exportItem of results.unusedExports) {
+        unusedExportNames.add(exportItem.exportName);
+    }
+    // Filter out properties whose parent type/interface is already reported as unused
+    const propertiesToReport = results.unusedProperties.filter((prop) => !unusedExportNames.has(prop.typeName));
+    // Create a set of completely unused files to exclude from export reporting
+    const unusedFileSet = new Set(results.unusedFiles);
+    // Filter out exports from completely unused files
+    const exportsToReport = results.unusedExports.filter((exp) => !unusedFileSet.has(exp.filePath));
+    // Report completely unused files first
+    if (results.unusedFiles.length > 0) {
+        lines.push("Completely Unused Files:");
+        lines.push("");
+        for (const filePath of results.unusedFiles) {
+            // filePath is relative to tsConfigDir, convert to absolute then to relative from cwd
+            const absolutePath = path.resolve(tsConfigDir, filePath);
+            const relativePath = path.relative(cwd, absolutePath);
+            lines.push(relativePath);
+            lines.push("  file:1:1-1 [ERROR] (All exports unused - file can be deleted)");
+            lines.push("");
+        }
+    }
+    if (exportsToReport.length > 0) {
+        lines.push("Unused Exports:");
+        lines.push("");
+        lines.push(...formatGroupedItems(exportsToReport, formatExportLine, tsConfigDir, cwd));
+    }
+    if (propertiesToReport.length > 0) {
+        lines.push("Unused Type/Interface Properties:");
+        lines.push("");
+        lines.push(...formatGroupedItems(propertiesToReport, formatPropertyLine, tsConfigDir, cwd));
+    }
+    const neverReturnedTypes = results.neverReturnedTypes || [];
+    if (neverReturnedTypes.length > 0) {
+        lines.push("Never-Returned Types:");
+        lines.push("");
+        lines.push(...formatGroupedItems(neverReturnedTypes, formatNeverReturnedLine, tsConfigDir, cwd));
+    }
+    if (results.unusedFiles.length === 0 &&
+        exportsToReport.length === 0 &&
+        propertiesToReport.length === 0 &&
+        neverReturnedTypes.length === 0) {
+        lines.push("No unused exports or properties found!");
+    }
+    else {
+        lines.push("Summary:");
+        lines.push(`  Completely unused files: ${results.unusedFiles.length}`);
+        lines.push(`  Unused exports: ${exportsToReport.length}`);
+        lines.push(`  Unused properties: ${propertiesToReport.length}`);
+        lines.push(`  Never-returned types: ${neverReturnedTypes.length}`);
+    }
+    return lines.join("\n");
+}
+function groupByFile(items) {
+    const grouped = new Map();
+    for (const item of items) {
+        const existing = grouped.get(item.filePath);
+        if (existing) {
+            existing.push(item);
+        }
+        else {
+            grouped.set(item.filePath, [item]);
+        }
+    }
+    return grouped;
+}

package/dist/hasNoCheck.d.ts

@@ -0,0 +1,2 @@
+import type { SourceFile } from "ts-morph";
+export declare function hasNoCheck(sourceFile: SourceFile): boolean;

package/dist/hasNoCheck.js

@@ -0,0 +1,8 @@
+export function hasNoCheck(sourceFile) {
+    const fullText = sourceFile.getFullText();
+    const firstLine = fullText.split("\n")[0];
+    if (!firstLine) {
+        return false;
+    }
+    return firstLine.trim() === "// @ts-nocheck";
+}