ts-unused 1.0.1 → 1.0.3

package/dist/cli.js

@@ -1,13 +1,44 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli.ts
-import fs2 from "node:fs";
-import path12 from "node:path";
+import fs3 from "node:fs";
+import path13 from "node:path";
 
 // src/analyzeProject.ts
 import path8 from "node:path";
 import { Project } from "ts-morph";
 
+// src/config.ts
+var defaultConfig = {
+  testFilePatterns: ["**/*.test.ts", "**/*.test.tsx", "**/*.spec.ts", "**/*.spec.tsx", "**/__tests__/**"],
+  ignoreFilePatterns: [],
+  ignoreExports: [],
+  ignoreProperties: [],
+  ignoreTypes: [],
+  ignoreModuleAugmentations: true,
+  analyzeProperties: true,
+  analyzeExports: true,
+  analyzeNeverReturnedTypes: true,
+  detectUnusedFiles: true
+};
+function mergeConfig(userConfig) {
+  const result = {
+    testFilePatterns: userConfig.testFilePatterns ?? defaultConfig.testFilePatterns,
+    ignoreFilePatterns: userConfig.ignoreFilePatterns ?? defaultConfig.ignoreFilePatterns,
+    ignoreExports: userConfig.ignoreExports ?? defaultConfig.ignoreExports,
+    ignoreProperties: userConfig.ignoreProperties ?? defaultConfig.ignoreProperties,
+    ignoreTypes: userConfig.ignoreTypes ?? defaultConfig.ignoreTypes,
+    ignoreModuleAugmentations: userConfig.ignoreModuleAugmentations ?? defaultConfig.ignoreModuleAugmentations,
+    analyzeProperties: userConfig.analyzeProperties ?? defaultConfig.analyzeProperties,
+    analyzeExports: userConfig.analyzeExports ?? defaultConfig.analyzeExports,
+    analyzeNeverReturnedTypes: userConfig.analyzeNeverReturnedTypes ?? defaultConfig.analyzeNeverReturnedTypes,
+    detectUnusedFiles: userConfig.detectUnusedFiles ?? defaultConfig.detectUnusedFiles
+  };
+  return result;
+}
+
 // src/findNeverReturnedTypes.ts
 import path2 from "node:path";
 import { SyntaxKind as SyntaxKind2 } from "ts-morph";
@@ -205,8 +236,58 @@ function hasNoCheck(sourceFile) {
   return firstLine.trim() === "// @ts-nocheck";
 }
 
