extensions.js

import path from 'path'

import resolve from 'eslint-module-utils/resolve'
import { isBuiltIn, isExternalModule, isScoped, isScopedModule } from '../core/importType'
import docsUrl from '../docsUrl'

const enumValues = { enum: [ 'always', 'ignorePackages', 'never' ] }
const patternProperties = {
  type: 'object',
  patternProperties: { '.*': enumValues },
}
const properties = {
  type: 'object',
  properties: {
    'pattern': patternProperties,
    'ignorePackages': { type: 'boolean' },
  },
}

function buildProperties(context) {

    const result = {
      defaultConfig: 'never',
      pattern: {},
      ignorePackages: false,
    }

    context.options.forEach(obj => {

      // If this is a string, set defaultConfig to its value
      if (typeof obj === 'string') {
        result.defaultConfig = obj
        return
      }

      // If this is not the new structure, transfer all props to result.pattern
      if (obj.pattern === undefined && obj.ignorePackages === undefined) {
        Object.assign(result.pattern, obj)
        return
      }

      // If pattern is provided, transfer all props
      if (obj.pattern !== undefined) {
        Object.assign(result.pattern, obj.pattern)
      }

      // If ignorePackages is provided, transfer it to result
      if (obj.ignorePackages !== undefined) {
        result.ignorePackages = obj.ignorePackages
      }
    })

    if (result.defaultConfig === 'ignorePackages') {
      result.defaultConfig = 'always'
      result.ignorePackages = true
    }

    return result
}

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      url: docsUrl('extensions'),
    },

    schema: {
      anyOf: [
        {
          type: 'array',
          items: [enumValues],
          additionalItems: false,
        },
        {
          type: 'array',
          items: [
            enumValues,
            properties,
          ],
          additionalItems: false,
        },
        {
          type: 'array',
          items: [properties],
          additionalItems: false,
        },
        {
          type: 'array',
          items: [patternProperties],
          additionalItems: false,
        },
        {
          type: 'array',
          items: [
            enumValues,
            patternProperties,
          ],
          additionalItems: false,
        },
      ],
    },
  },

  create: function (context) {

    const props = buildProperties(context)

    function getModifier(extension) {
      return props.pattern[extension] || props.defaultConfig
    }

    function isUseOfExtensionRequired(extension, isPackage) {
      return getModifier(extension) === 'always' && (!props.ignorePackages || !isPackage)
    }

    function isUseOfExtensionForbidden(extension) {
      return getModifier(extension) === 'never'
    }

    function isResolvableWithoutExtension(file) {
      const extension = path.extname(file)
      const fileWithoutExtension = file.slice(0, -extension.length)
      const resolvedFileWithoutExtension = resolve(fileWithoutExtension, context)

      return resolvedFileWithoutExtension === resolve(file, context)
    }

    function isExternalRootModule(file) {
      const slashCount = file.split('/').length - 1

      if (isScopedModule(file) && slashCount <= 1) return true
      if (isExternalModule(file, context, resolve(file, context)) && !slashCount) return true
      return false
    }

    function checkFileExtension(node) {
      const { source } = node

      // bail if the declaration doesn't have a source, e.g. "export { foo };"
      if (!source) return

      const importPathWithQueryString = source.value

      // don't enforce anything on builtins
      if (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

      const resolvedPath = resolve(importPath, context)

      // get extension from resolved path, if possible.
      // for unresolved, use source value.
      const extension = path.extname(resolvedPath || importPath).substring(1)

      // determine if this is a module
      const isPackage = isExternalModule(importPath, context.settings)
        || isScoped(importPath)

      if (!extension || !importPath.endsWith(`.${extension}`)) {
        const extensionRequired = isUseOfExtensionRequired(extension, isPackage)
        const extensionForbidden = isUseOfExtensionForbidden(extension)
        if (extensionRequired && !extensionForbidden) {
          context.report({
            node: source,
            message:
              `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPathWithQueryString}"`,
          })
        }
      } else if (extension) {
        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {
          context.report({
            node: source,
            message: `Unexpected use of file extension "${extension}" for "${importPathWithQueryString}"`,
          })
        }
      }
    }

    return {
      ImportDeclaration: checkFileExtension,
      ExportNamedDeclaration: checkFileExtension,
    }
  },
}