typescript - Existe alguma regra como "explicit-function-return-type" sem exigir o tipo void?

Existe alguma regra do ESLint que faça a mesma coisa que [explicit-function-return-type] mas sem exigir o tipo void nas funções?

Se não houver, como devo fazer esta regra personalizada?

Resposta #1

Para aqueles que querem a regra, consegui fazer esta regra personalizada, mas atualmente ela funciona apenas para métodos dentro de uma classe. Estou usando para aplicações Angular, então funciona muito bem.

const expUtil = require("@typescript-eslint/experimental-utils");

module.exports = (context) => {
  /**
   * Checks if a node is a constructor.
   * @param node The node to check
   */
  function isConstructor(node) {
    return (!!node &&
      node.type === expUtil.AST_NODE_TYPES.MethodDefinition &&
      node.kind === 'constructor');
  }
  /**
   * Checks if a node is a setter.
   */
  function isSetter(node) {
    return (!!node &&
      (node.type === expUtil.AST_NODE_TYPES.MethodDefinition ||
        node.type === expUtil.AST_NODE_TYPES.Property) &&
      node.kind === 'set');
  }

  /**
   * Checks if a node is returning some value
   */
  function isReturningValue(node) {
    const content = node.value.body;
    const returnVal = content.body.find(n => 
      n.type === expUtil.AST_NODE_TYPES.ReturnStatement
    );

    return (returnVal && !!returnVal.argument);
  }

  /**
   * Checks if a function declaration/expression has a return type.
   */
  function checkFunctionReturnType(node) {
    if (node.returnType ||
      node.value.returnType ||
      isConstructor(node.parent) ||
      isSetter(node.parent)) {
      return;
    }

    if (!isReturningValue(node)) {
      return;
    }

    context.report(
      node, 'Functions of type void should not return any value'
    );
  }

  return {
    MethodDefinition: checkFunctionReturnType
  };
};