consistent-type-specifier-style.js

import docsUrl from '../docsUrl';

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      description: 'Enforce or ban the use of inline type-only markers for named imports',
      url: docsUrl('consistent-type-specifier-style'),
    },
    fixable: 'code',
    schema: [
      {
        type: 'string',
        enum: ['prefer-inline', 'prefer-top-level'],
        default: 'prefer-inline',
      },
    ],
  },

  create(context) {
    const sourceCode = context.getSourceCode();

    if (context.options[0] === 'prefer-inline') {
      return {
        ImportDeclaration(node) {
          if (node.importKind === 'value' || node.importKind == null) {
            return;
          }

          if (
            // no specifiers (import type {} from '') have no specifiers to mark as inline
            node.specifiers.length === 0 ||
            (node.specifiers.length === 1 &&
              // default imports are both "inline" and "top-level"
              (node.specifiers[0].type === 'ImportDefaultSpecifier' ||
                // namespace imports are both "inline" and "top-level"
                node.specifiers[0].type === 'ImportNamespaceSpecifier'))
          ) {
            return;
          }

          context.report({
            node,
            message: 'Prefer using inline {{kind}} specifiers instead of a top-level {{kind}}-only import.',
            data: {
              kind: node.importKind,
            },
            fix(fixer) {
              const fixes = [];

              const kindToken = sourceCode.getFirstToken(node, { skip: 1 });
              if (kindToken) {
                fixes.push(fixer.remove(kindToken));
              }

              for (const specifier of node.specifiers) {
                fixes.push(fixer.insertTextBefore(specifier, `${node.importKind} `));
              }

              return fixes;
            },
          });
        },
      };
    }

    // prefer-top-level
    return {
      ImportDeclaration(node) {
        if (
          // already top-level is valid
          node.importKind === 'type' ||
          node.importKind === 'typeof' ||
          // no specifiers (import {} from '') cannot have inline - so is valid
          node.specifiers.length === 0 ||
          (node.specifiers.length === 1 &&
            // default imports are both "inline" and "top-level"
            (node.specifiers[0].type === 'ImportDefaultSpecifier' ||
              // namespace imports are both "inline" and "top-level"
              node.specifiers[0].type === 'ImportNamespaceSpecifier'))
        ) {
          return;
        }

        const typeSpecifiers = [];
        const typeofSpecifiers = [];
        const valueSpecifiers = [];
        let defaultSpecifier = null;
        for (const specifier of node.specifiers) {
          if (specifier.type === 'ImportDefaultSpecifier') {
            defaultSpecifier = specifier;
            continue;
          } else if (specifier.type !== 'ImportSpecifier') {
            continue;
          }

          if (specifier.importKind === 'type') {
            typeSpecifiers.push(specifier);
          } else if (specifier.importKind === 'typeof') {
            typeofSpecifiers.push(specifier);
          } else if (specifier.importKind === 'value' || specifier.importKind == null) {
            valueSpecifiers.push(specifier);
          }
        }

        const typeImport = getImportText(typeSpecifiers, 'type');
        const typeofImport = getImportText(typeofSpecifiers, 'typeof');
        const newImports = `${typeImport}\n${typeofImport}`.trim();

        if (
          typeSpecifiers.length + typeofSpecifiers.length ===
          node.specifiers.length
        ) {
          // all specifiers have inline specifiers - so we replace the entire import
          const kind = [];
          if (typeSpecifiers.length > 0) {
            kind.push('type');
          }
          if (typeofSpecifiers.length > 0) {
            kind.push('typeof');
          }
          context.report({
            node,
            message: 'Prefer using a top-level {{kind}}-only import instead of inline {{kind}} specifiers.',
            data: {
              kind: kind.join('/'),
            },
            fix(fixer) {
              return fixer.replaceText(node, newImports);
            },
          });
        } else {
          // remove specific specifiers and insert new imports for them
          for (const specifier of typeSpecifiers.concat(typeofSpecifiers)) {
            context.report({
              node: specifier,
              message: 'Prefer using a top-level {{kind}}-only import instead of inline {{kind}} specifiers.',
              data: {
                kind: specifier.importKind,
              },
              fix(fixer) {
                const fixes = [];

                // if there are no value specifiers, then the other report fixer will be called, not this one

                if (valueSpecifiers.length > 0) {
                  // import { Value, type Type } from 'mod';

                  // we can just remove the type specifiers
                  removeSpecifiers(typeSpecifiers);
                  removeSpecifiers(typeofSpecifiers);

                  // make the import nicely formatted by also removing the trailing comma after the last value import
                  // eg
                  // import { Value, type Type } from 'mod';
                  // to
                  // import { Value  } from 'mod';
                  // not
                  // import { Value,  } from 'mod';
                  const maybeComma = sourceCode.getTokenAfter(valueSpecifiers[valueSpecifiers.length - 1]);
                  if (isComma(maybeComma)) {
                    fixes.push(fixer.remove(maybeComma));
                  }
                } else if (defaultSpecifier) {
                  // import Default, { type Type } from 'mod';

                  // remove the entire curly block so we don't leave an empty one behind
                  // NOTE - the default specifier *must* be the first specifier always!
                  //        so a comma exists that we also have to clean up or else it's bad syntax
                  const comma = sourceCode.getTokenAfter(defaultSpecifier, isComma);
                  const closingBrace = sourceCode.getTokenAfter(
                    node.specifiers[node.specifiers.length - 1],
                    token => token.type === 'Punctuator' && token.value === '}',
                  );
                  fixes.push(fixer.removeRange([
                    comma.range[0],
                    closingBrace.range[1],
                  ]));
                }

                // insert the new imports after the old declaration
                fixes.push(fixer.insertTextAfter(node, `\n${newImports}`));

                return fixes;

                function removeSpecifiers(specifiers) {
                  for (const specifier of specifiers) {
                    // remove the trailing comma
                    const comma = sourceCode.getTokenAfter(specifier, isComma);
                    if (comma) {
                      fixes.push(fixer.remove(comma));
                    }
                    fixes.push(fixer.remove(specifier));
                  }
                }
              },
            });
          }
        }

        function getImportText(
          specifiers,
          kind,
        ) {
          const sourceString = sourceCode.getText(node.source);
          if (specifiers.length === 0) {
            return '';
          }

          const names = specifiers.map(s => {
            if (s.imported.name === s.local.name) {
              return s.imported.name;
            }
            return `${s.imported.name} as ${s.local.name}`;
          });
          // insert a fresh top-level import
          return `import ${kind} {${names.join(', ')}} from ${sourceString};`;
        }
      },
    };
  },
};

function isComma(token) {
  return token.type === 'Punctuator' && token.value === ',';
}