eslint-plugin-unslop 0.6.0 → 0.7.0

package/README.md

@@ -85,13 +85,16 @@ Each value is a policy object:
 
 ```ts
 {
-  imports?: string[]  // exact module, direct child via /*, self-or-child via /+, or '*' for all
-  exports?: string[]  // regex patterns symbols exported from entrypoints must match
-  entrypoints?: string[] // public files allowed for external and test imports
-  shared?: boolean    // marks module as shared; enables no-false-sharing
+  imports?: string[]      // exact module, direct child via /*, self-or-child via /+, or '*' for all
+  typeImports?: string[]  // same patterns as imports, but only for type-only imports
+  exports?: string[]      // regex patterns symbols exported from entrypoints must match
+  entrypoints?: string[]  // public files allowed for external and test imports
+  shared?: boolean        // marks module as shared; enables no-false-sharing
 }
 ```
 
+`typeImports` defaults to `[]` when omitted. Type-only imports are also allowed when the target matches `imports`, so `typeImports` is only needed for modules you want to allow type access to without allowing value imports.
+
 Architecture keys and import allowlists use different matching rules:
 
 - keys assign ownership to subtrees
@@ -99,7 +102,7 @@ Architecture keys and import allowlists use different matching rules:
 - `imports: ['models/*']` allows only direct children like `models/user`
 - `imports: ['models/+']` allows `models` and direct children like `models/user`
 
-When multiple keys cover the same canonical module path, the winner is chosen by nearest owner first, then exact named path over wildcard path at the same depth, then longer selector path, then declaration order. Unmatched canonical module paths become anonymous modules with empty `imports`, empty `exports`, `shared: false`, and default `entrypoints: ['index.ts']`.
+When multiple keys cover the same canonical module path, the winner is chosen by nearest owner first, then exact named path over wildcard path at the same depth, then longer selector path, then declaration order. Unmatched canonical module paths become anonymous modules with empty `imports`, empty `typeImports`, empty `exports`, `shared: false`, and default `entrypoints: ['index.ts']`.
 
 All architecture rules take no options. Policy comes entirely from this shared settings block.
 
@@ -112,6 +115,7 @@ Customs control for your modules: you declare which modules are allowed to impor
 Deny-by-default for cross-module imports, so forgetting to declare a dependency is a loud error rather than a silent free-for-all. It also enforces:
 
 - cross-module imports must arrive through the public gate (configured entrypoints)
+- type-only imports can be separately allowed via `typeImports` (value imports from those modules remain forbidden)
 - local cross-module namespace imports are forbidden (`import * as X from '<local-module>'`)
 - same-module relative imports can only go one level deeper - no tunnelling into internals
 - files that don't match any declared module become anonymous modules and are denied by default

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.0",
+  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);
@@ -632,11 +632,13 @@ function getUnsupportedArchitectureKeyDetails(matcher) {
 function parseModulePolicy(rawPolicy) {
   if (!isRecord(rawPolicy)) return void 0;
   const imports = readStringList(rawPolicy.imports);
+  const typeImports = readStringList(rawPolicy.typeImports);
   const exports2 = readStringList(rawPolicy.exports);
   const entrypoints = readStringList(rawPolicy.entrypoints);
   const shared = rawPolicy.shared === true;
   return {
     imports,
+    typeImports,
     exports: exports2,
     entrypoints: entrypoints.length > 0 ? entrypoints : ["index.ts"],
     shared
@@ -704,7 +706,13 @@ function makeAnonymousModule(canonicalPath) {
     canonicalPath,
     ownerKey: canonicalPath,
     ownerPath: canonicalPath,
-    policy: { imports: [], exports: [], entrypoints: ["index.ts"], shared: false },
+    policy: {
+      imports: [],
+      typeImports: [],
+      exports: [],
+      entrypoints: ["index.ts"],
+      shared: false
+    },
     order: 0,
     anonymous: true,
     ownerDepth: depth,
@@ -756,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: {
@@ -946,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);
     }
   }
@@ -964,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);
   }
@@ -972,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) {
@@ -992,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) {
@@ -1277,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())) {
@@ -1298,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);
@@ -1802,7 +1905,7 @@ function checkModuleEdge(options) {
     return;
   }
   if (isShallowRelativeEntrypoint(specifier, targetFile, importee.policy)) return;
-  if (!allowsImport(importer.policy, importee.canonicalPath)) {
+  if (!allowsCrossModuleDeclaration(importer.policy, importee.canonicalPath, node)) {
     context.report({
       node,
       messageId: "notAllowed",
@@ -1849,9 +1952,48 @@ function isRelativeDepthTooDeep(specifier) {
   const parts = specifier.slice(2).split("/").filter(Boolean);
   return parts.length > 2;
 }
-function allowsImport(policy, targetMatcher) {
-  if (policy.imports.includes("*")) return true;
-  return policy.imports.some((pattern) => importPatternMatches(pattern, targetMatcher));
+function allowsCrossModuleDeclaration(policy, targetMatcher, node) {
+  if (allowsImportPattern(policy.imports, targetMatcher)) return true;
+  return isTypeOnlyDeclaration(node) && allowsImportPattern(policy.typeImports, targetMatcher);
+}
+function isTypeOnlyDeclaration(node) {
+  if (node.type === "ImportDeclaration") return isTypeOnlyImportDeclaration(node);
+  if (node.type === "ExportAllDeclaration") return getExportKind(node) === "type";
+  return isTypeOnlyExportNamedDeclaration(node);
+}
+function isTypeOnlyImportDeclaration(node) {
+  if (getImportKind(node) === "type") return true;
+  if (node.specifiers.length === 0) return false;
+  return node.specifiers.every(isTypeOnlyImportSpecifier);
+}
+function isTypeOnlyImportSpecifier(specifier) {
+  return specifier.type === "ImportSpecifier" && getImportKind(specifier) === "type";
+}
+function isTypeOnlyExportNamedDeclaration(node) {
+  if (getExportKind(node) === "type") return true;
+  if (node.specifiers.length === 0) return false;
+  return node.specifiers.every(isTypeOnlyExportSpecifier);
+}
+function isTypeOnlyExportSpecifier(specifier) {
+  return getExportKind(specifier) === "type";
+}
+function getImportKind(value) {
+  return getDeclarationKind(value, "importKind");
+}
+function getExportKind(value) {
+  return getDeclarationKind(value, "exportKind");
+}
+function getDeclarationKind(value, key) {
+  if (!isRecord2(value)) return void 0;
+  const kind = value[key];
+  return kind === "type" || kind === "value" ? kind : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function allowsImportPattern(patterns, targetMatcher) {
+  if (patterns.includes("*")) return true;
+  return patterns.some((pattern) => importPatternMatches(pattern, targetMatcher));
 }
 function importPatternMatches(pattern, target) {
   if (pattern === target) return true;
@@ -2068,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",
@@ -2151,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) {
@@ -2195,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
@@ -2265,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
@@ -2296,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"
   }
 };