[New]: add rule default-import-match-filename

README.md

@@ -94,6 +94,7 @@ This plugin intends to support linting of ES2015+ (ES6+) import/export syntax, a
 * Forbid anonymous values as default exports ([`no-anonymous-default-export`])
 * Prefer named exports to be grouped together in a single export declaration ([`group-exports`])
 * Enforce a leading comment with the webpackChunkName for dynamic imports ([`dynamic-import-chunkname`])
+* Enforce default import name to match filename ([`default-import-match-filename`])
 
 [`first`]: ./docs/rules/first.md
 [`exports-last`]: ./docs/rules/exports-last.md
@@ -111,6 +112,7 @@ This plugin intends to support linting of ES2015+ (ES6+) import/export syntax, a
 [`no-default-export`]: ./docs/rules/no-default-export.md
 [`no-named-export`]: ./docs/rules/no-named-export.md
 [`dynamic-import-chunkname`]: ./docs/rules/dynamic-import-chunkname.md
+[`default-import-match-filename`]: ./docs/rules/default-import-match-filename.md
 
 ## `eslint-plugin-import` for enterprise
 

docs/rules/default-import-match-filename.md

@@ -0,0 +1,44 @@
+# import/default-import-match-filename
+
+Enforces default import name to match filename. Name matching is case-insensitive, and characters `._-` are stripped.
+
+## Rule Details
+
+### Options
+
+#### `ignorePaths`
+
+Set this option to `['some-dir/', 'bb']` to ignore import statements whose path contains either `some-dir/` or `bb` as a substring.
+
+### Fail
+
+```js
+import notFoo from './foo';
+import utilsFoo from '../utils/foo';
+import notFoo from '../foo/index.js';
+import notMerge from 'lodash/merge';
+import notPackageName from '..'; // When "../package.json" has name "package-name"
+import notDirectoryName from '..'; // When ".." is a directory named "directory-name"
+const bar = require('./foo');
+const bar = require('../foo');
+```
+
+### Pass
+
+```js
+import foo from './foo';
+import foo from '../foo/index.js';
+import merge from 'lodash/merge';
+import packageName from '..'; // When "../package.json" has name "package-name"
+import directoryName from '..'; // When ".." is a directory named "directory-name"
+import anything from 'foo';
+import foo_ from './foo';
+import foo from './foo.js';
+import fooBar from './foo-bar';
+import FoObAr from './foo-bar';
+import catModel from './cat.model.js';
+const foo = require('./foo');
+
+// Option `{ ignorePaths: ['format/'] }`
+import QWERTY from '../format/date';
+```

src/index.js

