ts-unused 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export type { AnalyzeProjectOptions } from "./analyzeProject";
+export { analyzeProject } from "./analyzeProject";
+export type { UnusedConfig } from "./config";
+export { defaultConfig, defineConfig, mergeConfig } from "./config";
+export { findUnusedExports } from "./findUnusedExports";
+export { findUnusedProperties } from "./findUnusedProperties";
+export type { FixResults } from "./fixProject";
+export { fixProject } from "./fixProject";
+export { formatResults } from "./formatResults";
+export type { PropertyUsageResult } from "./isPropertyUnused";
+export { createIsTestFile, isTestFile } from "./isTestFile";
+export { loadConfig, loadConfigSync } from "./loadConfig";
+export { matchesFilePattern, matchesPattern, patternToRegex } from "./patternMatcher";
+export type { AnalysisResults, ExportKind, IsTestFileFn, NeverReturnedTypeResult, Severity, UnusedExportResult, UnusedPropertyResult, } from "./types";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { analyzeProject } from "./analyzeProject";
+export { defaultConfig, defineConfig, mergeConfig } from "./config";
+export { findUnusedExports } from "./findUnusedExports";
+export { findUnusedProperties } from "./findUnusedProperties";
+export { fixProject } from "./fixProject";
+export { formatResults } from "./formatResults";
+export { createIsTestFile, isTestFile } from "./isTestFile";
+export { loadConfig, loadConfigSync } from "./loadConfig";
+export { matchesFilePattern, matchesPattern, patternToRegex } from "./patternMatcher";

package/dist/isPropertyUnused.d.ts

@@ -0,0 +1,7 @@
+import type { Project, PropertyDeclaration, PropertySignature } from "ts-morph";
+import type { IsTestFileFn } from "./types";
+export interface PropertyUsageResult {
+    isUnusedOrTestOnly: boolean;
+    onlyUsedInTests: boolean;
+}
+export declare function isPropertyUnused(prop: PropertySignature | PropertyDeclaration, isTestFile: IsTestFileFn, project: Project): PropertyUsageResult;

package/dist/isPropertyUnused.js

@@ -0,0 +1,48 @@
+import { findStructurallyEquivalentProperties } from "./findStructurallyEquivalentProperties";
+function countPropertyReferences(prop, isTestFile) {
+    const references = prop.findReferences();
+    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++;
+            }
+        }
+    }
+    const result = {
+        totalReferences,
+        testReferences,
+        nonTestReferences,
+    };
+    return result;
+}
+export function isPropertyUnused(prop, isTestFile, project) {
+    const counts = countPropertyReferences(prop, isTestFile);
+    // A property is unused if it only has 1 reference (the definition itself)
+    // A property is test-only if it has references only from tests
+    const onlyUsedInTests = counts.nonTestReferences === 1 && counts.testReferences > 0;
+    if (counts.totalReferences > 1 && !onlyUsedInTests) {
+        const result = { isUnusedOrTestOnly: false, onlyUsedInTests: false };
+        return result; // Used in production code
+    }
+    // Check structurally equivalent properties
+    const equivalentProps = findStructurallyEquivalentProperties(prop, project);
+    for (const equivalentProp of equivalentProps) {
+        const equivalentCounts = countPropertyReferences(equivalentProp, isTestFile);
+        const equivalentOnlyUsedInTests = equivalentCounts.nonTestReferences === 1 && equivalentCounts.testReferences > 0;
+        if (equivalentCounts.totalReferences > 1 && !equivalentOnlyUsedInTests) {
+            const result = { isUnusedOrTestOnly: false, onlyUsedInTests: false };
+            return result;
+        }
+    }
+    const result = { isUnusedOrTestOnly: true, onlyUsedInTests };
+    return result;
+}

package/dist/isTestFile.d.ts

@@ -0,0 +1,14 @@
+import type { SourceFile } from "ts-morph";
+import type { IsTestFileFn } from "./types";
+/**
+ * Default test file detection using built-in patterns.
+ * Checks for test file extensions and __tests__ directory.
+ */
+export declare function isTestFile(sourceFile: SourceFile): boolean;
+/**
+ * Creates a test file detection function based on custom patterns.
+ *
+ * @param patterns - Array of glob patterns to identify test files
+ * @returns A function that checks if a source file is a test file
+ */
+export declare function createIsTestFile(patterns?: string[]): IsTestFileFn;

package/dist/isTestFile.js

