Function getSingleColumnMap

components/dash-table/src/dash-table/syntax-tree/index.ts:25–96

(
    ast: MultiColumnsSyntaxTree,
    columns: IColumn[]
)

    ).join(` ${operator === FilterLogicalOperator.And ? '&&' : '||'} `);

export const getSingleColumnMap = (
    ast: MultiColumnsSyntaxTree,
    columns: IColumn[]
) => {
    if (!ast.isValid) {
        return;
    }

    const map = new Map<string, SingleColumnSyntaxTree>();

    const statements = ast.statements;
    if (!statements) {
        return map;
    }

    statements.forEach(s => {
        if (s.lexeme.type === LexemeType.UnaryOperator && s.left) {
            const sanitizedColumnId = s.left.lexeme.present
                ? s.left.lexeme.present(s.left)
                : s.left.value;

            const column = R.find(
                c => c.id.toString() === sanitizedColumnId,
                columns
            );
            if (!column) {
                throw new Error(`column ${sanitizedColumnId} not found`);
            }

            map.set(
                sanitizedColumnId,
                new SingleColumnSyntaxTree(s.value, column)
            );
        } else if (
            s.lexeme.type === LexemeType.RelationalOperator &&
            s.left &&
            s.right
        ) {
            const sanitizedColumnId = s.left.lexeme.present
                ? s.left.lexeme.present(s.left)
                : s.left.value;

            const column = R.find(
                c => c.id.toString() === sanitizedColumnId,
                columns
            );
            if (!column) {
                throw new Error(`column ${sanitizedColumnId} not found`);
            }

            if (
                s.lexeme.present &&
                s.lexeme.present(s) === RelationalOperator.Equal
            ) {
                map.set(
                    sanitizedColumnId,
                    new SingleColumnSyntaxTree(`${s.right.value}`, column)
                );