@codeperfect/eslint-plugin 2.1.0 → 2.2.0

package/dist/domain/architecture/no-unused-exports/no-unused-exports-options.js

@@ -0,0 +1,141 @@
+import { minimatch } from "minimatch";
+import path from "node:path";
+/** Default public API files where exported symbols are intentionally exposed. */
+export const DEFAULT_PUBLIC_API_FILES = [
+    "**/src/index.ts",
+    "**/__tests__/**/*.ts",
+];
+/** Default glob patterns used to classify test files. */
+export const DEFAULT_TEST_FILE_PATTERNS = [
+    "**/*.{test,spec,e2e}.ts",
+    "**/__tests__/**/*.ts",
+];
+/** Default file pattern used to scope analysis to source files. */
+const DEFAULT_LINTABLE_FILE_PATTERN = "**/src/**/*.ts";
+/**
+ * Checks whether one path is absolute and non-empty.
+ * @param filename Input filename.
+ * @returns True when the path is absolute and non-empty.
+ * @example
+ * ```typescript
+ * const ok = isAbsolutePath("/repo/src/feature.ts");
+ * ```
+ */
+const isAbsolutePath = (filename) => filename.length > 0 && path.isAbsolute(filename);
+/**
+ * Checks whether one file path is lintable.
+ * @param filename Input filename.
+ * @returns True when the path is absolute and matches source-file scope.
+ * @example
+ * ```typescript
+ * const ok = isLintableFilename("/repo/src/feature.ts");
+ * ```
+ */
+export const isLintableFilename = (filename) => {
+    if (!isAbsolutePath(filename)) {
+        return false;
+    }
+    const normalizedPath = filename.split(path.sep).join("/");
+    return minimatch(normalizedPath, DEFAULT_LINTABLE_FILE_PATTERN, {
+        dot: true,
+    });
+};
+/**
+ * Normalizes one rule option value into a string list.
+ * @param value Raw option value.
+ * @param defaults Default values.
+ * @returns Normalized list.
+ * @example
+ * ```typescript
+ * const list = normalizeStringList(["src/**"], ["src/**"]);
+ * ```
+ */
+const normalizeStringList = (value, defaults) => {
+    if (Array.isArray(value)) {
+        const normalized = value
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0);
+        return normalized.length > 0 ? normalized : [...defaults];
+    }
+    return [...defaults];
+};
+/**
+ * Builds normalized options from raw rule options.
+ * @param options Raw rule options.
+ * @returns Normalized options state.
+ * @example
+ * ```typescript
+ * const state = getOptions([{}]);
+ * ```
+ */
+export const getOptions = (options) => {
+    const raw = options[0];
+    return {
+        publicApiFiles: normalizeStringList(raw?.publicApiFiles, DEFAULT_PUBLIC_API_FILES),
+        testFilePatterns: normalizeStringList(raw?.testFilePatterns, DEFAULT_TEST_FILE_PATTERNS),
+    };
+};
+/**
+ * Converts an absolute filename into a repo-root-relative POSIX path.
+ * @param filename Absolute filename.
+ * @param repoRoot Absolute repository root.
+ * @returns Repo-relative POSIX path or undefined when outside repo root.
+ * @example
+ * ```typescript
+ * const relativePath = toRepoRelativePosixPath("/repo/src/feature.ts", "/repo");
+ * ```
+ */
+const toRepoRelativePosixPath = (filename, repoRoot) => {
+    if (!isAbsolutePath(filename) || !isAbsolutePath(repoRoot)) {
+        return void 0;
+    }
+    const relativePath = path.relative(repoRoot, filename);
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+        return void 0;
+    }
+    return relativePath.split(path.sep).join("/");
+};
+/**
+ * Checks whether one filename matches any glob pattern.
+ * @param filename Absolute filename.
+ * @param patterns Glob patterns.
+ * @param repoRoot Absolute repository root.
+ * @returns True when any pattern matches.
+ * @example
+ * ```typescript
+ * const match = matchesAnyPattern("/repo/src/index.ts", ["src-pattern"], "/repo");
+ * ```
+ */
+const matchesAnyPattern = (filename, patterns, repoRoot) => {
+    const relativePath = toRepoRelativePosixPath(filename, repoRoot);
+    if (relativePath === void 0 || patterns.length === 0) {
+        return false;
+    }
+    return patterns.some((pattern) => minimatch(relativePath, pattern, { dot: true }));
+};
+/**
+ * Checks whether one file defines a public API export surface.
+ * @param filename Absolute filename.
+ * @param state Normalized options.
+ * @param repoRoot Absolute repository root.
+ * @returns True when the file is a public API file.
+ * @example
+ * ```typescript
+ * const publicApiFile = isPublicApiFile("/repo/src/index.ts", state, "/repo");
+ * ```
+ */
+export const isPublicApiFile = (filename, state, repoRoot) => matchesAnyPattern(filename, state.publicApiFiles, repoRoot);
+/**
+ * Checks whether one file should be treated as a test file.
+ * @param filename Absolute filename.
+ * @param state Normalized options.
+ * @param repoRoot Absolute repository root.
+ * @returns True when the file path matches a test pattern.
+ * @example
+ * ```typescript
+ * const testFile = isTestFile("/repo/tests/e2e/demo.ts", state, "/repo");
+ * ```
+ */
+export const isTestFile = (filename, state, repoRoot) => matchesAnyPattern(filename, state.testFilePatterns, repoRoot);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-unused-exports-options.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-options.ts"],"names":[],"mappings":"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","sourcesContent":["import { minimatch } from \"minimatch\";\nimport path from \"node:path\";\n\nimport type { NoUnusedExportsOptions, NoUnusedExportsState } from \"./types\";\n\n/** Default public API files where exported symbols are intentionally exposed. */\nexport const DEFAULT_PUBLIC_API_FILES = [\n  \"**/src/index.ts\",\n  \"**/__tests__/**/*.ts\",\n] as const;\n\n/** Default glob patterns used to classify test files. */\nexport const DEFAULT_TEST_FILE_PATTERNS = [\n  \"**/*.{test,spec,e2e}.ts\",\n  \"**/__tests__/**/*.ts\",\n] as const;\n\n/** Default file pattern used to scope analysis to source files. */\nconst DEFAULT_LINTABLE_FILE_PATTERN = \"**/src/**/*.ts\";\n\n/**\n * Checks whether one path is absolute and non-empty.\n * @param filename Input filename.\n * @returns True when the path is absolute and non-empty.\n * @example\n * ```typescript\n * const ok = isAbsolutePath(\"/repo/src/feature.ts\");\n * ```\n */\nconst isAbsolutePath = (filename: string): boolean =>\n  filename.length > 0 && path.isAbsolute(filename);\n\n/**\n * Checks whether one file path is lintable.\n * @param filename Input filename.\n * @returns True when the path is absolute and matches source-file scope.\n * @example\n * ```typescript\n * const ok = isLintableFilename(\"/repo/src/feature.ts\");\n * ```\n */\nexport const isLintableFilename = (filename: string): boolean => {\n  if (!isAbsolutePath(filename)) {\n    return false;\n  }\n\n  const normalizedPath = filename.split(path.sep).join(\"/\");\n\n  return minimatch(normalizedPath, DEFAULT_LINTABLE_FILE_PATTERN, {\n    dot: true,\n  });\n};\n\n/**\n * Normalizes one rule option value into a string list.\n * @param value Raw option value.\n * @param defaults Default values.\n * @returns Normalized list.\n * @example\n * ```typescript\n * const list = normalizeStringList([\"src/**\"], [\"src/**\"]);\n * ```\n */\nconst normalizeStringList = (\n  value: unknown,\n  defaults: readonly string[],\n): string[] => {\n  if (Array.isArray(value)) {\n    const normalized = value\n      .filter((entry): entry is string => typeof entry === \"string\")\n      .map((entry) => entry.trim())\n      .filter((entry) => entry.length > 0);\n\n    return normalized.length > 0 ? normalized : [...defaults];\n  }\n\n  return [...defaults];\n};\n\n/**\n * Builds normalized options from raw rule options.\n * @param options Raw rule options.\n * @returns Normalized options state.\n * @example\n * ```typescript\n * const state = getOptions([{}]);\n * ```\n */\nexport const getOptions = (\n  options: readonly unknown[],\n): NoUnusedExportsState => {\n  const raw = options[0] as NoUnusedExportsOptions | undefined;\n\n  return {\n    publicApiFiles: normalizeStringList(\n      raw?.publicApiFiles,\n      DEFAULT_PUBLIC_API_FILES,\n    ),\n    testFilePatterns: normalizeStringList(\n      raw?.testFilePatterns,\n      DEFAULT_TEST_FILE_PATTERNS,\n    ),\n  };\n};\n\n/**\n * Converts an absolute filename into a repo-root-relative POSIX path.\n * @param filename Absolute filename.\n * @param repoRoot Absolute repository root.\n * @returns Repo-relative POSIX path or undefined when outside repo root.\n * @example\n * ```typescript\n * const relativePath = toRepoRelativePosixPath(\"/repo/src/feature.ts\", \"/repo\");\n * ```\n */\nconst toRepoRelativePosixPath = (\n  filename: string,\n  repoRoot: string,\n): string | undefined => {\n  if (!isAbsolutePath(filename) || !isAbsolutePath(repoRoot)) {\n    return void 0;\n  }\n\n  const relativePath = path.relative(repoRoot, filename);\n\n  if (relativePath.startsWith(\"..\") || path.isAbsolute(relativePath)) {\n    return void 0;\n  }\n\n  return relativePath.split(path.sep).join(\"/\");\n};\n\n/**\n * Checks whether one filename matches any glob pattern.\n * @param filename Absolute filename.\n * @param patterns Glob patterns.\n * @param repoRoot Absolute repository root.\n * @returns True when any pattern matches.\n * @example\n * ```typescript\n * const match = matchesAnyPattern(\"/repo/src/index.ts\", [\"src-pattern\"], \"/repo\");\n * ```\n */\nconst matchesAnyPattern = (\n  filename: string,\n  patterns: string[],\n  repoRoot: string,\n): boolean => {\n  const relativePath = toRepoRelativePosixPath(filename, repoRoot);\n\n  if (relativePath === void 0 || patterns.length === 0) {\n    return false;\n  }\n\n  return patterns.some((pattern) =>\n    minimatch(relativePath, pattern, { dot: true }),\n  );\n};\n\n/**\n * Checks whether one file defines a public API export surface.\n * @param filename Absolute filename.\n * @param state Normalized options.\n * @param repoRoot Absolute repository root.\n * @returns True when the file is a public API file.\n * @example\n * ```typescript\n * const publicApiFile = isPublicApiFile(\"/repo/src/index.ts\", state, \"/repo\");\n * ```\n */\nexport const isPublicApiFile = (\n  filename: string,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n): boolean => matchesAnyPattern(filename, state.publicApiFiles, repoRoot);\n\n/**\n * Checks whether one file should be treated as a test file.\n * @param filename Absolute filename.\n * @param state Normalized options.\n * @param repoRoot Absolute repository root.\n * @returns True when the file path matches a test pattern.\n * @example\n * ```typescript\n * const testFile = isTestFile(\"/repo/tests/e2e/demo.ts\", state, \"/repo\");\n * ```\n */\nexport const isTestFile = (\n  filename: string,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n): boolean => matchesAnyPattern(filename, state.testFilePatterns, repoRoot);\n"]}