@@ -0,0 +1,23 @@
+import { defaultConfig } from "./config";
+import { matchesFilePattern } from "./patternMatcher";
+const TEST_FILE_EXTENSIONS = [".test.ts", ".test.tsx", ".spec.ts", ".spec.tsx"];
+/**
+ * Default test file detection using built-in patterns.
+ * Checks for test file extensions and __tests__ directory.
+ */
+export function isTestFile(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    return filePath.includes("__tests__") || TEST_FILE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+}
+/**
+ * Creates a test file detection function based on custom patterns.
+ *
+ * @param patterns - Array of glob patterns to identify test files
+ * @returns A function that checks if a source file is a test file
+ */
+export function createIsTestFile(patterns = defaultConfig.testFilePatterns) {
+    return (sourceFile) => {
+        const filePath = sourceFile.getFilePath();
+        return matchesFilePattern(filePath, patterns);
+    };
+}

package/dist/loadConfig.d.ts

@@ -0,0 +1,20 @@
+import { type UnusedConfig } from "./config";
+/**
+ * Loads configuration from the target directory.
+ * Looks for `unused.config.ts` in the specified directory.
+ * If not found, returns default configuration.
+ *
+ * @param targetDir - The directory to look for the config file
+ * @param configPath - Optional explicit path to config file
+ * @returns The merged configuration
+ */
+export declare function loadConfig(targetDir: string, configPath?: string): Promise<Required<UnusedConfig>>;
+/**
+ * Synchronous version of loadConfig for backward compatibility.
+ * Uses Bun's sync import capabilities.
+ *
+ * @param targetDir - The directory to look for the config file
+ * @param configPath - Optional explicit path to config file
+ * @returns The merged configuration
+ */
+export declare function loadConfigSync(targetDir: string, configPath?: string): Required<UnusedConfig>;

package/dist/loadConfig.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import path from "node:path";
+import { defaultConfig, mergeConfig } from "./config";
+const CONFIG_FILE_NAME = "unused.config.ts";
+/**
+ * Loads configuration from the target directory.
+ * Looks for `unused.config.ts` in the specified directory.
+ * If not found, returns default configuration.
+ *
+ * @param targetDir - The directory to look for the config file
+ * @param configPath - Optional explicit path to config file
+ * @returns The merged configuration
+ */
+export async function loadConfig(targetDir, configPath) {
+    const resolvedConfigPath = configPath ? path.resolve(configPath) : path.join(targetDir, CONFIG_FILE_NAME);
+    if (!fs.existsSync(resolvedConfigPath)) {
+        return { ...defaultConfig };
+    }
+    try {
+        // Use dynamic import to load the TypeScript config file
+        // Bun natively supports TypeScript imports
+        const configModule = await import(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}`);
+    }
+}
+/**
+ * Synchronous version of loadConfig for backward compatibility.
+ * Uses Bun's sync import capabilities.
+ *
+ * @param targetDir - The directory to look for the config file
+ * @param configPath - Optional explicit path to config file
+ * @returns The merged configuration
+ */
+export function loadConfigSync(targetDir, configPath) {
+    const resolvedConfigPath = configPath ? path.resolve(configPath) : path.join(targetDir, CONFIG_FILE_NAME);
+    if (!fs.existsSync(resolvedConfigPath)) {
+        return { ...defaultConfig };
+    }
+    try {
+        // Bun supports synchronous require of TypeScript files
+        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}`);
+    }
+}

package/dist/patternMatcher.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Converts a glob-like pattern to a RegExp.
+ * Supports:
+ * - `*` matches any characters except `/`
+ * - `**` matches any characters including `/`
+ * - `?` matches any single character
+ */
+export declare function patternToRegex(pattern: string): RegExp;
+/**
+ * Checks if a string matches any of the given patterns.
+ * Patterns can be exact strings or glob-like patterns.
+ *
+ * @param value - The string to test
+ * @param patterns - Array of patterns to match against
+ * @returns true if the value matches any pattern
+ */
+export declare function matchesPattern(value: string, patterns: string[]): boolean;
+/**
+ * Checks if a file path matches any of the given patterns.
+ * Normalizes the path before matching.
+ *
+ * @param filePath - The file path to test (can be absolute or relative)
+ * @param patterns - Array of glob patterns to match against
+ * @returns true if the file matches any pattern
+ */
+export declare function matchesFilePattern(filePath: string, patterns: string[]): boolean;

package/dist/patternMatcher.js

