@quillsql/react 2.15.3 → 2.15.4

package/dist/esm/utils/reportBuilder.js

@@ -1,800 +0,0 @@
-import { extractColumnish, getColumnName, isBoolColumnType, isNumericColumnType, } from '../components/ReportBuilder/ast';
-import { deepCopy, isIdColumn } from '../components/ReportBuilder/util';
-import { JoinType, } from '../models/ReportBuilder';
-import { astToFilterTree, filterTreeToAst, getFieldFromExpression, } from './astFilterProcessing';
-import { isStringType } from './columnType';
-import { getDateFormatFromBucket } from './dates';
-import { getPossiblePivotFieldOptions, isValidPivot } from './pivotProcessing';
-import { DATE_FORMAT_TYPES, quillFormat } from './valueFormatter';
-const baseAstForReportBuilder = {
-    with: null,
-    type: 'select',
-    options: null,
-    distinct: {
-        type: null,
-    },
-    columns: [],
-    into: {
-        position: null,
-    },
-    from: [],
-    where: null,
-    groupby: null,
-    having: null,
-    orderby: null,
-    limit: null,
-    window: null,
-};
-// Primary conversion functions
-export const reportBuilderStateToAst = (reportBuilderState, databaseType) => {
-    const astFrom = tableToAstFrom(reportBuilderState.tables);
-    const astColumns = columnsToAstColumns(reportBuilderState.columns);
-    const filterTree = reportBuilderState.filterStack && reportBuilderState.filterStack.length > 0
-        ? filterStackToFilterTree(reportBuilderState.filterStack)
-        : null;
-    const astWhere = filterTree
-        ? filterTreeToAst(filterTree, databaseType)
-        : null;
-    const astOrderby = sortToAstOrderBy(reportBuilderState.sort);
-    const astLimit = limitToAstLimit(reportBuilderState.limit, databaseType);
-    return {
-        ...baseAstForReportBuilder,
-        from: astFrom,
-        columns: astColumns,
-        where: astWhere,
-        orderby: astOrderby,
-        limit: databaseType.toLowerCase() === 'mssql' ? null : astLimit,
-        top: databaseType.toLowerCase() === 'mssql' ? astLimit : null,
-    };
-};
-export const astToReportBuilderState = (ast, databaseType, schema) => {
-    const tables = astFromToTables(ast.from);
-    const defaultTable = tables.length === 1 ? tables[0]?.name : undefined;
-    const columns = astColumnsToColumns(ast.columns, defaultTable);
-    const relevantColumns = tables.flatMap((table) => {
-        const schemaTable = schema.find((s) => s.name === table.name);
-        return schemaTable ? schemaTable.columns : [];
-    });
-    const pivot = astGroupByToPivot(ast.groupby, relevantColumns);
-    const sort = astOrderByToSort(ast.orderby);
-    const limit = astLimitToLimit(ast.limit);
-    const filterStack = generateFilterStack(astToFilterTree(ast.where, databaseType.toLowerCase()));
-    return {
-        tables,
-        columns,
-        filterStack,
-        pivot,
-        sort,
-        limit,
-    };
-};
-// Helper conversion functions
-const astColumnsToColumns = (node, defaultTable) => {
-    // expected
-    /*
-          [
-              {
-                  "expr": {
-                      "type": "column_ref",
-                      "table": null,
-                      "column": "field"
-                  },
-                  "as": null
-              },
-          ]
-          */
-    if (!node || !node.length || node.length === 0) {
-        return [];
-    }
-    return node.map((node) => {
-        return {
-            field: getFieldFromExpression(node.expr),
-            table: node.expr.table ?? defaultTable ?? null,
-            alias: node.as ?? null,
-        };
-    });
-};
-const astGroupByToPivot = (node, columnInfo) => {
-    if (!node) {
-        return null;
-    }
-    return convertASTToPivotData(node, columnInfo);
-};
-const astFromToTables = (node) => {
-    // expected
-    /*
-          [
-              {
-                  "db": null,
-                  "table": "all_tenant_data",
-                  "as": null,
-                  "join": 'INNER JOIN',
-              }
-          ]
-          */
-    if (!node) {
-        return [];
-    }
-    return node.map((_node) => {
-        return {
-            name: _node.table,
-            alias: _node.as ?? null,
-            join: _node.join
-                ? {
-                    type: _node.join,
-                    condition: {
-                        operator: _node.on.operator,
-                        left: {
-                            field: getFieldFromExpression(_node.on.left.column.expr || _node.on.left.column),
-                            table: _node.on.left.table,
-                        },
-                        right: {
-                            field: getFieldFromExpression(_node.on.right.column.expr || _node.on.right.column),
-                            table: _node.on.right.table,
-                        },
-                    },
-                }
-                : null,
-        };
-    });
-};
-const astOrderByToSort = (node) => {
-    // expected
-    /*
-          [
-              {
-                  "expr": {
-                      "type": "column_ref",
-                      "table": null,
-                      "column": "county_id"
-                  },
-                  "type": "DESC"
-              }
-          ]
-          */
-    if (!node) {
-        return [];
-    }
-    return node
-        .map((node) => {
-        return node.expr
-            ? {
-                field: getFieldFromExpression(node.expr),
-                direction: node.type ?? 'ASC',
-            }
-            : null;
-    })
-        .filter((node) => node);
-};
-const astLimitToLimit = (node) => {
-    // expected
-    /*
-          {
-              "seperator": "",
-              "value": [
-                  {
-                      "type": "number",
-                      "value": 10
-                  }
-              ]
-          }
-          */
-    if (!node ||
-        !node.value ||
-        node.value.length === 0 ||
-        !node.value?.[0]?.value) {
-        return null;
-    }
-    return { value: node.value[0].value };
-};
-const createOperatorFromJoinCondition = (condition) => {
-    return {
-        type: 'binary_expr',
-        operator: condition.operator,
-        left: {
-            type: 'column_ref',
-            table: condition.left.table,
-            column: condition.left.field,
-        },
-        right: {
-            type: 'column_ref',
-            table: condition.right.table,
-            column: condition.right.field,
-        },
-    };
-};
-const tableToAstFrom = (tables) => {
-    return tables.map((table) => {
-        return {
-            db: null,
-            table: table.name,
-            as: table.alias ?? null,
-            join: table.join ? table.join.type : null,
-            on: table.join
-                ? createOperatorFromJoinCondition(table.join.condition)
-                : null,
-        };
-    });
-};
-const columnsToAstColumns = (columns) => {
-    if (!columns) {
-        return null;
-    }
-    return columns.map((column) => {
-        return {
-            expr: {
-                type: 'column_ref',
-                table: column.table ?? null,
-                column: column.field,
-            },
-            as: column.alias ?? null,
-        };
-    });
-};
-const sortToAstOrderBy = (sort) => {
-    if (!sort || sort.length === 0) {
-        return null;
-    }
-    return sort.map((sort) => {
-        return {
-            expr: {
-                type: 'column_ref',
-                table: null,
-                column: sort.field,
-            },
-            type: sort.direction,
-        };
-    });
-};
-const limitToAstLimit = (limit, databaseType) => {
-    if (!limit) {
-        return null;
-    }
-    if (databaseType.toLowerCase() === 'mssql') {
-        return {
-            value: limit.value,
-            percent: null,
-        };
-    }
-    return {
-        seperator: '',
-        value: [
-            {
-                type: 'number',
-                value: limit.value,
-            },
-        ],
-    };
-};
-// Validation
-export const isValidPivotForReport = (pivot, uniqueValuesByColumn, reportColumns) => {
-    if (!isValidPivot(pivot).valid) {
-        return false;
-    }
-    // check that pivot rows and columns
-    const pivotColumns = reportColumns;
-    const possibleOptions = getPossiblePivotFieldOptions(pivotColumns, uniqueValuesByColumn);
-    if (pivot.rowField &&
-        pivot.columnField &&
-        pivot.rowField === pivot.columnField) {
-        return false;
-    }
-    if (pivot.rowField && !possibleOptions.rowFields.includes(pivot.rowField)) {
-        return false;
-    }
-    if (pivot.columnField &&
-        !possibleOptions.columnFields.includes(pivot.columnField)) {
-        return false;
-    }
-    for (const agg of pivot.aggregations ?? []) {
-        if (agg.valueField &&
-            !possibleOptions.valueFields.includes(agg.valueField)) {
-            return false;
-        }
-    }
-    if (!pivot.aggregations || pivot.aggregations.length === 0) {
-        return false;
-    }
-    return true;
-};
-export const makePivotValid = (pivot, uniqueValuesForPivot, reportColumns) => {
-    if (!pivot) {
-        return { pivot: null, hint: '' };
-    }
-    // try flipping row and column field
-    let newPivot = {
-        ...pivot,
-        rowField: pivot.columnField,
-        columnField: pivot.rowField,
-    };
-    if (isValidPivotForReport(newPivot, uniqueValuesForPivot, reportColumns)) {
-        newPivot = setTypesOnPivot(newPivot, reportColumns);
-        return {
-            pivot: newPivot,
-            hint: 'Flipping pivot row and column fields to maintain validity',
-        };
-    }
-    // try removing column field
-    newPivot = {
-        ...pivot,
-        rowField: pivot.rowField,
-        columnField: undefined,
-    };
-    if (isValidPivotForReport(newPivot, uniqueValuesForPivot, reportColumns)) {
-        newPivot = setTypesOnPivot(newPivot, reportColumns);
-        return {
-            pivot: newPivot,
-            hint: 'Removing column field to maintain validity',
-        };
-    }
-    return { pivot: null, hint: '' };
-};
-export const formatRows = (rows, columns, pivot, aggregationType, dateBucket) => {
-    const copiedRows = deepCopy(rows);
-    if (pivot) {
-        const formattedRows = copiedRows.map((row) => {
-            const formattedRow = row;
-            Object.keys(row).forEach((key) => {
-                const column = columns.find((c) => c.field === key);
-                let format = 'string';
-                if (!column) {
-                    format =
-                        aggregationType === 'count' ? 'whole_number' : 'two_decimal_places';
-                }
-                else {
-                    format = DATE_FORMAT_TYPES.includes(column.format)
-                        ? dateBucket
-                            ? getDateFormatFromBucket(dateBucket)
-                            : 'MMM_yyyy'
-                        : 'string';
-                }
-                const formattedValue = quillFormat({
-                    value: row[key],
-                    format,
-                });
-                formattedRow[key] = formattedValue;
-            });
-            return formattedRow;
-        });
-        return formattedRows;
-    }
-    else {
-        const formattedRows = copiedRows.map((row) => {
-            return columns.reduce((formattedRow, column) => {
-                // Apply the format function to each field in the row
-                const formattedValue = quillFormat({
-                    value: row[column.field],
-                    format: column.format,
-                });
-                formattedRow[column.field] = formattedValue;
-                return formattedRow;
-            }, {});
-        });
-        return formattedRows;
-    }
-};
-export const setTypesOnPivot = (newPivot, searchColumns) => ({
-    ...newPivot,
-    aggregations: newPivot.aggregations?.map((agg) => ({
-        ...agg,
-        valueFieldType: searchColumns.find((c) => c.field === agg.valueField)
-            ?.jsType,
-        valueField2Type: searchColumns.find((c) => c.field === agg.valueField2)
-            ?.jsType,
-    })),
-    valueField: newPivot.aggregations?.[0]?.valueField,
-    valueField2: newPivot.aggregations?.[0]?.valueField2,
-    aggregationType: newPivot.aggregations?.[0]?.aggregationType,
-    valueFieldType: searchColumns.find((c) => c.field === newPivot.aggregations?.[0]?.valueField)?.jsType,
-    valueField2Type: searchColumns.find((c) => c.field === newPivot.aggregations?.[0]?.valueField2)?.jsType,
-});
-export const orderTablesByBestPrimaryTable = (tables, foreignKeyMap) => {
-    const getPrimaryTableMappings = (table) => {
-        const tablesMappedByPrimaryTable = [{ ...table }];
-        foreignKeyMap[table.name]?.forEach((mapping) => {
-            if (tables.some((t) => t.name === mapping.foreignTable)) {
-                tablesMappedByPrimaryTable.push({
-                    name: mapping.foreignTable,
-                    join: {
-                        type: JoinType.INNER,
-                        condition: {
-                            operator: '=',
-                            left: { field: mapping.foreignKey, table: table.name },
-                            right: {
-                                field: mapping.foreignTablePrimaryKey,
-                                table: mapping.foreignTable,
-                            },
-                        },
-                    },
-                });
-            }
-        });
-        return tablesMappedByPrimaryTable;
-    };
-    if (tables.length === 0) {
-        return [];
-    }
-    let primaryTableMappings = [];
-    tables.forEach((table) => {
-        const mappedByTable = getPrimaryTableMappings(table);
-        if (mappedByTable.length > primaryTableMappings.length) {
-            primaryTableMappings = mappedByTable;
-        }
-    });
-    return primaryTableMappings;
-};
-export const validatedReportBuilderState = (state, foreignKeyMap) => {
-    let { tables, columns, filterStack, sort } = state;
-    const { pivot, limit } = state;
-    if (columns.length === 0) {
-        return {
-            tables: [],
-            columns: [],
-            filterStack: [],
-            pivot: null,
-            sort: [],
-            limit: null,
-        };
-    }
-    const tablesReferencedInColumns = tables.filter((table) => {
-        return columns.some((col) => col.table === table.name);
-    });
-    tables = columns.some((col) => col.table === tables[0]?.name)
-        ? tablesReferencedInColumns
-        : orderTablesByBestPrimaryTable(tablesReferencedInColumns, foreignKeyMap);
-    columns = columns.filter((col) => {
-        return tables.some((table) => table.name === col.table);
-    });
-    filterStack = filterStack.filter((filter, index) => {
-        if (!filter.value) {
-            let prevFilterValid = true;
-            let nextFilterValid = true;
-            if (index === 1) {
-                const prevFilter = filterStack[0];
-                prevFilterValid =
-                    !!prevFilter.value &&
-                        columns.some((col) => col.field === prevFilter.value?.field) &&
-                        tables.some((table) => table.name === prevFilter.value?.table);
-            }
-            const nextFilter = filterStack[index + 1];
-            if (nextFilter) {
-                nextFilterValid =
-                    !!nextFilter.value &&
-                        columns.some((col) => col.field === nextFilter.value?.field) &&
-                        tables.some((table) => table.name === nextFilter.value?.table);
-            }
-            return prevFilterValid && nextFilterValid;
-        }
-        else {
-            return (columns.some((col) => col.field === filter.value?.field) &&
-                tables.some((table) => table.name === filter.value?.table));
-        }
-    });
-    sort = sort.filter((sort) => {
-        return columns.some((col) => (col.alias ?? col.field) === sort.field);
-    });
-    // If pivot is using removed columns, remove pivot
-    let removePivot = false;
-    if (pivot) {
-        const referencedColumns = [];
-        if (pivot.rowField) {
-            referencedColumns.push(pivot.rowField);
-        }
-        if (pivot.columnField) {
-            referencedColumns.push(pivot.columnField);
-        }
-        if (pivot.aggregations) {
-            pivot.aggregations.forEach((agg) => {
-                if (agg.valueField) {
-                    referencedColumns.push(agg.valueField);
-                }
-                if (agg.valueField2) {
-                    referencedColumns.push(agg.valueField2);
-                }
-            });
-        }
-        const columnMapping = referencedColumns
-            .map((col) => {
-            const column = columns.find((c) => (c.alias || c.field) === col);
-            return column;
-        })
-            .filter((c) => c !== undefined);
-        removePivot = !columnMapping.every((col) => columns.some((c) => (c.alias || c.field) === (col.alias || col.field) &&
-            c.table === col.table));
-    }
-    return {
-        tables,
-        columns,
-        filterStack,
-        pivot: removePivot ? null : pivot,
-        sort,
-        limit,
-    };
-};
-function convertGroupByToPivotData(ast, columns, aliasMap) {
-    if (!ast.groupby) {
-        return {};
-    }
-    if (!Array.isArray(ast.groupby)) {
-        // @ts-ignore
-        ast.groupby = ast.groupby.columns; // change as of node-sql-parser v5.3.4
-        if (!ast.groupby) {
-            return {};
-        }
-    }
-    const pivot = {};
-    const isDateTrunc = (item) => ['function', 'date_trunc'].includes(item.type);
-    const isExtract = (item) => 'extract' === item.type;
-    const isCol = (x) => ['double_quote_string', 'column_ref'].includes(x.type);
-    const dateTruncGroup = ast.groupby.find(isDateTrunc);
-    const extractGroup = ast.groupby.find(isExtract);
-    if (dateTruncGroup) {
-        const column = dateTruncGroup.args?.value.find(isCol);
-        const columnName = extractColumnish(column);
-        pivot.rowField = columnName;
-        pivot.rowFieldType = columns.find((c) => c.field === columnName)?.fieldType;
-    }
-    else if (extractGroup) {
-        const column = extractGroup.args?.source;
-        const columnName = extractColumnish(column);
-        pivot.rowField = columnName;
-        pivot.rowFieldType = columns.find((c) => c.field === columnName)?.fieldType;
-    }
-    // Otherwise, set the first groupby to rowField then set
-    // next field to columnField (if there is one)
-    for (let j = 0; j < ast.groupby.length; j++) {
-        const group = ast.groupby[j];
-        let groupValue;
-        if (group?.type === 'number') {
-            const index = typeof group.value === 'number' ? group.value : 1;
-            const equivalentColumn = ast.columns[index - 1];
-            groupValue = extractColumnish(equivalentColumn.expr);
-        }
-        else {
-            groupValue = extractColumnish(group);
-        }
-        if (!groupValue || isIdColumn(groupValue)) {
-            continue;
-        }
-        // check if this value is an alias, if so use concrete value
-        if (groupValue && aliasMap[groupValue]) {
-            groupValue = aliasMap[groupValue];
-        }
-        // Try to set the rowField and columnField.
-        const column = columns.find((c) => c.field === groupValue);
-        if (!column ||
-            isNumericColumnType(column.fieldType) ||
-            isIdColumn(column.field)) {
-            continue;
-        }
-        if (!pivot.rowField) {
-            pivot.rowField = groupValue;
-            pivot.rowFieldType = columns.find((c) => c.field === groupValue)?.fieldType;
-        }
-        else if (!pivot.columnField && groupValue !== pivot.rowField) {
-            const columnFieldType = columns.find((c) => c.field === groupValue)?.fieldType;
-            if (!isStringType(columnFieldType || '')) {
-                // try swapping row and column
-                if (isStringType(pivot.rowFieldType || '')) {
-                    pivot.columnField = pivot.rowField;
-                    pivot.columnFieldType = pivot.rowFieldType;
-                    pivot.rowField = groupValue;
-                    pivot.rowFieldType = columnFieldType;
-                    break;
-                }
-                else {
-                    continue;
-                }
-            }
-            pivot.columnField = groupValue;
-            pivot.columnFieldType = columnFieldType;
-        }
-    }
-    return pivot;
-}
-function convertCaseWhenToPivotData(column) {
-    const pivot = {};
-    const columnNode = column.expr?.args?.expr?.args[0]?.result;
-    const columnName = columnNode?.value ?? columnNode?.column?.expr?.value ?? columnNode?.column;
-    if (columnName && typeof columnName === 'string') {
-        if (!isIdColumn(columnName)) {
-            pivot.valueField = columnName;
-            pivot.aggregationType = column?.expr?.name?.toLowerCase();
-            if (pivot.aggregationType === 'avg') {
-                pivot.aggregationType = 'average';
-            }
-            pivot.aggregations = [
-                {
-                    valueField: pivot.valueField,
-                    aggregationType: pivot.aggregationType,
-                },
-            ];
-        }
-    }
-    // We need to extract a column name from the condition expression of
-    // the CASE and we'll use that as the columnField in our pivot.
-    const condNode = column.expr?.args?.expr?.args[0]?.cond;
-    const condColumnName = condNode.left?.column?.expr?.value ??
-        condNode.left?.column ??
-        condNode.left?.value;
-    if (!isIdColumn(condColumnName)) {
-        pivot.columnField = condColumnName;
-    }
-    return pivot;
-}
-export function convertASTToPivotData(ast, columnInfo) {
-    const newPivot = {};
-    const aliasMap = {};
-    if (ast.columns === '*') {
-        return null;
-    }
-    ast.columns.forEach((column) => {
-        const columnName = getColumnName(column);
-        if (!columnName) {
-            return;
-        }
-        const alias = column.as || columnName;
-        aliasMap[alias] = columnName;
-        if (column.expr?.args?.expr?.type.toLowerCase() === 'case' &&
-            ['double_quote_string', 'column_ref'].includes(column.expr?.args?.expr?.args[0]?.result?.type)) {
-            const caseWhenPivot = convertCaseWhenToPivotData(column);
-            if (caseWhenPivot.aggregations) {
-                caseWhenPivot.aggregations.forEach((agg) => {
-                    if (!newPivot.aggregations?.find((a) => a.valueField === agg.valueField)) {
-                        newPivot.aggregations = newPivot.aggregations ?? [];
-                        newPivot.aggregations.push(agg);
-                    }
-                });
-            }
-            else {
-                if (!newPivot.aggregations?.find((a) => a.valueField === caseWhenPivot.valueField)) {
-                    newPivot.aggregations = newPivot.aggregations ?? [];
-                    newPivot.aggregations.push({
-                        valueField: caseWhenPivot.valueField,
-                        aggregationType: caseWhenPivot.aggregationType,
-                    });
-                }
-            }
-            newPivot.columnField = caseWhenPivot.columnField;
-        }
-        else if (column.expr.type === 'aggr_func' && !isIdColumn(columnName)) {
-            const aggObj = column.expr;
-            let aggregationType = aggObj.name.toLowerCase();
-            if (aggregationType === 'avg') {
-                aggregationType = 'average';
-            }
-            newPivot.aggregations = newPivot.aggregations ?? [];
-            newPivot.aggregations.push({
-                valueField: columnName,
-                aggregationType,
-            });
-        }
-        else if (column.expr.type === 'function') {
-            const functionInfo = column.expr.name;
-            if (Array.isArray(functionInfo.name) &&
-                functionInfo.name[0].value &&
-                ['timestamp_trunc', 'date_trunc', 'date_part'].includes(functionInfo.name[0].value.toLowerCase())) {
-                newPivot.rowField = columnName;
-            }
-        }
-    });
-    const pivotData = convertGroupByToPivotData(ast, columnInfo, aliasMap);
-    const finalPivot = { ...pivotData, ...newPivot };
-    const isColumnDate = columnInfo.find((column) => column.field === finalPivot?.columnField)
-        ?.fieldType === 'date';
-    if (finalPivot) {
-        // Make sure date fields are set to the rowField
-        const isPivot1D = finalPivot.rowField && !finalPivot.columnField;
-        if (finalPivot.columnField && isColumnDate) {
-            [finalPivot.rowField, finalPivot.columnField] = [
-                finalPivot.columnField,
-                finalPivot.rowField,
-            ];
-            finalPivot.rowFieldType = 'date';
-        }
-        // Make sure pivot value field is of numeric type
-        // MAke sure each value field is of numeric type
-        if (finalPivot.aggregations) {
-            finalPivot.aggregations = finalPivot.aggregations.filter((agg) => {
-                const column = columnInfo.find((c) => c.field === agg.valueField);
-                return (column &&
-                    (isNumericColumnType(column.fieldType) ||
-                        isBoolColumnType(column.fieldType)));
-            });
-        }
-        else if (finalPivot.valueField) {
-            const column = columnInfo.find((c) => c.field === finalPivot.valueField);
-            if (!column ||
-                !(isNumericColumnType(column.fieldType) ||
-                    isBoolColumnType(column.fieldType))) {
-                finalPivot.valueField = '';
-                finalPivot.aggregationType = 'count';
-            }
-        }
-        if (finalPivot.rowFieldType === 'date') {
-            finalPivot.sort = true;
-            finalPivot.sortDirection = 'ASC';
-            finalPivot.sortField = finalPivot.rowField;
-            finalPivot.sortFieldType = finalPivot.rowFieldType;
-        }
-        else if (isPivot1D) {
-            finalPivot.sort = true;
-            finalPivot.sortDirection = 'ASC';
-            finalPivot.sortField = finalPivot.rowField;
-            finalPivot.sortFieldType = finalPivot.rowFieldType;
-        }
-    }
-    return finalPivot;
-}
-/**
- * Function that flattens a tree of filters into an array
- */
-export function generateFilterStack(filterTree) {
-    if (!filterTree) {
-        return [];
-    }
-    const tree = filterTree;
-    let filterStack = [];
-    /**
-     * Function that takes in a FilterTree and flattens it into an array using in order traversal
-     */
-    function traverseTree(node) {
-        if (!node) {
-            return;
-        }
-        if (node.leaf) {
-            filterStack.push(node);
-        }
-        else {
-            traverseTree(node.leftNode);
-            filterStack.push(node);
-            traverseTree(node.rightNode);
-        }
-    }
-    traverseTree(tree);
-    // Remove null (invalid) filters from filter stack
-    filterStack = filterStack.filter((filter) => {
-        return ((!filter.leaf &&
-            filter.rightNode &&
-            (!filter.rightNode.leaf || filter.rightNode.value)) ||
-            (filter.leaf && filter.value));
-    });
-    return filterStack;
-}
-/**
- * Given an array of Filters (presumed to be in in-order state), generate
- * the corresponding Filter tree. Essentially the reverse of what traverseTree does
- */
-export function filterStackToFilterTree(stack) {
-    function buildTree(i) {
-        const newNode = {
-            leaf: false,
-            operator: null,
-            leftNode: null,
-            rightNode: null,
-        };
-        if (i >= stack.length) {
-            return null;
-        }
-        else if (stack[i].leaf) {
-            if (i < stack.length - 1) {
-                // more nodes later
-                newNode.operator = stack[i + 1].operator;
-                newNode.leftNode = {
-                    leaf: true,
-                    leftNode: null,
-                    rightNode: null,
-                    operator: null,
-                    value: stack[i].value,
-                };
-                newNode.rightNode = buildTree(i + 2);
-            }
-            else {
-                newNode.leaf = true;
-                newNode.value = stack[i].value;
-            }
-        }
-        return newNode;
-    }
-    return buildTree(0);
-}