Skip to content

⬅️ Back to Table of Contents

📄 method-signature-style.ts

📊 Analysis Summary

Metric Count
🔧 Functions 37
📦 Imports 8
📊 Variables & Constants 4
📑 Type Aliases 2

📚 Table of Contents

🛠️ File Location:

📂 packages/eslint-plugin/src/rules/method-signature-style.ts

📦 Imports

Name Source
TSESTree @typescript-eslint/utils
AST_NODE_TYPES @typescript-eslint/utils
createRule ../util
isClosingParenToken ../util
isCommaToken ../util
isOpeningParenToken ../util
isSemicolonToken ../util
nullThrows ../util

Variables & Constants

Name Type Kind Value Exported
params string let/var '()' ✗
parent any const methodNode.parent ✗
members any const `parent.type === AST_NODE_TYPES.TSInterfaceBody
? parent.body
: parent.members` ✗
typeNode any const propertyNode.typeAnnotation?.typeAnnotation ✗

Functions

getMethodKey(node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature): string

Code 
function getMethodKey(
      node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature,
    ): string {
      let key = context.sourceCode.getText(node.key);
      if (node.computed) {
        key = `[${key}]`;
      }
      if (node.optional) {
        key = `${key}?`;
      }
      if (node.readonly) {
        key = `readonly ${key}`;
      }
      return key;
    }
  • Parameters:
  • node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature
  • Return Type: string
  • Calls:
  • context.sourceCode.getText

getMethodParams(node: TSESTree.TSFunctionType | TSESTree.TSMethodSignature): string

Code 
function getMethodParams(
      node: TSESTree.TSFunctionType | TSESTree.TSMethodSignature,
    ): string {
      let params = '()';
      if (node.params.length > 0) {
        const openingParen = nullThrows(
          context.sourceCode.getTokenBefore(
            node.params[0],
            isOpeningParenToken,
          ),
          'Missing opening paren before first parameter',
        );
        const closingParen = nullThrows(
          context.sourceCode.getTokenAfter(
            node.params[node.params.length - 1],
            isClosingParenToken,
          ),
          'Missing closing paren after last parameter',
        );

        params = context.sourceCode.text.substring(
          openingParen.range[0],
          closingParen.range[1],
        );
      }
      if (node.typeParameters != null) {
        const typeParams = context.sourceCode.getText(node.typeParameters);
        params = `${typeParams}${params}`;
      }
      return params;
    }
  • Parameters:
  • node: TSESTree.TSFunctionType | TSESTree.TSMethodSignature
  • Return Type: string
  • Calls:
  • nullThrows (from ../util)
  • context.sourceCode.getTokenBefore
  • context.sourceCode.getTokenAfter
  • context.sourceCode.text.substring
  • context.sourceCode.getText

getMethodReturnType(node: TSESTree.TSFunctionType | TSESTree.TSMethodSignature): string

Code 
function getMethodReturnType(
      node: TSESTree.TSFunctionType | TSESTree.TSMethodSignature,
    ): string {
      return node.returnType == null
        ? // if the method has no return type, it implicitly has an `any` return type
          // we just make it explicit here so we can do the fix
          'any'
        : context.sourceCode.getText(node.returnType.typeAnnotation);
    }
  • Parameters:
  • node: TSESTree.TSFunctionType | TSESTree.TSMethodSignature
  • Return Type: string
  • Calls:
  • context.sourceCode.getText
  • Internal Comments: 
    // we just make it explicit here so we can do the fix

getDelimiter(node: TSESTree.Node): string

Code 
function getDelimiter(node: TSESTree.Node): string {
      const lastToken = context.sourceCode.getLastToken(node);
      if (
        lastToken &&
        (isSemicolonToken(lastToken) || isCommaToken(lastToken))
      ) {
        return lastToken.value;
      }

      return '';
    }
  • Parameters:
  • node: TSESTree.Node
  • Return Type: string
  • Calls:
  • context.sourceCode.getLastToken
  • isSemicolonToken (from ../util)
  • isCommaToken (from ../util)

isNodeParentModuleDeclaration(node: TSESTree.Node): boolean

Code 
function isNodeParentModuleDeclaration(node: TSESTree.Node): boolean {
      if (!node.parent) {
        return false;
      }

      if (node.parent.type === AST_NODE_TYPES.TSModuleDeclaration) {
        return true;
      }

      if (node.parent.type === AST_NODE_TYPES.Program) {
        return false;
      }
      return isNodeParentModuleDeclaration(node.parent);
    }
  • Parameters:
  • node: TSESTree.Node
  • Return Type: boolean
  • Calls:
  • isNodeParentModuleDeclaration

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
                const key = getMethodKey(methodNode);
                const params = getMethodParams(methodNode);
                const returnType = getMethodReturnType(methodNode);
                const delimiter = getDelimiter(methodNode);
                return fixer.replaceText(
                  methodNode,
                  `${key}: ${params} => ${returnType}${delimiter}`,
                );
              }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

fix(fixer: any): any

Code 
fixer => {
              const key = getMethodKey(propertyNode);
              const params = getMethodParams(typeNode);
              const returnType = getMethodReturnType(typeNode);
              const delimiter = getDelimiter(propertyNode);
              return fixer.replaceText(
                propertyNode,
                `${key}${params}: ${returnType}${delimiter}`,
              );
            }
  • Parameters:
  • fixer: any
  • Return Type: any
  • Calls:
  • getMethodKey
  • getMethodParams
  • getMethodReturnType
  • getDelimiter
  • fixer.replaceText

Type Aliases

Options

type Options = [('method' | 'property')?];

MessageIds

type MessageIds = 'errorMethod' | 'errorProperty';