prefer-type-alias.ts

import * as util from '../util';
import { RuleFix } from 'ts-eslint';

export default util.createRule({
  name: 'prefer-type-alias',
  meta: {
    type: 'suggestion',
    docs: {
      description: 'Prefer a type alias over an interface declaration.',
      category: 'Stylistic Issues',
      recommended: false,
      tslintName: 'prefer-type-alias',
    },
    messages: {
      preferTypeAlias: 'Expected a `type` instead of an `interface`',
    },
    schema: [],
    fixable: 'code',
  },
  defaultOptions: [],
  create(context) {
    const sourceCode = context.getSourceCode();

    return {
      TSInterfaceDeclaration: node => {
        context.report({
          node: node.id,
          messageId: 'preferTypeAlias',
          fix(fixer) {
            const typeNode = node.typeParameters || node.id;
            const fixes: RuleFix[] = [];

            const interfaceKeyword = sourceCode.getFirstToken(node);
            const extendsKeyword = sourceCode.getTokenAfter(interfaceKeyword!, {
              filter: token =>
                token.type === 'Keyword' && token.value === 'extends',
            });
            const headBracket = sourceCode.getTokenAfter(interfaceKeyword!, {
              filter: token =>
                token.type === 'Punctuator' && token.value === '{',
            });

            fixes.push(fixer.replaceText(interfaceKeyword!, 'type'));
            fixes.push(
              fixer.replaceTextRange(
                [typeNode.range[1], node.body.range[0]],
                ' ',
              ),
            );
            fixes.push(fixer.insertTextBefore(headBracket!, '= '));

            if (extendsKeyword) {
              const interfaceIdentifier = sourceCode.getTokenAfter(
                extendsKeyword,
                {
                  filter: token => token.type === 'Identifier',
                },
              );

              const [tailBracket] = sourceCode.getLastTokens(node, {
                filter: token =>
                  token.type === 'Punctuator' && token.value === '}',
              });

              // NOTE: insertion `& Keyword` to tail
              fixes.push(fixer.insertTextAfter(tailBracket, ' & '));
              fixes.push(
                fixer.insertTextAfter(tailBracket, interfaceIdentifier!.value),
              );

              // NOTE: remove `extends` & interface name
              fixes.push(
                fixer.removeRange([
                  extendsKeyword.range[0],
                  extendsKeyword.range[1] + 1,
                ]),
              );
              fixes.push(
                fixer.removeRange([
                  interfaceIdentifier!.range[0],
                  interfaceIdentifier!.range[1] + 1, // include space after Identifier like `A `
                ]),
              );
            }

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