@@ -0,0 +1,83 @@
+/**
+ * Converts a glob-like pattern to a RegExp.
+ * Supports:
+ * - `*` matches any characters except `/`
+ * - `**` matches any characters including `/`
+ * - `?` matches any single character
+ */
+export function patternToRegex(pattern) {
+    // Escape special regex characters except * and ?
+    let regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    // Use placeholders to handle ** before * to avoid conflicts
+    // Replace ** with a unique placeholder first
+    const DOUBLE_STAR_PLACEHOLDER = "<<DOUBLESTAR>>";
+    regexStr = regexStr.replace(/\*\*/g, DOUBLE_STAR_PLACEHOLDER);
+    // Convert single * to match anything except /
+    regexStr = regexStr.replace(/\*/g, "[^/]*");
+    // Convert ** placeholder back to match anything including /
+    regexStr = regexStr.split(DOUBLE_STAR_PLACEHOLDER).join(".*");
+    // Convert ? to match any single character
+    regexStr = regexStr.replace(/\?/g, ".");
+    return new RegExp(`^${regexStr}$`);
+}
+/**
+ * Checks if a string matches any of the given patterns.
+ * Patterns can be exact strings or glob-like patterns.
+ *
+ * @param value - The string to test
+ * @param patterns - Array of patterns to match against
+ * @returns true if the value matches any pattern
+ */
+export function matchesPattern(value, patterns) {
+    for (const pattern of patterns) {
+        // Check exact match first
+        if (pattern === value) {
+            return true;
+        }
+        // Check glob pattern
+        if (pattern.includes("*") || pattern.includes("?")) {
+            const regex = patternToRegex(pattern);
+            if (regex.test(value)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Checks if a file path matches any of the given patterns.
+ * Normalizes the path before matching.
+ *
+ * @param filePath - The file path to test (can be absolute or relative)
+ * @param patterns - Array of glob patterns to match against
+ * @returns true if the file matches any pattern
+ */
+export function matchesFilePattern(filePath, patterns) {
+    // Normalize path separators
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    for (const pattern of patterns) {
+        const normalizedPattern = pattern.replace(/\\/g, "/");
+        // Check if pattern matches anywhere in the path
+        if (normalizedPattern.startsWith("**/")) {
+            // Pattern like **/*.test.ts should match any path ending with .test.ts
+            const suffixPattern = normalizedPattern.slice(3);
+            const regex = patternToRegex(`**/${suffixPattern}`);
+            if (regex.test(normalizedPath)) {
+                return true;
+            }
+            // Also check if just the suffix matches the end
+            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;
+}

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+import type { SourceFile } from "ts-morph";
+export type Severity = "error" | "warning" | "info";
+export type ExportKind = "function" | "class" | "interface" | "type" | "const" | "variable" | "enum" | "namespace" | "export";
+export interface UnusedExportResult {
+    filePath: string;
+    exportName: string;
+    line: number;
+    character: number;
+    endCharacter: number;
+    kind: ExportKind;
+    severity: Severity;
+    onlyUsedInTests: boolean;
+}
+export interface UnusedPropertyResult {
+    filePath: string;
+    typeName: string;
+    propertyName: string;
+    line: number;
+    character: number;
+    endCharacter: number;
+    todoComment?: string;
+    severity: Severity;
+    onlyUsedInTests: boolean;
+}
+export interface NeverReturnedTypeResult {
+    filePath: string;
+    functionName: string;
+    neverReturnedType: string;
+    line: number;
+    character: number;
+    endCharacter: number;
+    severity: Severity;
+}
+export interface AnalysisResults {
+    unusedExports: UnusedExportResult[];
+    unusedProperties: UnusedPropertyResult[];
+    unusedFiles: string[];
+    neverReturnedTypes?: NeverReturnedTypeResult[];
+}
+export type IsTestFileFn = (sourceFile: SourceFile) => boolean;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,19 +1,28 @@
 {
   "name": "ts-unused",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Find unused exports and properties in TypeScript projects",
   "license": "MIT",
   "bin": {
     "ts-unused": "dist/cli.js"
   },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
     "dist"
   ],
   "type": "module",
   "scripts": {
     "clean": "rm -rf dist",
-    "build:js": "bun build src/cli.ts --outdir dist --target node --external ts-morph --external typescript",
-    "build": "bun clean && bun build:js",
+    "build:cli": "bun build src/cli.ts --outdir dist --target node --external ts-morph --external typescript",
+    "build:lib": "tsgo --project tsconfig.build.json",
+    "build": "bun clean && bun build:cli && bun build:lib",
     "typecheck": "tsgo --noEmit",
     "lint": "bun run fix && biome check src",
     "fix": "biome check --write --unsafe src",