Method getSuggestions

packages/expr/src/autocomplete.ts:47–107

* Generates autocomplete suggestions based on the input expression and cursor offset position.

(
        expr: string,
        cursorOffset: number,
        context: SymbolsTable
    )

     * Generates autocomplete suggestions based on the input expression and cursor offset position.
     */
    public getSuggestions(
        expr: string,
        cursorOffset: number,
        context: SymbolsTable
    ): AutocompleteSuggestions {
        if (!expr.length) {
            return [];
        }

        try {
            const { result, invalidNodes } = this.#parser.parse(expr, { loose: true });

            // Locate the node at the cursor position.
            const nodeAtCursorFound = walk.findNodeAround(result, cursorOffset, (_type, node) =>
                isNodeAtCursor(node, cursorOffset)
            );

            if (!nodeAtCursorFound) {
                // When we can't find one we might be in the boundary of the program/expression.
                // We could possibly be in a whitespace at the end of the expression or in a situation where the parsed
                // tree may contain 2 top level ExpressionStatement (second one returned as invalid node by the parser).
                //
                // In this case we want to provide operators as suggestions and refine the search of the "cursor" node to either:
                //   - using the end position of the whole expression AST (e.g white space at the very end of the expression string)
                //   - or using the second top level ExpressionStatement node found by the parser as the cursor is at the end of that node.
                if (cursorOffset > result.end) {
                    const ast = invalidNodes.length > 0 ? invalidNodes[0]?.expression : result;

                    if (!ast) {
                        return [];
                    }

                    const lastNodeFound = walk.findNodeAround(ast, ast.end, (_type, node) =>
                        isNodeAtCursor(node, ast.end)
                    );
                    if (!lastNodeFound) {
                        return [];
                    }
                    const { node } = lastNodeFound;

                    if (!isAnyNode(node)) {
                        throw Error(`Unexpected node type ${node.type}`);
                    }

                    return this.getOperatorSuggestionsForNode(ast, node, result.end, context);
                }
                return [];
            }

            const { node } = nodeAtCursorFound;

            if (!isAnyNode(node)) {
                throw Error(`Unexpected node type ${node.type}`);
            }

            return this.getSuggestionsForNode(result, node, expr, cursorOffset, context);
        } catch (error) {
            this.#logger.error('Error while computing autocomplete suggestions', error);