ts-unused 1.0.2 → 1.0.3

package/dist/extractTodoComment.js

@@ -0,0 +1,27 @@
+/**
+ * Extracts TODO comment text from the leading comments of a property.
+ * Returns undefined if no TODO comment is found.
+ */
+export function extractTodoComment(prop) {
+    const leadingComments = prop.getLeadingCommentRanges();
+    for (const comment of leadingComments) {
+        const commentText = comment.getText();
+        // Match single-line comments: // TODO ...
+        const singleLineMatch = commentText.match(/\/\/\s*TODO\s+(.+)/i);
+        if (singleLineMatch) {
+            const todoText = singleLineMatch[1];
+            if (todoText) {
+                return todoText.trim();
+            }
+        }
+        // Match multi-line comments: /* TODO ... */ or /** TODO ... */
+        const multiLineMatch = commentText.match(/\/\*+\s*TODO\s+(.+?)\*\//is);
+        if (multiLineMatch) {
+            const todoText = multiLineMatch[1];
+            if (todoText) {
+                return todoText.trim().replace(/\s+/g, " ");
+            }
+        }
+    }
+    return undefined;
+}

package/dist/findNeverReturnedTypes.d.ts

@@ -1,3 +1,6 @@
 import type { Project } from "ts-morph";
 import type { IsTestFileFn, NeverReturnedTypeResult } from "./types";
-export declare function findNeverReturnedTypes(project: Project, tsConfigDir: string, isTestFile: IsTestFileFn, onProgress?: (filePath: string) => void, targetFilePath?: string): NeverReturnedTypeResult[];
+export interface FindNeverReturnedTypesOptions {
+    ignoreFilePatterns?: string[];
+}
+export declare function findNeverReturnedTypes(project: Project, tsConfigDir: string, isTestFile: IsTestFileFn, onProgress?: (filePath: string) => void, targetFilePath?: string, options?: FindNeverReturnedTypesOptions): NeverReturnedTypeResult[];

package/dist/findNeverReturnedTypes.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { SyntaxKind } from "ts-morph";
+import { analyzeFunctionReturnTypes } from "./analyzeFunctionReturnTypes";
+import { hasNoCheck } from "./hasNoCheck";
+import { matchesFilePattern } from "./patternMatcher";
+export function findNeverReturnedTypes(project, tsConfigDir, isTestFile, onProgress, targetFilePath, options = {}) {
+    const { ignoreFilePatterns = [] } = options;
+    const results = [];
+    for (const sourceFile of project.getSourceFiles()) {
+        if (isTestFile(sourceFile)) {
+            continue;
+        }
+        if (hasNoCheck(sourceFile)) {
+            continue;
+        }
+        const filePath = sourceFile.getFilePath();
+        if (targetFilePath && filePath !== targetFilePath) {
+            continue;
+        }
+        // Check if file matches ignore patterns
+        if (ignoreFilePatterns.length > 0 && matchesFilePattern(filePath, ignoreFilePatterns)) {
+            continue;
+        }
+        if (onProgress) {
+            const relativePath = path.relative(tsConfigDir, filePath);
+            onProgress(relativePath);
+        }
+        // Get all function declarations
+        const functions = sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration);
+        for (const func of functions) {
+            const funcResults = analyzeFunctionReturnTypes(func, sourceFile, tsConfigDir);
+            results.push(...funcResults);
+        }
+    }
+    return results;
+}

package/dist/findStructurallyEquivalentProperties.js

@@ -0,0 +1,60 @@
+import { SyntaxKind } from "ts-morph";
+function checkInterfaceProperties(iface, propName, propType, originalProp, equivalentProps) {
+    const properties = iface.getProperties();
+    for (const p of properties) {
+        if (p === originalProp) {
+            continue;
+        }
+        if (p.getName() === propName) {
+            const pType = p.getType().getText();
+            if (pType === propType) {
+                equivalentProps.push(p);
+            }
+        }
+    }
+}
+function checkTypeAliasProperties(typeAlias, propName, propType, originalProp, equivalentProps) {
+    const typeNode = typeAlias.getTypeNode();
+    if (!typeNode || typeNode.getKind() !== SyntaxKind.TypeLiteral) {
+        return;
+    }
+    const properties = typeNode.getChildren().filter((child) => child.getKind() === SyntaxKind.PropertySignature);
+    for (const p of properties) {
+        if (p === originalProp) {
+            continue;
+        }
+        if (p.getKind() === SyntaxKind.PropertySignature && p.getName() === propName) {
+            const pType = p.getType().getText();
+            if (pType === propType) {
+                equivalentProps.push(p);
+            }
+        }
+    }
+}
+/**
+ * Finds properties that are structurally equivalent to the given property.
+ * Two properties are structurally equivalent if they have:
+ * - Same property name
+ * - Same type signature
+ *
+ * This handles cases where properties are re-declared across interfaces,
+ * such as when one interface extends another and re-declares properties,
+ * or when spread operations flow values between structurally similar types.
+ */
+export function findStructurallyEquivalentProperties(prop, project) {
+    const propName = prop.getName();
+    const propType = prop.getType().getText();
+    const equivalentProps = [];
+    const sourceFiles = project.getSourceFiles();
+    for (const sourceFile of sourceFiles) {
+        const interfaces = sourceFile.getInterfaces();
+        for (const iface of interfaces) {
+            checkInterfaceProperties(iface, propName, propType, prop, equivalentProps);
+        }
+        const typeAliases = sourceFile.getTypeAliases();
+        for (const typeAlias of typeAliases) {
+            checkTypeAliasProperties(typeAlias, propName, propType, prop, equivalentProps);
+        }
+    }
+    return equivalentProps;
+}