@@ -38,6 +38,7 @@ export const rules = {
   'unambiguous': require('./rules/unambiguous'),
   'no-unassigned-import': require('./rules/no-unassigned-import'),
   'no-useless-path-segments': require('./rules/no-useless-path-segments'),
+  'default-import-match-filename': require('./rules/default-import-match-filename'),
   'dynamic-import-chunkname': require('./rules/dynamic-import-chunkname'),
 
   // export

src/rules/default-import-match-filename.js

@@ -0,0 +1,199 @@
+import docsUrl from '../docsUrl'
+import isStaticRequire from '../core/staticRequire'
+import Path from 'path'
+
+/**
+ * @param {string} filename
+ * @returns {string}
+ */
+function removeExtension(filename) {
+  return Path.basename(filename, Path.extname(filename))
+}
+
+/**
+ * @param {string} filename
+ * @returns {string}
+ */
+function normalizeFilename(filename) {
+  return filename.replace(/[-_.]/g, '').toLowerCase()
+}
+
+/**
+ * Test if local name matches filename.
+ * @param {string} localName
+ * @param {string} filename
+ * @returns {boolean}
+ */
+function isCompatible(localName, filename) {
+  const normalizedLocalName = localName.replace(/_/g, '').toLowerCase()
+
+  return (
+    normalizedLocalName === normalizeFilename(filename) ||
+    normalizedLocalName === normalizeFilename(removeExtension(filename))
+  )
+}
+
+/**
+ * Match 'foo' but not 'foo/bar.js' and './foo'
+ * @param {string} path
+ * @returns {boolean}
+ */
+function isBarePackageImport(path) {
+  return path !== '.' && path !== '..' && !path.includes('/')
+}
+
+/**
+ * Match paths consisting of only '.' and '..', like '.', './', '..', '../..'.
+ * @param {string} path
+ * @returns {boolean}
+ */
+function isAncestorRelativePath(path) {
+  return (
+    path.length > 0 &&
+    !path.startsWith('/') &&
+    path
+      .split(/[/\\]/)
+      .every(segment => segment === '..' || segment === '.' || segment === '')
+  )
+}
+
+/**
+ * @param {string} packageJsonPath
+ * @returns {string | undefined}
+ */
+function getPackageJsonName(packageJsonPath) {
+  try {
+    return require(packageJsonPath).name || undefined
+  } catch (_) {
+    return undefined
+  }
+}
+
+function getNameFromPackageJsonOrDirname(path, context) {
+  const directoryName = Path.join(context.getFilename(), path, '..')
+  const packageJsonPath = Path.join(directoryName, 'package.json')
+  const packageJsonName = getPackageJsonName(packageJsonPath)
+  return packageJsonName || Path.basename(directoryName)
+}
+
+/**
+ * Get filename from a path.
+ * @param {string} path
+ * @param {object} context
+ * @returns {string | undefined}
+ */
+function getFilename(path, context) {
+  // like require('lodash')
+  if (isBarePackageImport(path)) {
+    return undefined
+  }
+
+  const basename = Path.basename(path)
+
+  const isDir = /^index$|^index\./.test(basename)
+  const processedPath = isDir ? Path.dirname(path) : path
+
+  // like require('.'), require('..'), require('../..')
+  if (isAncestorRelativePath(processedPath)) {
+    return getNameFromPackageJsonOrDirname(processedPath, context)
+  }
+
+  return Path.basename(processedPath) + (isDir ? '/' : '')
+}
+
+/**
+ * @param {string[]} ignorePaths
+ * @param {string} path
+ * @returns {boolean}
+ */
+function isIgnored(ignorePaths, path) {
+  return ignorePaths.some(pattern => path.includes(pattern))
+}
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      url: docsUrl('default-import-match-filename'),
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ignorePaths: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+        },
+      },
+    ],
+  },
+
+  create(context) {
+    const ignorePaths = context.options[0]
+      ? context.options[0].ignorePaths || []
+      : []
+
+    return {
+      ImportDeclaration(node) {
+        const defaultImportSpecifier = node.specifiers.find(
+          ({type}) => type === 'ImportDefaultSpecifier'
+        )
+
+        const defaultImportName =
+          defaultImportSpecifier && defaultImportSpecifier.local.name
+
+        if (!defaultImportName) {
+          return
+        }
+
+        const filename = getFilename(node.source.value, context)
+
+        if (!filename) {
+          return
+        }
+
+        if (
+          !isCompatible(defaultImportName, filename) &&
+          !isIgnored(ignorePaths, node.source.value)
+        ) {
+          context.report({
+            node: defaultImportSpecifier,
+            message: `Default import name does not match filename "${filename}".`,
+          })
+        }
+      },
+
+      CallExpression(node) {
+        if (
+          !isStaticRequire(node) ||
+          node.parent.type !== 'VariableDeclarator' ||
+          node.parent.id.type !== 'Identifier'
+        ) {
+          return
+        }
+
+        const localName = node.parent.id.name
+
+        const filename = getFilename(node.arguments[0].value, context)
+
+        if (!filename) {
+          return
+        }
+
+        if (
+          !isCompatible(localName, filename) &&
+          !isIgnored(ignorePaths, node.arguments[0].value)
+        ) {
+          context.report({
+            node: node.parent.id,
+            message: `Default import name does not match filename "${filename}".`,
+          })
+        }
+      },
+    }
+  },
+}

tests/files/default-import-match-filename/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "package-name"
+}