How to use

sortedIndexBy

function

in

LoDashStatic

AssignmentExpression(node) {
        const operator = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
        const nodeTokens = getTokensAndComments(node);
        const tokensFromOperator = nodeTokens.slice(lodash.sortedIndexBy(nodeTokens, operator, token => token.range[0]));

        offsets.setDesiredOffsets(tokensFromOperator, sourceCode.getLastToken(node.left), 1);
        offsets.ignoreToken(tokensFromOperator[0]);
        offsets.ignoreToken(tokensFromOperator[1]);
      }

ExportNamedDeclaration(node) {
        if (node.declaration === null) {
          const tokensInNode = getTokensAndComments(node);
          const closingCurly = sourceCode.getLastToken(node, astUtils.isClosingBraceToken);
          const closingCurlyIndex = lodash.sortedIndexBy(tokensInNode, closingCurly, token => token.range[0]);

          // Indent the specifiers in `export {foo, bar, baz}`
          addElementListIndent(node.specifiers, sourceCode.getFirstToken(node, { skip: 1 }), closingCurly, 1);

          if (node.source) {

            // Indent everything after and including the `from` token in `export {foo, bar, baz} from 'qux'`
            offsets.setDesiredOffsets(tokensInNode.slice(closingCurlyIndex + 1), sourceCode.getFirstToken(node), 1);
          }
        }
      }

/**
    * Adds indentation for the right-hand side of binary/logical expressions.
    * @param {ASTNode} node A BinaryExpression or LogicalExpression node
    * @returns {void}
    */
    function addBinaryOrLogicalExpressionIndent(node) {
      const tokens = getTokensAndComments(node);
      const operator = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
      const firstTokenAfterOperator = sourceCode.getTokenAfter(operator);
      const tokensAfterOperator = tokens.slice(lodash.sortedIndexBy(tokens, firstTokenAfterOperator, token => token.range[0]));

      /*
       * For backwards compatibility, don't check BinaryExpression indents, e.g.
       * var foo = bar &&
       *                   baz;
       */

      offsets.ignoreToken(operator);
      offsets.ignoreToken(tokensAfterOperator[0]);
      offsets.setDesiredOffsets(tokensAfterOperator, tokensAfterOperator[0], 1);
    }

/**
    * Checks the indentation of a function's parameters
    * @param {ASTNode} node The node
    * @param {number} paramsIndent The indentation level option for the parameters
    * @returns {void}
    */
    function addFunctionParamsIndent(node, paramsIndent) {
      const openingParen = node.params.length ? sourceCode.getTokenBefore(node.params[0]) : sourceCode.getTokenBefore(node.body, 1);

      if (!openingParen) {

        // If there is no opening paren (e.g. for an arrow function with a single parameter), don't indent anything.
        return;
      }

      const closingParen = sourceCode.getTokenBefore(node.body);
      const nodeTokens = getTokensAndComments(node);
      const openingParenIndex = lodash.sortedIndexBy(nodeTokens, openingParen, token => token.range[0]);
      const closingParenIndex = lodash.sortedIndexBy(nodeTokens, closingParen, token => token.range[0]);

      parameterParens.add(nodeTokens[openingParenIndex]);
      parameterParens.add(nodeTokens[closingParenIndex]);

      addElementListIndent(node.params, nodeTokens[openingParenIndex], nodeTokens[closingParenIndex], paramsIndent);
    }