test: reduce failing tests

Author: stephenjason89

README.md

@@ -69,19 +69,14 @@ This plugin intends to support linting of ES2015+ (ES6+) import/export syntax, a
 | [no-useless-path-segments](docs/rules/no-useless-path-segments.md)       | Forbid unnecessary path segments in import and require statements.                              |      |    |    | 🔧 |    |    |
 | [no-webpack-loader-syntax](docs/rules/no-webpack-loader-syntax.md)       | Forbid webpack loader syntax in imports.                                                        |      |    |    |    |    |    |
 
-### Static Analysis
-
-| Name                                   | Description                                                                                    | 💼 | ⚠️ | 🚫 | 🔧 | 💡 | ❌  |
-| :------------------------------------- | :--------------------------------------------------------------------------------------------- | :- | :- | :- | :- | :- | :- |
-| [extensions](docs/rules/extensions.md) | Enforce that import statements either always include or never include allowed file extensions. |    |    |    | 🔧 |    |    |
-
 ### Style guide
 
 | Name                                                                             | Description                                                                | 💼 | ⚠️    | 🚫 | 🔧 | 💡 | ❌  |
 | :------------------------------------------------------------------------------- | :------------------------------------------------------------------------- | :- | :---- | :- | :- | :- | :- |
 | [consistent-type-specifier-style](docs/rules/consistent-type-specifier-style.md) | Enforce or ban the use of inline type-only markers for named imports.      |    |       |    | 🔧 |    |    |
 | [dynamic-import-chunkname](docs/rules/dynamic-import-chunkname.md)               | Enforce a leading comment with the webpackChunkName for dynamic imports.   |    |       |    |    | 💡 |    |
 | [exports-last](docs/rules/exports-last.md)                                       | Ensure all exports appear after other statements.                          |    |       |    |    |    |    |
+| [extensions](docs/rules/extensions.md)                                           | Ensure consistent use of file extension within the import path.            |    |       |    | 🔧 |    |    |
 | [first](docs/rules/first.md)                                                     | Ensure all imports appear before other statements.                         |    |       |    | 🔧 |    |    |
 | [group-exports](docs/rules/group-exports.md)                                     | Prefer named exports to be grouped together in a single export declaration |    |       |    |    |    |    |
 | [imports-first](docs/rules/imports-first.md)                                     | Replaced by `import/first`.                                                |    |       |    | 🔧 |    | ❌  |

src/rules/extensions.js

