eslint-plugin-unslop 0.6.0 → 0.6.1

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.6.1",
   description: "ESLint plugin with rules for reducing AI-generated code smells",
   repository: {
     type: "git",
@@ -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,
@@ -1802,7 +1810,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 +1857,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;