package/dist/findUnusedExports.d.ts

@@ -1,3 +1,7 @@
 import type { Project } from "ts-morph";
+import { type CheckExportOptions } from "./checkExportUsage";
 import type { IsTestFileFn, UnusedExportResult } from "./types";
-export declare function findUnusedExports(project: Project, tsConfigDir: string, isTestFile: IsTestFileFn, onProgress?: (filePath: string) => void, targetFilePath?: string): UnusedExportResult[];
+export interface FindUnusedExportsOptions extends CheckExportOptions {
+    ignoreFilePatterns?: string[];
+}
+export declare function findUnusedExports(project: Project, tsConfigDir: string, isTestFile: IsTestFileFn, onProgress?: (filePath: string) => void, targetFilePath?: string, options?: FindUnusedExportsOptions): UnusedExportResult[];

package/dist/findUnusedExports.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { checkExportUsage } from "./checkExportUsage";
+import { hasNoCheck } from "./hasNoCheck";
+import { matchesFilePattern } from "./patternMatcher";
+export function findUnusedExports(project, tsConfigDir, isTestFile, onProgress, targetFilePath, options = {}) {
+    const { ignoreFilePatterns = [], ...checkOptions } = options;
+    const results = [];
+    for (const sourceFile of project.getSourceFiles()) {
+        if (isTestFile(sourceFile)) {
+            continue;
+        }
+        if (hasNoCheck(sourceFile)) {
+            continue;
+        }
+        const filePath = sourceFile.getFilePath();
+        if (targetFilePath && filePath !== targetFilePath) {
+            continue;
+        }
+        // Check if file should be ignored based on patterns
+        if (ignoreFilePatterns.length > 0 && matchesFilePattern(filePath, ignoreFilePatterns)) {
+            continue;
+        }
+        if (onProgress) {
+            const relativePath = path.relative(tsConfigDir, filePath);
+            onProgress(relativePath);
+        }
+        const exports = sourceFile.getExportedDeclarations();
+        for (const [exportName, declarations] of exports.entries()) {
+            const unusedExport = checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isTestFile, checkOptions);
+            if (unusedExport) {
+                results.push(unusedExport);
+            }
+        }
+    }
+    return results;
+}

package/dist/findUnusedProperties.d.ts

@@ -1,3 +1,7 @@
 import type { Project } from "ts-morph";
+import { type AnalyzeInterfacesOptions } from "./analyzeInterfaces";
 import type { IsTestFileFn, UnusedPropertyResult } from "./types";
-export declare function findUnusedProperties(project: Project, tsConfigDir: string, isTestFile: IsTestFileFn, onProgress?: (filePath: string) => void, targetFilePath?: string): UnusedPropertyResult[];
+export interface FindUnusedPropertiesOptions extends AnalyzeInterfacesOptions {
+    ignoreFilePatterns?: string[];
+}
+export declare function findUnusedProperties(project: Project, tsConfigDir: string, isTestFile: IsTestFileFn, onProgress?: (filePath: string) => void, targetFilePath?: string, options?: FindUnusedPropertiesOptions): UnusedPropertyResult[];

package/dist/findUnusedProperties.js

@@ -0,0 +1,32 @@
+import path from "node:path";
+import { analyzeInterfaces } from "./analyzeInterfaces";
+import { analyzeTypeAliases } from "./analyzeTypeAliases";
+import { hasNoCheck } from "./hasNoCheck";
+import { matchesFilePattern } from "./patternMatcher";
+export function findUnusedProperties(project, tsConfigDir, isTestFile, onProgress, targetFilePath, options = {}) {
+    const { ignoreFilePatterns = [], ...analyzeOptions } = options;
+    const results = [];
+    for (const sourceFile of project.getSourceFiles()) {
+        if (isTestFile(sourceFile)) {
+            continue;
+        }
+        if (hasNoCheck(sourceFile)) {
+            continue;
+        }
+        const filePath = sourceFile.getFilePath();
+        if (targetFilePath && filePath !== targetFilePath) {
+            continue;
+        }
+        // Check if file should be ignored based on patterns
+        if (ignoreFilePatterns.length > 0 && matchesFilePattern(filePath, ignoreFilePatterns)) {
+            continue;
+        }
+        if (onProgress) {
+            const relativePath = path.relative(tsConfigDir, filePath);
+            onProgress(relativePath);
+        }
+        analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project, analyzeOptions);
+        analyzeTypeAliases(sourceFile, tsConfigDir, isTestFile, results, project, analyzeOptions);
+    }
+    return results;
+}