Function argumentNodeFinder

src/util/nodeFinders.ts:40–86

(...parentTypes: string[])

const toPosition = (point: Point) => new Position(point.row, point.column);

export const argumentNodeFinder = (...parentTypes: string[]): NodeFinder => {
  const left = ["(", "{", "["];
  const right = [")", "}", "]"];
  const delimiters = left.concat(right);
  const isType = (node: SyntaxNode | null, typeNames: string[]) =>
    node != null && typeNames.includes(node.type);
  const isOk = (node: SyntaxNode | null) =>
    node != null && !isType(node, delimiters);
  return (node: SyntaxNode, selection?: Selection) => {
    let resultNode: SyntaxNode | null;
    const { start, end } = selection!;
    // Is already child
    if (isType(node.parent, parentTypes)) {
      if (isType(node, left)) {
        resultNode = node.nextNamedSibling;
      } else if (isType(node, right)) {
        resultNode = node.previousNamedSibling;
      } else if (node.type === ",") {
        resultNode = end.isBeforeOrEqual(toPosition(node.startPosition))
          ? node.previousNamedSibling
          : node.nextNamedSibling;
      } else {
        resultNode = node;
      }
      return isOk(resultNode) ? resultNode : null;
      // Is parent
    } else if (isType(node, parentTypes)) {
      const children = [...node.children];
      const childRight =
        children.find(({ startPosition }) =>
          toPosition(startPosition).isAfterOrEqual(end)
        ) ?? null;
      if (isOk(childRight)) {
        return childRight;
      }
      children.reverse();
      const childLeft =
        children.find(({ endPosition }) =>
          toPosition(endPosition).isBeforeOrEqual(start)
        ) ?? null;
      if (isOk(childLeft)) {
        return childLeft;
      }
    }
    return null;
  };
};

/**
 * Creates a matcher that can match potentially wrapped nodes. For example