feat(import/extensions): allow enforcement decision overrides based on specifier

Author: Xunnamius

src/rules/extensions.js

@@ -1,5 +1,6 @@
 import path from 'path';
 
+import minimatch from 'minimatch';
 import resolve from 'eslint-module-utils/resolve';
 import { isBuiltIn, isExternalModule, isScoped } from '../core/importType';
 import moduleVisitor from 'eslint-module-utils/moduleVisitor';
@@ -16,6 +17,26 @@ const properties = {
     pattern: patternProperties,
     checkTypeImports: { type: 'boolean' },
     ignorePackages: { type: 'boolean' },
+    pathGroupOverrides: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          pattern: {
+            type: 'string',
+          },
+          patternOptions: {
+            type: 'object',
+          },
+          action: {
+            type: 'string',
+            enum: ['enforce', 'ignore'],
+          },
+        },
+        additionalProperties: false,
+        required: ['pattern', 'action'],
+      },
+    }
   },
 };
 
@@ -54,6 +75,10 @@ function buildProperties(context) {
     if (obj.checkTypeImports !== undefined) {
       result.checkTypeImports = obj.checkTypeImports;
     }
+
+    if (obj.pathGroupOverrides !== undefined) {
+      result.pathGroupOverrides = obj.pathGroupOverrides;
+    }
   });
 
   if (result.defaultConfig === 'ignorePackages') {
@@ -143,20 +168,37 @@ module.exports = {
       return false;
     }
 
+    function computeOverrideAction(pathGroupOverrides = [], path) {
+      for (let i = 0, l = pathGroupOverrides.length; i < l; i++) {
+        const { pattern, patternOptions, action } = pathGroupOverrides[i];
+        if (minimatch(path, pattern, patternOptions || { nocomment: true })) {
+          return action;
+        }
+      }
+    }
+
     function checkFileExtension(source, node) {
       // bail if the declaration doesn't have a source, e.g. "export { foo };", or if it's only partially typed like in an editor
       if (!source || !source.value) { return; }
 
       const importPathWithQueryString = source.value;
 
+      // If not undefined, the user decided if rules are enforced on this import
+      const overrideAction = computeOverrideAction(
+        props.pathGroupOverrides,
+        importPathWithQueryString
+      );
+
+      if(overrideAction === 'ignore') { return ; }
+
       // don't enforce anything on builtins
-      if (isBuiltIn(importPathWithQueryString, context.settings)) { return; }
+      if (!overrideAction && isBuiltIn(importPathWithQueryString, context.settings)) { return; }
 
       const importPath = importPathWithQueryString.replace(/\?(.*)$/, '');
 
       // don't enforce in root external packages as they may have names with `.js`.
       // Like `import Decimal from decimal.js`)
-      if (isExternalRootModule(importPath)) { return; }
+      if (!overrideAction && isExternalRootModule(importPath)) { return; }
 
       const resolvedPath = resolve(importPath, context);
 
@@ -174,7 +216,7 @@ module.exports = {
       if (!extension || !importPath.endsWith(`.${extension}`)) {
         // ignore type-only imports and exports
         if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) { return; }
-        const extensionRequired = isUseOfExtensionRequired(extension, isPackage);
+        const extensionRequired = isUseOfExtensionRequired(extension, !overrideAction && isPackage);
         const extensionForbidden = isUseOfExtensionForbidden(extension);
         if (extensionRequired && !extensionForbidden) {
           context.report({

tests/src/rules/extensions.js

@@ -736,6 +736,86 @@ describe('TypeScript', () => {
             ],
             parser,
           }),
+
+          // pathGroupOverrides: no patterns match good bespoke specifiers
+          test({
+            code: `
+              import { ErrorMessage as UpstreamErrorMessage } from '@black-flag/core/util';
+
+              import { $instances } from 'rootverse+debug:src.ts';
+              import { $exists } from 'rootverse+bfe:src/symbols.ts';
+
+              import type { Entries } from 'type-fest';
+            `,
+            parser,
+            options: [
+              'always',
+              {
+                ignorePackages: true,
+                checkTypeImports: true,
+                pathGroupOverrides: [
+                  {
+                    pattern: 'multiverse{*,*/**}',
+                    action: 'enforce'
+                  }
+                ]
+              }
+            ]
+          }),
+          // pathGroupOverrides: an enforce pattern matches good bespoke specifiers
+          test({
+            code: `
+              import { ErrorMessage as UpstreamErrorMessage } from '@black-flag/core/util';
+
+              import { $instances } from 'rootverse+debug:src.ts';
+              import { $exists } from 'rootverse+bfe:src/symbols.ts';
+
+              import type { Entries } from 'type-fest';
+            `,
+            parser,
+            options: [
+              'always',
+              {
+                ignorePackages: true,
+                checkTypeImports: true,
+                pathGroupOverrides: [
+                  {
+                    pattern: 'rootverse{*,*/**}',
+                    action: 'enforce'
+                  },
+                ]
+              }
+            ]
+          }),
+          // pathGroupOverrides: an ignore pattern matches bad bespoke specifiers
+          test({
+            code: `
+              import { ErrorMessage as UpstreamErrorMessage } from '@black-flag/core/util';
+
+              import { $instances } from 'rootverse+debug:src';
+              import { $exists } from 'rootverse+bfe:src/symbols';
+
+              import type { Entries } from 'type-fest';
+            `,
+            parser,
+            options: [
+              'always',
+              {
+                ignorePackages: true,
+                checkTypeImports: true,
+                pathGroupOverrides: [
+                  {
+                    pattern: 'multiverse{*,*/**}',
+                    action: 'enforce'
+                  },
+                  {
+                    pattern: 'rootverse{*,*/**}',
+                    action: 'ignore'
+                  },
+                ]
+              }
+            ]
+          }),
         ],
         invalid: [
           test({
@@ -756,6 +836,46 @@ describe('TypeScript', () => {
             ],
             parser,
           }),
+
+          // pathGroupOverrides: an enforce pattern matches bad bespoke specifiers
+          test({
+            code: `
+              import { ErrorMessage as UpstreamErrorMessage } from '@black-flag/core/util';
+
+              import { $instances } from 'rootverse+debug:src';
+              import { $exists } from 'rootverse+bfe:src/symbols';
+
+              import type { Entries } from 'type-fest';
+            `,
+            parser,
+            options: [
+              'always',
+              {
+                ignorePackages: true,
+                checkTypeImports: true,
+                pathGroupOverrides: [
+                  {
+                    pattern: 'rootverse{*,*/**}',
+                    action: 'enforce'
+                  },
+                  {
+                    pattern: 'universe{*,*/**}',
+                    action: 'ignore'
+                  }
+                ]
+              }
+            ],
+            errors: [
+              {
+                message: 'Missing file extension for "rootverse+debug:src"',
+                line: 4,
+              },
+              {
+                message: 'Missing file extension for "rootverse+bfe:src/symbols"',
+                line: 5,
+              }
+            ],
+          }),
         ],
       });
     });