package/dist/domain/architecture/no-unused-exports/no-unused-exports-utilities.d.ts

@@ -0,0 +1,49 @@
+import type { AST, Rule } from "eslint";
+import * as ts from "typescript";
+import type { ExportedElement, ExportUsage, NoUnusedExportsState } from "./types.js";
+/**
+ * Resolves TypeScript parser services program when available.
+ * @param context Rule context.
+ * @returns TypeScript program when available.
+ * @example
+ * ```typescript
+ * const program = getTypeScriptProgram(context);
+ * ```
+ */
+declare const getTypeScriptProgram: (context: Rule.RuleContext) => ts.Program | undefined;
+/**
+ * Collects exported elements from one program body.
+ * @param body Program body statements.
+ * @returns Exported elements in declaration order.
+ * @example
+ * ```typescript
+ * const exported = collectExportedElements(program.body);
+ * ```
+ */
+declare const collectExportedElements: (body: AST.Program["body"]) => ExportedElement[];
+/**
+ * Collects concrete usages of one exported element across the program.
+ * @param program TypeScript program.
+ * @param sourceFilename Source filename where export is defined.
+ * @param state Normalized rule options.
+ * @param repoRoot Absolute repository root used for test-file classification.
+ * @param exportedElement Exported element to classify.
+ * @returns Concrete usages for the exported element.
+ * @example
+ * ```typescript
+ * const usages = collectCrossFileUsages(program, "/repo/src/feature.ts", state, "/repo", exportedElement);
+ * ```
+ */
+declare const collectCrossFileUsages: (program: ts.Program, sourceFilename: string, state: NoUnusedExportsState, repoRoot: string, exportedElement: ExportedElement) => ExportUsage[];
+/**
+ * Classifies one exported name based on cross-file usages.
+ * @param usages Collected usages.
+ * @returns Classification label.
+ * @example
+ * ```typescript
+ * const classification = classifyExportUsage("feature", usages);
+ * ```
+ */
+declare const classifyExportUsage: (usages: ExportUsage[]) => "production" | "test-only" | "unused";
+export { classifyExportUsage, collectCrossFileUsages, collectExportedElements, getTypeScriptProgram, };
+//# sourceMappingURL=no-unused-exports-utilities.d.ts.map

package/dist/domain/architecture/no-unused-exports/no-unused-exports-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-exports-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAIxC,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EACV,eAAe,EAEf,WAAW,EACX,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAgFjB;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,GACxB,SAAS,IAAI,CAAC,WAAW,KACxB,EAAE,CAAC,OAAO,GAAG,SAOf,CAAC;AA0LF;;;;;;;;GAQG;AACH,QAAA,MAAM,uBAAuB,GAC3B,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,KACxB,eAAe,EAsFjB,CAAC;AA+VF;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,sBAAsB,GAC1B,SAAS,EAAE,CAAC,OAAO,EACnB,gBAAgB,MAAM,EACtB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,iBAAiB,eAAe,KAC/B,WAAW,EAoDb,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GACvB,QAAQ,WAAW,EAAE,KACpB,YAAY,GAAG,WAAW,GAAG,QAY/B,CAAC;AAEF,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,EACvB,oBAAoB,GACrB,CAAC"}