eslint-plugin-unslop 0.6.1 → 0.7.0

package/dist/index.cjs

@@ -37,7 +37,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-unslop",
-  version: "0.6.1",
+  version: "0.7.0",
   description: "ESLint plugin with rules for reducing AI-generated code smells",
   repository: {
     type: "git",
@@ -301,7 +301,7 @@ var WRAPPER_UNSAFE = {
 
 // src/rules/no-false-sharing/index.ts
 var import_node_path4 = __toESM(require("path"), 1);
-var import_typescript3 = __toESM(require("typescript"), 1);
+var import_typescript4 = __toESM(require("typescript"), 1);
 
 // src/utils/architecture-policy.ts
 var import_node_path3 = __toESM(require("path"), 1);
@@ -764,6 +764,61 @@ function hasStringName(value) {
   return typeof id.name === "string";
 }
 
+// src/utils/project-symbol-usage.ts
+var import_typescript3 = __toESM(require("typescript"), 1);
+function findTsSourceFile(program, filename) {
+  const normalized = normalizeResolvedPath2(filename);
+  return program.getSourceFiles().find((sf) => normalizeResolvedPath2(sf.fileName) === normalized);
+}
+function countProjectWideUses(targetSymbol, checker, program) {
+  let total = 0;
+  for (const sf of program.getSourceFiles()) {
+    if (sf.isDeclarationFile) continue;
+    total += countUsesInFile(sf, targetSymbol, checker);
+  }
+  return total;
+}
+function countUsesInFile(sourceFile, targetSymbol, checker) {
+  let count = 0;
+  function walk(node) {
+    if (import_typescript3.default.isIdentifier(node) && isCountableUse(node, targetSymbol, checker)) {
+      count++;
+    }
+    import_typescript3.default.forEachChild(node, walk);
+  }
+  walk(sourceFile);
+  return count;
+}
+function isCountableUse(node, targetSymbol, checker) {
+  if (!isRealUsagePosition(node)) return false;
+  const sym = checker.getSymbolAtLocation(node);
+  if (sym === void 0) return false;
+  return resolveCanonicalSymbol(sym, checker) === targetSymbol;
+}
+function isRealUsagePosition(node) {
+  const parent = node.parent;
+  if (isDeclarationBinding(parent, node)) return false;
+  if (isImportPosition(parent, node)) return false;
+  if (import_typescript3.default.isExportSpecifier(parent)) return false;
+  if (import_typescript3.default.isExportAssignment(parent)) return false;
+  return true;
+}
+function isDeclarationBinding(parent, node) {
+  return isNamedDeclParent(parent) && parent.name === node;
+}
+function isNamedDeclParent(parent) {
+  return import_typescript3.default.isVariableDeclaration(parent) || import_typescript3.default.isTypeAliasDeclaration(parent) || import_typescript3.default.isInterfaceDeclaration(parent) || import_typescript3.default.isFunctionDeclaration(parent) || import_typescript3.default.isClassDeclaration(parent);
+}
+function isImportPosition(parent, node) {
+  if (import_typescript3.default.isImportSpecifier(parent)) return true;
+  if (import_typescript3.default.isImportClause(parent) && parent.name === node) return true;
+  return import_typescript3.default.isNamespaceImport(parent) && parent.name === node;
+}
+function resolveCanonicalSymbol(symbol, checker) {
+  if ((symbol.flags & import_typescript3.default.SymbolFlags.Alias) === 0) return symbol;
+  return checker.getAliasedSymbol(symbol);
+}
+
 // src/rules/no-false-sharing/index.ts
 var no_false_sharing_default = {
   meta: {
@@ -954,11 +1009,11 @@ function isProjectSourceFile(filePath, options) {
 function collectImportedSymbolUsages(sourceFile, projectContext) {
   const usages = [];
   for (const statement of sourceFile.statements) {
-    if (import_typescript3.default.isImportDeclaration(statement)) {
+    if (import_typescript4.default.isImportDeclaration(statement)) {
       addImportDeclarationUsages(statement, sourceFile, projectContext, usages);
       continue;
     }
-    if (import_typescript3.default.isExportDeclaration(statement)) {
+    if (import_typescript4.default.isExportDeclaration(statement)) {
       addExportDeclarationUsages(statement, sourceFile, projectContext, usages);
     }
   }
@@ -972,7 +1027,7 @@ function addImportDeclarationUsages(statement, sourceFile, projectContext, usage
     addIdentifierUsage(statement.importClause.name, targetFile, projectContext, usages);
   }
   const namedBindings = statement.importClause.namedBindings;
-  if (namedBindings === void 0 || !import_typescript3.default.isNamedImports(namedBindings)) return;
+  if (namedBindings === void 0 || !import_typescript4.default.isNamedImports(namedBindings)) return;
   for (const element of namedBindings.elements) {
     addIdentifierUsage(element.name, targetFile, projectContext, usages);
   }
@@ -980,15 +1035,15 @@ function addImportDeclarationUsages(statement, sourceFile, projectContext, usage
 function addExportDeclarationUsages(statement, sourceFile, projectContext, usages) {
   const targetFile = getResolvedTargetFile(statement.moduleSpecifier, sourceFile, projectContext);
   if (targetFile === void 0) return;
-  if (statement.exportClause === void 0 || !import_typescript3.default.isNamedExports(statement.exportClause)) return;
+  if (statement.exportClause === void 0 || !import_typescript4.default.isNamedExports(statement.exportClause)) return;
   for (const element of statement.exportClause.elements) {
     const reference = element.propertyName ?? element.name;
-    if (!import_typescript3.default.isIdentifier(reference)) continue;
+    if (!import_typescript4.default.isIdentifier(reference)) continue;
     addIdentifierUsage(reference, targetFile, projectContext, usages);
   }
 }
 function getResolvedTargetFile(moduleSpecifier, sourceFile, projectContext) {
-  if (moduleSpecifier === void 0 || !import_typescript3.default.isStringLiteral(moduleSpecifier)) return void 0;
+  if (moduleSpecifier === void 0 || !import_typescript4.default.isStringLiteral(moduleSpecifier)) return void 0;
   return resolveImportTarget(sourceFile.fileName, projectContext, moduleSpecifier.text);
 }
 function addIdentifierUsage(identifier, targetFile, projectContext, usages) {
@@ -1000,7 +1055,7 @@ function addIdentifierUsage(identifier, targetFile, projectContext, usages) {
   usages.push({ canonicalKey, targetFile });
 }
 function getCanonicalSymbol(checker, symbol) {
-  if ((symbol.flags & import_typescript3.default.SymbolFlags.Alias) === 0) return symbol;
+  if ((symbol.flags & import_typescript4.default.SymbolFlags.Alias) === 0) return symbol;
   return checker.getAliasedSymbol(symbol);
 }
 function getCanonicalSymbolKey(symbol) {
@@ -1285,17 +1340,23 @@ function visitValue(val, visit) {
 
 // src/rules/read-friendly-order/kahns-sort.ts
 function kahnsTopologicalSort(items, priority) {
-  const byName = new Map(items.filter((e) => e.name).map((e) => [e.name, e]));
-  const inDeg = buildInDegrees(items, byName);
+  const byName = /* @__PURE__ */ new Map();
+  for (const e of items) {
+    if (e.name) byName.set(e.name, e);
+  }
+  const { inDeg, eagerDependents } = buildInDegrees(items, byName);
   const queue = items.filter((e) => !e.name || inDeg.get(e.name) === 0);
   const result = [];
-  const state = { placed: /* @__PURE__ */ new Set(), inDeg, byName };
+  const state = { placed: /* @__PURE__ */ new Set(), inDeg, byName, eagerDependents };
   drainQueue(queue, result, state, priority);
   appendRemaining(items, result, state.placed);
   return result;
 }
 function findCyclicNames(items) {
-  const byName = new Map(items.filter((e) => e.name).map((e) => [e.name, e]));
+  const byName = /* @__PURE__ */ new Map();
+  for (const e of items) {
+    if (e.name) byName.set(e.name, e);
+  }
   const inCycle = /* @__PURE__ */ new Set();
   for (const [name] of byName) {
     if (reachesSelf(name, name, byName, /* @__PURE__ */ new Set())) {
@@ -1306,33 +1367,67 @@ function findCyclicNames(items) {
 }
 function buildInDegrees(items, byName) {
   const inDeg = /* @__PURE__ */ new Map();
-  for (const [name] of byName) inDeg.set(name, 0);
+  const eagerDependents = /* @__PURE__ */ new Map();
+  for (const [name] of byName) {
+    inDeg.set(name, 0);
+    eagerDependents.set(name, []);
+  }
   for (const item of items) {
-    for (const d of item.deps) {
-      if (inDeg.has(d)) inDeg.set(d, inDeg.get(d) + 1);
+    processItemDeps(item, inDeg, eagerDependents);
+  }
+  return { inDeg, eagerDependents };
+}
+function processItemDeps(item, inDeg, eagerDependents) {
+  for (const d of item.deps) {
+    if (!inDeg.has(d)) continue;
+    if (item.eager && item.name && inDeg.has(item.name)) {
+      addEagerDependent(item.name, d, inDeg, eagerDependents);
+    } else {
+      inDeg.set(d, (inDeg.get(d) ?? 0) + 1);
     }
   }
-  return inDeg;
+}
+function addEagerDependent(consumerName, dep, inDeg, eagerDependents) {
+  inDeg.set(consumerName, (inDeg.get(consumerName) ?? 0) + 1);
+  const list = eagerDependents.get(dep) ?? [];
+  list.push(consumerName);
+  eagerDependents.set(dep, list);
 }
 function drainQueue(queue, result, state, priority) {
   while (queue.length > 0) {
     queue.sort((a, b) => (priority ? priority(a) - priority(b) : 0) || a.idx - b.idx);
     const item = queue.shift();
+    if (item === void 0) break;
     result.push(item);
     if (item.name) state.placed.add(item.name);
     decrementDeps(item, queue, state);
   }
 }
 function decrementDeps(item, queue, state) {
+  decrementNonEager(item, queue, state);
+  decrementEager(item, queue, state);
+}
+function decrementNonEager(item, queue, state) {
   for (const d of item.deps) {
     if (state.placed.has(d) || !state.inDeg.has(d)) continue;
-    state.inDeg.set(d, state.inDeg.get(d) - 1);
-    if (state.inDeg.get(d) === 0) {
-      const dm = state.byName.get(d);
-      if (dm && !state.placed.has(d)) queue.push(dm);
-    }
+    const current = state.inDeg.get(d) ?? 0;
+    state.inDeg.set(d, current - 1);
+    if (current - 1 === 0) enqueueByName(d, queue, state);
   }
 }
+function decrementEager(item, queue, state) {
+  if (!item.name) return;
+  for (const consumerName of state.eagerDependents.get(item.name) ?? []) {
+    if (state.placed.has(consumerName) || !state.inDeg.has(consumerName)) continue;
+    const current = state.inDeg.get(consumerName) ?? 0;
+    state.inDeg.set(consumerName, current - 1);
+    if (current - 1 === 0) enqueueByName(consumerName, queue, state);
+  }
+}
+function enqueueByName(name, queue, state) {
+  const entry = state.byName.get(name);
+  if (entry && !state.placed.has(name)) queue.push(entry);
+}
 function appendRemaining(items, result, placed) {
   for (const item of items) {
     if (item.name && !placed.has(item.name)) result.push(item);
@@ -2115,7 +2210,7 @@ function isEntrypointFile(filePath, entrypoints) {
 }
 
 // src/rules/no-single-use-constants/index.ts
-var import_typescript4 = __toESM(require("typescript"), 1);
+var import_typescript5 = __toESM(require("typescript"), 1);
 var no_single_use_constants_default = {
   meta: {
     type: "suggestion",
@@ -2198,11 +2293,7 @@ function extractConstDeclarators(stmt) {
 function isExcludedInitializer(declarator) {
   const init = declarator.init;
   if (init === null || init === void 0) return true;
-  return init.type === "ObjectExpression" || init.type === "NewExpression" || init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression" || init.type === "ClassExpression" || hasExplicitTypeArguments(init);
-}
-function hasExplicitTypeArguments(node) {
-  if (node.type !== "CallExpression") return false;
-  return node.typeArguments !== void 0 || node.typeParameters !== void 0;
+  return init.type === "ObjectExpression" || init.type === "NewExpression" || init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression" || init.type === "ClassExpression" || init.type === "CallExpression";
 }
 function collectExportedNames(program, names) {
   for (const stmt of program.body) {
@@ -2242,65 +2333,124 @@ function countExportedUses(name, filename, tsContext) {
   if (targetSymbol === void 0) return void 0;
   return countProjectWideUses(targetSymbol, tsContext.checker, tsContext.program);
 }
-function findTsSourceFile(program, filename) {
-  const normalized = normalizeResolvedPath2(filename);
-  return program.getSourceFiles().find((sf) => normalizeResolvedPath2(sf.fileName) === normalized);
-}
 function findDeclarationSymbol(sourceFile, name, checker) {
   for (const stmt of sourceFile.statements) {
-    if (!import_typescript4.default.isVariableStatement(stmt)) continue;
-    if ((stmt.declarationList.flags & import_typescript4.default.NodeFlags.Const) === 0) continue;
+    if (!import_typescript5.default.isVariableStatement(stmt)) continue;
+    if ((stmt.declarationList.flags & import_typescript5.default.NodeFlags.Const) === 0) continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!import_typescript4.default.isIdentifier(decl.name) || decl.name.text !== name) continue;
+      if (!import_typescript5.default.isIdentifier(decl.name) || decl.name.text !== name) continue;
       return checker.getSymbolAtLocation(decl.name);
     }
   }
   return void 0;
 }
-function countProjectWideUses(targetSymbol, checker, program) {
-  let total = 0;
-  for (const sf of program.getSourceFiles()) {
-    if (sf.isDeclarationFile) continue;
-    total += countUsesInFile(sf, targetSymbol, checker);
-  }
-  return total;
-}
-function countUsesInFile(sourceFile, targetSymbol, checker) {
-  let count = 0;
-  function walk(node) {
-    if (import_typescript4.default.isIdentifier(node) && isCountableUse(node, targetSymbol, checker)) {
-      count++;
+
+// src/rules/no-unused-types/index.ts
+var import_typescript6 = __toESM(require("typescript"), 1);
+var no_unused_types_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow exported type aliases and interfaces with zero project-wide uses",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      configurationError: "Configuration error: {{details}}",
+      zeroUses: 'type "{{name}}" has no real uses across the project; remove it'
     }
-    import_typescript4.default.forEachChild(node, walk);
+  },
+  create(context) {
+    const filename = context.filename;
+    return {
+      "Program:exit"(node) {
+        const exportedTypeNames = collectExportedTypeNames(node);
+        if (filename.length === 0 || exportedTypeNames.size === 0) return;
+        const projectContext = getRequiredTypeScriptProjectContext(filename);
+        if (projectContext.kind === "context-error") {
+          context.report({
+            node,
+            messageId: "configurationError",
+            data: {
+              details: formatProjectContextError(projectContext.error)
+            }
+          });
+          return;
+        }
+        const tsContext = projectContext.projectContext;
+        for (const name of exportedTypeNames) {
+          checkType(name, filename, tsContext, context);
+        }
+      }
+    };
   }
-  walk(sourceFile);
-  return count;
+};
+function collectExportedTypeNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const stmt of program.body) {
+    const name = getExportedTypeName(stmt);
+    if (name !== void 0) names.add(name);
+  }
+  return names;
 }
-function isCountableUse(node, targetSymbol, checker) {
-  if (!isRealUsagePosition(node)) return false;
-  const sym = checker.getSymbolAtLocation(node);
-  if (sym === void 0) return false;
-  return resolveCanonicalSymbol(sym, checker) === targetSymbol;
+function getExportedTypeName(stmt) {
+  if (stmt.type !== "ExportNamedDeclaration") return void 0;
+  const decl = stmt.declaration;
+  if (decl === null || decl === void 0) return void 0;
+  const declType = strProp2(decl, "type");
+  if (declType !== "TSTypeAliasDeclaration" && declType !== "TSInterfaceDeclaration")
+    return void 0;
+  const idNode = prop2(decl, "id");
+  return strProp2(idNode, "name");
 }
-function isRealUsagePosition(node) {
-  const parent = node.parent;
-  if (isDeclarationBinding(parent, node)) return false;
-  if (isImportPosition(parent, node)) return false;
-  if (import_typescript4.default.isExportSpecifier(parent)) return false;
-  if (import_typescript4.default.isExportAssignment(parent)) return false;
-  return true;
+function checkType(name, filename, tsContext, context) {
+  const sourceFile = findTsSourceFile(tsContext.program, filename);
+  if (sourceFile === void 0) return;
+  const targetSymbol = findTypeDeclarationSymbol(sourceFile, name, tsContext.checker);
+  if (targetSymbol === void 0) return;
+  const count = countProjectWideUses(targetSymbol, tsContext.checker, tsContext.program);
+  if (count > 0) return;
+  const decl = targetSymbol.declarations?.[0];
+  if (decl === void 0) return;
+  context.report({
+    node: context.sourceCode.ast,
+    loc: {
+      start: {
+        line: import_typescript6.default.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1,
+        column: import_typescript6.default.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).character
+      },
+      end: {
+        line: import_typescript6.default.getLineAndCharacterOfPosition(sourceFile, decl.getEnd()).line + 1,
+        column: import_typescript6.default.getLineAndCharacterOfPosition(sourceFile, decl.getEnd()).character
+      }
+    },
+    messageId: "zeroUses",
+    data: { name }
+  });
 }
-function isDeclarationBinding(parent, node) {
-  return import_typescript4.default.isVariableDeclaration(parent) && parent.name === node;
+function findTypeDeclarationSymbol(sourceFile, name, checker) {
+  for (const stmt of sourceFile.statements) {
+    const decl = getTypedDeclaration(stmt);
+    if (decl === void 0) continue;
+    if (!import_typescript6.default.isIdentifier(decl.name) || decl.name.text !== name) continue;
+    const sym = checker.getSymbolAtLocation(decl.name);
+    if (sym !== void 0) return sym;
+  }
+  return void 0;
 }
-function isImportPosition(parent, node) {
-  if (import_typescript4.default.isImportSpecifier(parent)) return true;
-  if (import_typescript4.default.isImportClause(parent) && parent.name === node) return true;
-  return import_typescript4.default.isNamespaceImport(parent) && parent.name === node;
+function getTypedDeclaration(stmt) {
+  if (import_typescript6.default.isTypeAliasDeclaration(stmt) || import_typescript6.default.isInterfaceDeclaration(stmt)) {
+    return stmt;
+  }
+  return void 0;
 }
-function resolveCanonicalSymbol(symbol, checker) {
-  if ((symbol.flags & import_typescript4.default.SymbolFlags.Alias) === 0) return symbol;
-  return checker.getAliasedSymbol(symbol);
+function strProp2(obj, key) {
+  const v = prop2(obj, key);
+  return typeof v === "string" ? v : void 0;
+}
+function prop2(obj, key) {
+  if (typeof obj !== "object" || obj === null) return void 0;
+  return Reflect.get(obj, key);
 }
 
 // src/rules/index.ts
@@ -2312,7 +2462,8 @@ var rules_default = {
   "import-control": import_control_default,
   "no-whitebox-testing": no_whitebox_testing_default,
   "export-control": export_control_default,
-  "no-single-use-constants": no_single_use_constants_default
+  "no-single-use-constants": no_single_use_constants_default,
+  "no-unused-types": no_unused_types_default
 };
 
 // src/index.ts
@@ -2343,6 +2494,7 @@ var full = {
     "unslop/export-control": "error",
     "unslop/no-false-sharing": "error",
     "unslop/no-single-use-constants": "error",
+    "unslop/no-unused-types": "error",
     "unslop/read-friendly-order": "error"
   }
 };