feat: add forSubpaths and forSiblings options

Author: chapa

src/rules/prefer-alias.js

@@ -6,6 +6,10 @@ import P from 'path'
 
 const isParentImport = path => /^(\.\/)?\.\.\//.test(path)
 
+const isSiblingImport = path => /^\.\/[^/]+$/.test(path)
+
+const isSubpathImport = path => /^\.\/.+\//.test(path)
+
 const findMatchingAlias = (sourcePath, currentFile, options) => {
   const resolvePath = options.resolvePath || defaultResolvePath
 
@@ -61,8 +65,22 @@ export default {
           options.alias
           |> keys
           |> some(alias => sourcePath |> startsWith(`${alias}/`))
-        // relative parent
-        if (sourcePath |> isParentImport) {
+
+        const importWithoutAlias = resolvePath(sourcePath, currentFile, options)
+
+        const [shouldAlias, shouldUnalias] = [
+          !hasAlias &&
+            ((importWithoutAlias |> isParentImport) ||
+              ((importWithoutAlias |> isSiblingImport) &&
+                options.forSiblings) ||
+              ((importWithoutAlias |> isSubpathImport) && options.forSubpaths)),
+          hasAlias &&
+            (((importWithoutAlias |> isSiblingImport) &&
+              !options.forSiblings) ||
+              ((importWithoutAlias |> isSubpathImport) &&
+                !options.forSubpaths)),
+        ]
+        if (shouldAlias) {
           const matchingAlias = findMatchingAlias(
             sourcePath,
             currentFile,
@@ -78,20 +96,26 @@ export default {
             P.relative(matchingAlias.path, absoluteImportPath)
             |> replace(/\\/g, '/')
           }`
+          let importType
+          if (importWithoutAlias |> isSiblingImport) {
+            importType = 'sibling'
+          } else if (importWithoutAlias |> isSubpathImport) {
+            importType = 'subpath'
+          } else {
+            importType = 'parent'
+          }
 
           return context.report({
             fix: fixer =>
               fixer.replaceTextRange(
                 [node.source.range[0] + 1, node.source.range[1] - 1],
                 rewrittenImport,
               ),
-            message: `Unexpected parent import '${sourcePath}'. Use '${rewrittenImport}' instead`,
+            message: `Unexpected ${importType} import '${sourcePath}'. Use '${rewrittenImport}' instead`,
             node,
           })
         }
-
-        const importWithoutAlias = resolvePath(sourcePath, currentFile, options)
-        if (!(importWithoutAlias |> isParentImport) && hasAlias) {
+        if (shouldUnalias) {
           return context.report({
             fix: fixer =>
               fixer.replaceTextRange(
@@ -116,6 +140,14 @@ export default {
           alias: {
             type: 'object',
           },
+          forSiblings: {
+            default: false,
+            type: 'boolean',
+          },
+          forSubpaths: {
+            default: false,
+            type: 'boolean',
+          },
         },
         type: 'object',
       },

src/rules/prefer-alias.spec.js

@@ -43,6 +43,68 @@ const lint = (code, options = {}) => {
 
 export default tester(
   {
+    'alias for siblings': async () => {
+      await outputFiles({
+        '.babelrc.json': JSON.stringify({
+          plugins: [
+            [
+              packageName`babel-plugin-module-resolver`,
+              { alias: { '@': '.' } },
+            ],
+          ],
+        }),
+        'foo.js': '',
+      })
+      expect(
+        lint("import foo from './foo'", {
+          eslintConfig: {
+            rules: {
+              'self/self': [
+                'error',
+                {
+                  forSiblings: true,
+                },
+              ],
+            },
+          },
+        }),
+      ).toEqual({
+        messages: ["Unexpected sibling import './foo'. Use '@/foo' instead"],
+        output: "import foo from '@/foo'",
+      })
+    },
+    'alias for subpaths': async () => {
+      await outputFiles({
+        '.babelrc.json': JSON.stringify({
+          plugins: [
+            [
+              packageName`babel-plugin-module-resolver`,
+              { alias: { '@': '.' } },
+            ],
+          ],
+        }),
+        'sub/foo.js': '',
+      })
+      expect(
+        lint("import foo from './sub/foo'", {
+          eslintConfig: {
+            rules: {
+              'self/self': [
+                'error',
+                {
+                  forSubpaths: true,
+                },
+              ],
+            },
+          },
+        }),
+      ).toEqual({
+        messages: [
+          "Unexpected subpath import './sub/foo'. Use '@/sub/foo' instead",
+        ],
+        output: "import foo from '@/sub/foo'",
+      })
+    },
     'alias parent': async () => {
       await outputFiles({
         '.babelrc.json': JSON.stringify({