+// src/patternMatcher.ts
+function patternToRegex(pattern) {
+  let regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const DOUBLE_STAR_PLACEHOLDER = "<<DOUBLESTAR>>";
+  regexStr = regexStr.replace(/\*\*/g, DOUBLE_STAR_PLACEHOLDER);
+  regexStr = regexStr.replace(/\*/g, "[^/]*");
+  regexStr = regexStr.split(DOUBLE_STAR_PLACEHOLDER).join(".*");
+  regexStr = regexStr.replace(/\?/g, ".");
+  return new RegExp(`^${regexStr}$`);
+}
+function matchesPattern(value, patterns) {
+  for (const pattern of patterns) {
+    if (pattern === value) {
+      return true;
+    }
+    if (pattern.includes("*") || pattern.includes("?")) {
+      const regex = patternToRegex(pattern);
+      if (regex.test(value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function matchesFilePattern(filePath, patterns) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  for (const pattern of patterns) {
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    if (normalizedPattern.startsWith("**/")) {
+      const suffixPattern = normalizedPattern.slice(3);
+      const regex = patternToRegex(`**/${suffixPattern}`);
+      if (regex.test(normalizedPath)) {
+        return true;
+      }
+      const suffixRegex = patternToRegex(suffixPattern);
+      const fileName = normalizedPath.split("/").pop() ?? "";
+      if (suffixRegex.test(fileName)) {
+        return true;
+      }
+    } else {
+      const regex = patternToRegex(normalizedPattern);
+      if (regex.test(normalizedPath)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 // src/findNeverReturnedTypes.ts
-function findNeverReturnedTypes(project, tsConfigDir, isTestFile, onProgress, targetFilePath) {
+function findNeverReturnedTypes(project, tsConfigDir, isTestFile, onProgress, targetFilePath, options = {}) {
+  const { ignoreFilePatterns = [] } = options;
   const results = [];
   for (const sourceFile of project.getSourceFiles()) {
     if (isTestFile(sourceFile)) {
@@ -215,11 +296,15 @@ function findNeverReturnedTypes(project, tsConfigDir, isTestFile, onProgress, ta
     if (hasNoCheck(sourceFile)) {
       continue;
     }
-    if (targetFilePath && sourceFile.getFilePath() !== targetFilePath) {
+    const filePath = sourceFile.getFilePath();
+    if (targetFilePath && filePath !== targetFilePath) {
+      continue;
+    }
+    if (ignoreFilePatterns.length > 0 && matchesFilePattern(filePath, ignoreFilePatterns)) {
       continue;
     }
     if (onProgress) {
-      const relativePath = path2.relative(tsConfigDir, sourceFile.getFilePath());
+      const relativePath = path2.relative(tsConfigDir, filePath);
       onProgress(relativePath);
     }
     const functions = sourceFile.getDescendantsOfKind(SyntaxKind2.FunctionDeclaration);
@@ -274,11 +359,27 @@ function getNameNode(declaration) {
   }
   return;
 }
-function checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isTestFile) {
+function isModuleAugmentation(declaration) {
+  if (Node.isModuleDeclaration(declaration)) {
+    const nameNode = declaration.getNameNode();
+    if (Node.isStringLiteral(nameNode)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isTestFile, options = {}) {
+  const { ignoreExports = [], ignoreModuleAugmentations = true } = options;
   const firstDeclaration = declarations[0];
   if (!firstDeclaration) {
     return null;
   }
+  if (ignoreExports.length > 0 && matchesPattern(exportName, ignoreExports)) {
+    return null;
+  }
+  if (ignoreModuleAugmentations && isModuleAugmentation(firstDeclaration)) {
+    return null;
+  }
   const declarationSourceFile = firstDeclaration.getSourceFile();
   if (declarationSourceFile.getFilePath() !== sourceFile.getFilePath()) {
     return null;
@@ -329,7 +430,8 @@ function checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isT
 }
 
 // src/findUnusedExports.ts
-function findUnusedExports(project, tsConfigDir, isTestFile, onProgress, targetFilePath) {
+function findUnusedExports(project, tsConfigDir, isTestFile, onProgress, targetFilePath, options = {}) {
+  const { ignoreFilePatterns = [], ...checkOptions } = options;
   const results = [];
   for (const sourceFile of project.getSourceFiles()) {
     if (isTestFile(sourceFile)) {
@@ -338,16 +440,20 @@ function findUnusedExports(project, tsConfigDir, isTestFile, onProgress, targetF
     if (hasNoCheck(sourceFile)) {
       continue;
     }
-    if (targetFilePath && sourceFile.getFilePath() !== targetFilePath) {
+    const filePath = sourceFile.getFilePath();
+    if (targetFilePath && filePath !== targetFilePath) {
+      continue;
+    }
+    if (ignoreFilePatterns.length > 0 && matchesFilePattern(filePath, ignoreFilePatterns)) {
       continue;
     }
     if (onProgress) {
-      const relativePath = path4.relative(tsConfigDir, sourceFile.getFilePath());
+      const relativePath = path4.relative(tsConfigDir, filePath);
       onProgress(relativePath);
     }
     const exports = sourceFile.getExportedDeclarations();
     for (const [exportName, declarations] of exports.entries()) {
-      const unusedExport = checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isTestFile);
+      const unusedExport = checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isTestFile, checkOptions);
       if (unusedExport) {
         results.push(unusedExport);
       }
@@ -483,11 +589,19 @@ function isPropertyUnused(prop, isTestFile, project) {
 }
 
 // src/analyzeInterfaces.ts
-function analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project) {
+function analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project, options = {}) {
+  const { ignoreProperties = [], ignoreTypes = [] } = options;
   const interfaces = sourceFile.getInterfaces();
   for (const iface of interfaces) {
     const interfaceName = iface.getName();
+    if (ignoreTypes.length > 0 && matchesPattern(interfaceName, ignoreTypes)) {
+      continue;
+    }
     for (const prop of iface.getProperties()) {
+      const propertyName = prop.getName();
+      if (ignoreProperties.length > 0 && matchesPattern(propertyName, ignoreProperties)) {
+        continue;
+      }
       const usage = isPropertyUnused(prop, isTestFile, project);
       if (usage.isUnusedOrTestOnly) {
         const relativePath = path5.relative(tsConfigDir, sourceFile.getFilePath());
@@ -498,7 +612,6 @@ function analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project
         } else if (usage.onlyUsedInTests) {
           severity = "info";
         }
-        const propertyName = prop.getName();
         const startPos = prop.getStart();
         const lineStartPos = prop.getStartLinePos();
         const character = startPos - lineStartPos + 1;
@@ -523,10 +636,15 @@ function analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project
 // src/analyzeTypeAliases.ts
 import path6 from "node:path";
 import { Node as Node2 } from "ts-morph";
-function analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isTestFile, results, project) {
+function analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isTestFile, results, project, options = {}) {
+  const { ignoreProperties = [] } = options;
   if (!Node2.isPropertySignature(member)) {
     return;
   }
+  const propertyName = member.getName();
+  if (ignoreProperties.length > 0 && matchesPattern(propertyName, ignoreProperties)) {
+    return;
+  }
   const usage = isPropertyUnused(member, isTestFile, project);
   if (!usage.isUnusedOrTestOnly) {
     return;
@@ -539,7 +657,6 @@ function analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isT
   } else if (usage.onlyUsedInTests) {
     severity = "info";
   }
-  const propertyName = member.getName();
   const startPos = member.getStart();
   const lineStartPos = member.getStartLinePos();
   const character = startPos - lineStartPos + 1;
@@ -557,8 +674,12 @@ function analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isT
   };
   results.push(result);
 }
-function analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, results, project) {
+function analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, results, project, options = {}) {
+  const { ignoreTypes = [] } = options;
   const typeName = typeAlias.getName();
+  if (ignoreTypes.length > 0 && matchesPattern(typeName, ignoreTypes)) {
+    return;
+  }
   const typeNode = typeAlias.getTypeNode();
   if (!typeNode) {
     return;
@@ -567,18 +688,19 @@ function analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, result
     return;
   }
   for (const member of typeNode.getMembers()) {
-    analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isTestFile, results, project);
+    analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isTestFile, results, project, options);
   }
 }
-function analyzeTypeAliases(sourceFile, tsConfigDir, isTestFile, results, project) {
+function analyzeTypeAliases(sourceFile, tsConfigDir, isTestFile, results, project, options = {}) {
   const typeAliases = sourceFile.getTypeAliases();
   for (const typeAlias of typeAliases) {
-    analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, results, project);
+    analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, results, project, options);
   }
 }
 
 // src/findUnusedProperties.ts
-function findUnusedProperties(project, tsConfigDir, isTestFile, onProgress, targetFilePath) {
+function findUnusedProperties(project, tsConfigDir, isTestFile, onProgress, targetFilePath, options = {}) {
+  const { ignoreFilePatterns = [], ...analyzeOptions } = options;
   const results = [];
   for (const sourceFile of project.getSourceFiles()) {
     if (isTestFile(sourceFile)) {
@@ -587,15 +709,19 @@ function findUnusedProperties(project, tsConfigDir, isTestFile, onProgress, targ
     if (hasNoCheck(sourceFile)) {
       continue;
     }
-    if (targetFilePath && sourceFile.getFilePath() !== targetFilePath) {
+    const filePath = sourceFile.getFilePath();
+    if (targetFilePath && filePath !== targetFilePath) {
+      continue;
+    }
+    if (ignoreFilePatterns.length > 0 && matchesFilePattern(filePath, ignoreFilePatterns)) {
       continue;
     }
     if (onProgress) {
-      const relativePath = path7.relative(tsConfigDir, sourceFile.getFilePath());
+      const relativePath = path7.relative(tsConfigDir, filePath);
       onProgress(relativePath);
     }
-    analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project);
-    analyzeTypeAliases(sourceFile, tsConfigDir, isTestFile, results, project);
+    analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project, analyzeOptions);
+    analyzeTypeAliases(sourceFile, tsConfigDir, isTestFile, results, project, analyzeOptions);
   }
   return results;
 }
@@ -606,9 +732,26 @@ function isTestFile(sourceFile) {
   const filePath = sourceFile.getFilePath();
   return filePath.includes("__tests__") || TEST_FILE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 }
+function createIsTestFile(patterns = defaultConfig.testFilePatterns) {
+  return (sourceFile) => {
+    const filePath = sourceFile.getFilePath();
+    return matchesFilePattern(filePath, patterns);
+  };
+}
 
 // src/analyzeProject.ts
-function analyzeProject(tsConfigPath, onProgress, targetFilePath, isTestFile2 = isTestFile) {
+function analyzeProject(tsConfigPath, onProgress, targetFilePath, isTestFileOrOptions) {
+  let options = {};
+  if (typeof isTestFileOrOptions === "function") {
+    options = { isTestFile: isTestFileOrOptions };
+  } else if (isTestFileOrOptions) {
+    options = isTestFileOrOptions;
+  }
+  const config = {
+    ...defaultConfig,
+    ...options.config
+  };
+  const isTestFile2 = options.isTestFile ? options.isTestFile : config.testFilePatterns ? createIsTestFile(config.testFilePatterns) : isTestFile;
   const project = new Project({
     tsConfigFilePath: tsConfigPath
   });
@@ -624,6 +767,9 @@ function analyzeProject(tsConfigPath, onProgress, targetFilePath, isTestFile2 =
     if (targetFilePath && sf.getFilePath() !== targetFilePath) {
       return false;
     }
+    if (config.ignoreFilePatterns.length > 0 && matchesFilePattern(sf.getFilePath(), config.ignoreFilePatterns)) {
+      return false;
+    }
     return true;
   });
   const totalFiles = filesToAnalyze.length;
@@ -636,33 +782,48 @@ function analyzeProject(tsConfigPath, onProgress, targetFilePath, isTestFile2 =
       onProgress(currentFile, totalFiles, filePath);
     }
   } : undefined;
-  const unusedExports = findUnusedExports(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath);
-  const unusedProperties = findUnusedProperties(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath);
-  const neverReturnedTypes = findNeverReturnedTypes(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath);
+  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
+  };
+  const unusedExports = config.analyzeExports ? findUnusedExports(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath, exportOptions) : [];
+  const unusedProperties = config.analyzeProperties ? findUnusedProperties(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath, propertyOptions) : [];
+  const neverReturnedTypes = config.analyzeNeverReturnedTypes ? findNeverReturnedTypes(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath, neverReturnedOptions) : [];
   const unusedFiles = [];
-  const fileExportCounts = new Map;
-  for (const sourceFile of filesToAnalyze) {
-    const filePath = path8.relative(tsConfigDir, sourceFile.getFilePath());
-    const exports = sourceFile.getExportedDeclarations();
-    const totalExports = exports.size;
-    if (totalExports > 0) {
-      fileExportCounts.set(filePath, { total: totalExports, unused: 0, testOnly: 0 });
+  if (config.detectUnusedFiles) {
+    const fileExportCounts = new Map;
+    for (const sourceFile of filesToAnalyze) {
+      const filePath = path8.relative(tsConfigDir, sourceFile.getFilePath());
+      const exports = sourceFile.getExportedDeclarations();
+      const totalExports = exports.size;
+      if (totalExports > 0) {
+        fileExportCounts.set(filePath, { total: totalExports, unused: 0, testOnly: 0 });
+      }
     }
-  }
-  for (const unusedExport of unusedExports) {
-    const counts = fileExportCounts.get(unusedExport.filePath);
-    if (counts) {
-      counts.unused++;
-      if (unusedExport.onlyUsedInTests) {
-        counts.testOnly++;
+    for (const unusedExport of unusedExports) {
+      const counts = fileExportCounts.get(unusedExport.filePath);
+      if (counts) {
+        counts.unused++;
+        if (unusedExport.onlyUsedInTests) {
+          counts.testOnly++;
+        }
       }
     }
-  }
-  for (const [filePath, counts] of fileExportCounts.entries()) {
-    const allExportsUnused = counts.total > 0 && counts.unused === counts.total;
-    const hasAnyTestOnlyExports = counts.testOnly > 0;
-    if (allExportsUnused && !hasAnyTestOnlyExports) {
-      unusedFiles.push(filePath);
+    for (const [filePath, counts] of fileExportCounts.entries()) {
+      const allExportsUnused = counts.total > 0 && counts.unused === counts.total;
+      const hasAnyTestOnlyExports = counts.testOnly > 0;
+      if (allExportsUnused && !hasAnyTestOnlyExports) {
+        unusedFiles.push(filePath);
+      }
     }
   }
   const results = {
@@ -1250,34 +1411,78 @@ function groupByFile(items) {
   return grouped;
 }
 
+// src/loadConfig.ts
+import fs2 from "node:fs";
+import path12 from "node:path";
+var CONFIG_FILE_NAME = "unused.config.ts";
+function loadConfigSync(targetDir, configPath) {
+  const resolvedConfigPath = configPath ? path12.resolve(configPath) : path12.join(targetDir, CONFIG_FILE_NAME);
+  if (!fs2.existsSync(resolvedConfigPath)) {
+    return { ...defaultConfig };
+  }
+  try {
+    const configModule = __require(resolvedConfigPath);
+    const userConfig = configModule.default ?? configModule;
+    return mergeConfig(userConfig);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load config from ${resolvedConfigPath}: ${errorMessage}`);
+  }
+}
+
 // src/cli.ts
+function parseArgs(args) {
+  let command = "check";
+  let tsConfigArg = "";
+  let configPath;
+  const positionalArgs = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--config" || arg === "-c") {
+      configPath = args[++i];
+    } else if (arg.startsWith("--config=")) {
+      configPath = arg.slice("--config=".length);
+    } else if (arg === "check" || arg === "fix") {
+      command = arg;
+    } else {
+      positionalArgs.push(arg);
+    }
+  }
+  tsConfigArg = positionalArgs[0] ?? "";
+  const targetFilePath = positionalArgs[1];
+  let tsConfigPath = path13.resolve(tsConfigArg);
+  if (fs3.existsSync(tsConfigPath) && fs3.statSync(tsConfigPath).isDirectory()) {
+    tsConfigPath = path13.join(tsConfigPath, "tsconfig.json");
+  }
+  return {
+    command,
+    tsConfigPath,
+    targetFilePath: targetFilePath ? path13.resolve(targetFilePath) : undefined,
+    configPath
+  };
+}
 function main() {
   const args = process.argv.slice(2);
   if (args.length === 0) {
-    console.log("Usage: ts-unused <command> <path-to-tsconfig.json> [file-path-to-check]");
+    console.log("Usage: ts-unused <command> <path-to-tsconfig.json> [file-path-to-check] [options]");
     console.log("");
     console.log("Commands:");
     console.log("  check  - Analyze and report unused exports/properties (default)");
     console.log("  fix    - Automatically remove unused exports/properties and delete unused files");
     console.log("");
+    console.log("Options:");
+    console.log("  --config, -c <path>  - Path to configuration file (default: unused.config.ts in project dir)");
+    console.log("");
     console.log("Examples:");
     console.log("  ts-unused check tsconfig.json");
     console.log("  ts-unused check ./project-dir    # looks for tsconfig.json inside");
     console.log("  ts-unused fix tsconfig.json");
+    console.log("  ts-unused check tsconfig.json --config ./unused.config.ts");
     process.exit(1);
   }
-  const firstArg = args[0] ?? "";
-  let command = "check";
-  let configIndex = 0;
-  if (firstArg === "check" || firstArg === "fix") {
-    command = firstArg;
-    configIndex = 1;
-  }
-  let tsConfigPath = path12.resolve(args[configIndex] ?? "");
-  if (fs2.existsSync(tsConfigPath) && fs2.statSync(tsConfigPath).isDirectory()) {
-    tsConfigPath = path12.join(tsConfigPath, "tsconfig.json");
-  }
-  const targetFilePath = args[configIndex + 1] ? path12.resolve(args[configIndex + 1]) : undefined;
+  const { command, tsConfigPath, targetFilePath, configPath } = parseArgs(args);
+  const tsConfigDir = path13.dirname(path13.resolve(tsConfigPath));
+  const config = loadConfigSync(tsConfigDir, configPath);
   if (command === "fix") {
     console.log(`Fixing TypeScript project: ${tsConfigPath}`);
     console.log("");
@@ -1316,11 +1521,10 @@ function main() {
       const filledLength = Math.min(barLength, Math.max(0, Math.floor(current / total * barLength)));
       const emptyLength = Math.max(0, barLength - filledLength);
       const bar = "█".repeat(filledLength) + "░".repeat(emptyLength);
-      const fileName = path12.basename(filePath);
+      const fileName = path13.basename(filePath);
       process.stdout.write(`\r\x1B[KProgress: [${bar}] ${percentage}% (${current}/${total}) ${fileName}`);
-    }, targetFilePath);
+    }, targetFilePath, { config });
     process.stdout.write("\r\x1B[K");
-    const tsConfigDir = path12.dirname(path12.resolve(tsConfigPath));
     const output = formatResults(results, tsConfigDir);
     console.log(output);
   }

package/dist/config.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Configuration options for ts-unused analysis.
+ */
+export interface UnusedConfig {
+    /**
+     * Patterns to identify test files. Supports glob patterns.
+     * Files matching these patterns will be treated as test files
+     * and their usages won't count as production usage.
+     *
+     * @default ["**\/*.test.ts", "**\/*.test.tsx", "**\/*.spec.ts", "**\/*.spec.tsx", "**\/__tests__/**"]
+     */
+    testFilePatterns?: string[];
+    /**
+     * Patterns for files to completely ignore during analysis.
+     * Supports glob patterns.
+     *
+     * @default []
+     */
+    ignoreFilePatterns?: string[];
+    /**
+     * Export names to ignore (will not be reported as unused).
+     * Supports exact names or glob patterns.
+     *
+     * @default []
+     */
+    ignoreExports?: string[];
+    /**
+     * Property names to ignore (will not be reported as unused).
+     * Supports exact names or glob patterns.
+     *
+     * @default []
+     */
+    ignoreProperties?: string[];
+    /**
+     * Type names to ignore (their properties will not be analyzed).
+     * Supports exact names or glob patterns.
+     *
+     * @default []
+     */
+    ignoreTypes?: string[];
+    /**
+     * Whether to ignore module augmentation declarations.
+     * Module augmentations (declare module "...") are typically used
+     * to extend existing types and don't have direct usages.
+     *
+     * @default true
+     */
+    ignoreModuleAugmentations?: boolean;
+    /**
+     * Whether to analyze properties for unused status.
+     *
+     * @default true
+     */
+    analyzeProperties?: boolean;
+    /**
+     * Whether to analyze exports for unused status.
+     *
+     * @default true
+     */
+    analyzeExports?: boolean;
+    /**
+     * Whether to analyze for never-returned types in function return types.
+     *
+     * @default true
+     */
+    analyzeNeverReturnedTypes?: boolean;
+    /**
+     * Whether to detect completely unused files.
+     *
+     * @default true
+     */
+    detectUnusedFiles?: boolean;
+}
+/**
+ * Default configuration values.
+ */
+export declare const defaultConfig: Required<UnusedConfig>;
+/**
+ * Helper function for creating a strongly-typed configuration file.
+ * Use this in your `unused.config.ts` file:
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from "ts-unused";
+ *
+ * export default defineConfig({
+ *   testFilePatterns: ["**\/*.test.ts", "**\/TestLogger.ts"],
+ *   ignoreExports: ["moduleAugmentation"],
+ * });
+ * ```
+ */
+export declare function defineConfig(config: UnusedConfig): UnusedConfig;
+/**
+ * Merges user config with default config.
+ */
+export declare function mergeConfig(userConfig: UnusedConfig): Required<UnusedConfig>;

package/dist/config.js

@@ -0,0 +1,50 @@
+/**
+ * Default configuration values.
+ */
+export const defaultConfig = {
+    testFilePatterns: ["**/*.test.ts", "**/*.test.tsx", "**/*.spec.ts", "**/*.spec.tsx", "**/__tests__/**"],
+    ignoreFilePatterns: [],
+    ignoreExports: [],
+    ignoreProperties: [],
+    ignoreTypes: [],
+    ignoreModuleAugmentations: true,
+    analyzeProperties: true,
+    analyzeExports: true,
+    analyzeNeverReturnedTypes: true,
+    detectUnusedFiles: true,
+};
+/**
+ * Helper function for creating a strongly-typed configuration file.
+ * Use this in your `unused.config.ts` file:
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from "ts-unused";
+ *
+ * export default defineConfig({
+ *   testFilePatterns: ["**\/*.test.ts", "**\/TestLogger.ts"],
+ *   ignoreExports: ["moduleAugmentation"],
+ * });
+ * ```
+ */
+export function defineConfig(config) {
+    return config;
+}
+/**
+ * Merges user config with default config.
+ */
+export function mergeConfig(userConfig) {
+    const result = {
+        testFilePatterns: userConfig.testFilePatterns ?? defaultConfig.testFilePatterns,
+        ignoreFilePatterns: userConfig.ignoreFilePatterns ?? defaultConfig.ignoreFilePatterns,
+        ignoreExports: userConfig.ignoreExports ?? defaultConfig.ignoreExports,
+        ignoreProperties: userConfig.ignoreProperties ?? defaultConfig.ignoreProperties,
+        ignoreTypes: userConfig.ignoreTypes ?? defaultConfig.ignoreTypes,
+        ignoreModuleAugmentations: userConfig.ignoreModuleAugmentations ?? defaultConfig.ignoreModuleAugmentations,
+        analyzeProperties: userConfig.analyzeProperties ?? defaultConfig.analyzeProperties,
+        analyzeExports: userConfig.analyzeExports ?? defaultConfig.analyzeExports,
+        analyzeNeverReturnedTypes: userConfig.analyzeNeverReturnedTypes ?? defaultConfig.analyzeNeverReturnedTypes,
+        detectUnusedFiles: userConfig.detectUnusedFiles ?? defaultConfig.detectUnusedFiles,
+    };
+    return result;
+}

package/dist/extractTodoComment.d.ts

@@ -0,0 +1,6 @@
+import type { PropertyDeclaration, PropertySignature } from "ts-morph";
+/**
+ * Extracts TODO comment text from the leading comments of a property.
+ * Returns undefined if no TODO comment is found.
+ */
+export declare function extractTodoComment(prop: PropertySignature | PropertyDeclaration): string | undefined;