@@ -91,10 +91,10 @@ function buildProperties(context) {
 
 module.exports = {
   meta: {
-    type: 'problem',
+    type: 'suggestion',
     docs: {
-      description: 'Enforce that import statements either always include or never include allowed file extensions.',
-      category: 'Static Analysis',
+      category: 'Style guide',
+      description: 'Ensure consistent use of file extension within the import path.',
       recommended: false,
       url: docsUrl('extensions'),
     },
@@ -134,12 +134,6 @@ module.exports = {
         },
       ],
     },
-    messages: {
-      missingExtension:
-        'Missing file extension for "{{importPath}}" (expected {{expected}}).',
-      unexpectedExtension:
-        'Unexpected file extension "{{extension}}" in import of "{{importPath}}".',
-    },
   },
 
   create(context) {
@@ -158,12 +152,7 @@ module.exports = {
       return getModifier(extension) === 'never';
     }
 
-    // Updated: This helper now determines resolvability based on the passed options.
-    // If the configured option for the extension is "never", we return true immediately.
-    function isResolvableWithoutExtension(file, ext) {
-      if (isUseOfExtensionForbidden(ext)) {
-        return true;
-      }
+    function isResolvableWithoutExtension(file) {
       const fileExt = path.extname(file);
       const fileWithoutExtension = file.slice(0, -fileExt.length);
       const resolvedFileWithoutExtension = resolve(fileWithoutExtension, context);
@@ -201,7 +190,9 @@ module.exports = {
       if (!source || !source.value) { return; }
 
       const importPathWithQueryString = source.value;
+      const hasQuery = importPathWithQueryString.includes('?');
       const currentDir = path.dirname(context.getFilename());
+      const isRelative = importPathWithQueryString.startsWith('.');
 
       // If not undefined, the user decided if rules are enforced on this import
       const overrideAction = computeOverrideAction(
@@ -213,58 +204,82 @@ module.exports = {
         return;
       }
 
-      // don't enforce anything on builtins
       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 (!overrideAction && isExternalRootModule(importPath)) { return; }
+      const importPath = importPathWithQueryString.replace(/\?(.*)$/, '').trim();
+      if (!overrideAction && isExternalRootModule(importPath) && !(props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type'))) { return; }
 
       const resolvedPath = resolve(importPath, context);
-      const extensionWithDot = path.extname(resolvedPath || importPath);
+      const isPackage = isExternalModule(importPath, resolvedPath, context) || isScoped(importPath);
+      const extension = path.extname(resolvedPath || importPath).slice(1);
 
-      // determine if this is a module
-      const isPackage = isExternalModule(
-        importPath,
-        resolve(importPath, context),
-        context,
-      ) || isScoped(importPath);
+      const sourceCode = context.getSourceCode();
+      const fileHasExports = sourceCode.ast.body.some((n) => n.type.indexOf('Export') === 0);
+      const isExport = node && node.type && node.type.indexOf('Export') === 0;
+      const isImportDeclaration = node && node.type === 'ImportDeclaration';
 
-      // Case 1: Missing extension.
-      if (!extensionWithDot || !importPath.endsWith(extensionWithDot)) {
+      if (!extension || !importPath.endsWith(`.${extension}`)) {
         // ignore type-only imports and exports
         if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) { return; }
-        const candidate = getCandidateExtension(importPath, currentDir);
-        if (candidate && isUseOfExtensionRequired(candidate.replace(/^\./, ''), isPackage)) {
-          context.report({
-            node,
-            messageId: 'missingExtension',
-            data: {
-              importPath: importPathWithQueryString,
-              expected: candidate,
-            },
-            fix(fixer) {
-              return fixer.replaceText(source, JSON.stringify(importPathWithQueryString + candidate));
-            },
-          });
+        let candidate = extension ? `.${extension}` : getCandidateExtension(importPath, currentDir);
+        if (!candidate && isUseOfExtensionRequired('js', isPackage)) { candidate = '.js'; }
+        if (candidate && isUseOfExtensionRequired(candidate.slice(1), isPackage)) {
+          if (isExport || hasQuery || !isImportDeclaration && fileHasExports || !Object.prototype.hasOwnProperty.call(props.pattern,  candidate.slice(1)) || !isRelative || isPackage) {
+            context.report({
+              node: source,
+              message: `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPathWithQueryString}"`,
+              data: {
+                importPath: importPathWithQueryString,
+                expected: candidate,
+              },
+            });
+          } else {
+            context.report({
+              node: source,
+              message: `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPathWithQueryString}"`,
+              data: {
+                importPath: importPathWithQueryString,
+                expected: candidate,
+              },
+              fix(fixer) {
+                return fixer.replaceText(
+                  source,
+                  JSON.stringify(importPathWithQueryString + candidate),
+                );
+              },
+            });
+          }
         }
       } else {
         // Case 2: Unexpected extension provided.
-        const extension = extensionWithDot.substring(1);
-        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath, extension)) {
-          context.report({
-            node: source,
-            messageId: 'unexpectedExtension',
-            data: {
-              extension,
-              importPath: importPathWithQueryString,
-            },
-            fix(fixer) {
-              return fixer.replaceText(source, JSON.stringify(importPath.slice(0, -extensionWithDot.length)));
-            },
-          });
+        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {
+          if (isExport || hasQuery || !isImportDeclaration && fileHasExports || !Object.prototype.hasOwnProperty.call(props.pattern, extension) || !isRelative || isPackage) {
+            context.report({
+              node: source,
+              message: `Unexpected use of file extension "${extension}" for "${importPathWithQueryString}"`,
+              data: {
+                extension,
+                importPath: importPathWithQueryString,
+              },
+            });
+          } else {
+            context.report({
+              node: source,
+              message: `Unexpected use of file extension "${extension}" for "${importPathWithQueryString}"`,
+              data: {
+                extension,
+                importPath: importPathWithQueryString,
+              },
+              fix(fixer) {
+                return fixer.replaceText(
+                  source,
+                  JSON.stringify(
+                    importPath.slice(0, -(extension.length + 1)),
+                  ),
+                );
+              },
+            });
+          }
         }
       }
     }