@lightdash/common 0.1369.1 → 0.1369.2

package/dist/index.d.ts

@@ -49,6 +49,7 @@ export * from './compiler/exploreCompiler';
 export * from './compiler/filtersCompiler';
 export * from './compiler/translator';
 export * from './dbt/validation';
+export * from './pivotTable/pivotQueryResults';
 export { default as lightdashDbtYamlSchema } from './schemas/json/lightdash-dbt-2.0.json';
 export * from './templating/template';
 export * from './types/analytics';

package/dist/index.js

@@ -19,6 +19,7 @@ tslib_1.__exportStar(require("./compiler/exploreCompiler"), exports);
 tslib_1.__exportStar(require("./compiler/filtersCompiler"), exports);
 tslib_1.__exportStar(require("./compiler/translator"), exports);
 tslib_1.__exportStar(require("./dbt/validation"), exports);
+tslib_1.__exportStar(require("./pivotTable/pivotQueryResults"), exports);
 var lightdash_dbt_2_0_json_1 = require("./schemas/json/lightdash-dbt-2.0.json");
 Object.defineProperty(exports, "lightdashDbtYamlSchema", { enumerable: true, get: function () { return tslib_1.__importDefault(lightdash_dbt_2_0_json_1).default; } });
 tslib_1.__exportStar(require("./templating/template"), exports);

package/dist/pivotTable/pivotQueryResults.d.ts

@@ -0,0 +1,19 @@
+import { type ItemsMap } from '../types/field';
+import { type MetricQuery } from '../types/metricQuery';
+import { type PivotConfig, type PivotData } from '../types/pivot';
+import { type ResultRow } from '../types/results';
+type FieldFunction = (fieldId: string) => ItemsMap[string] | undefined;
+type FieldLabelFunction = (fieldId: string) => string | undefined;
+type PivotQueryResultsArgs = {
+    pivotConfig: PivotConfig;
+    metricQuery: Pick<MetricQuery, 'dimensions' | 'metrics' | 'tableCalculations' | 'additionalMetrics' | 'customDimensions'>;
+    rows: ResultRow[];
+    options: {
+        maxColumns: number;
+    };
+    getField: FieldFunction;
+    getFieldLabel: FieldLabelFunction;
+};
+export declare const pivotQueryResults: ({ pivotConfig, metricQuery, rows, options, getField, getFieldLabel, }: PivotQueryResultsArgs) => PivotData;
+export declare const pivotResultsAsCsv: (pivotConfig: PivotConfig, rows: ResultRow[], itemMap: ItemsMap, metricQuery: MetricQuery, customLabels: Record<string, string> | undefined, onlyRaw: boolean, maxColumnLimit: number) => string[][];
+export {};

package/dist/pivotTable/pivotQueryResults.js

@@ -0,0 +1,544 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pivotResultsAsCsv = exports.pivotQueryResults = void 0;
+const tslib_1 = require("tslib");
+const isNumber_1 = tslib_1.__importDefault(require("lodash/isNumber"));
+const last_1 = tslib_1.__importDefault(require("lodash/last"));
+const field_1 = require("../types/field");
+const formatting_1 = require("../utils/formatting");
+const isRecursiveRecord = (value) => typeof value === 'object' && value !== null;
+const create2DArray = (rows, columns, value = null) => Array.from({ length: rows }, () => Array.from({ length: columns }, () => value));
+const parseNumericValue = (value) => {
+    if (value === null)
+        return 0;
+    const parsedVal = Number(value.raw);
+    return Number.isNaN(parsedVal) ? 0 : parsedVal;
+};
+const setIndexByKey = (obj, keys, value) => {
+    if (keys.length === 0) {
+        return false;
+    }
+    const [key, ...rest] = keys;
+    if (rest.length === 0) {
+        if (obj[key] === undefined) {
+            // eslint-disable-next-line no-param-reassign
+            obj[key] = value;
+            return true;
+        }
+        return false;
+    }
+    if (obj[key] === undefined) {
+        // eslint-disable-next-line no-param-reassign
+        obj[key] = {};
+    }
+    const nextObject = obj[key];
+    if (!isRecursiveRecord(nextObject)) {
+        throw new Error('Cannot set key on non-object');
+    }
+    return setIndexByKey(nextObject, rest, value);
+};
+const getIndexByKey = (obj, keys) => {
+    if (keys.length === 0) {
+        throw new Error('Cannot get key from empty keys array');
+    }
+    const [key, ...rest] = keys;
+    if (rest.length === 0) {
+        const value = obj[key];
+        if (typeof value !== 'number') {
+            throw new Error('Expected a number');
+        }
+        else {
+            return value;
+        }
+    }
+    else {
+        const nextObj = obj[key];
+        if (isRecursiveRecord(nextObj)) {
+            return getIndexByKey(nextObj, rest);
+        }
+        throw new Error('Expected a RecursiveRecord object');
+    }
+};
+const getAllIndicesForFieldId = (obj, fieldId) => {
+    const entries = Object.entries(obj);
+    return entries.reduce((acc, [key, value]) => {
+        if (key === fieldId && (0, isNumber_1.default)(value)) {
+            return [...acc, value];
+        }
+        if (isRecursiveRecord(value)) {
+            return [...acc, ...getAllIndicesForFieldId(value, fieldId)];
+        }
+        return acc;
+    }, []);
+};
+const getAllIndices = (obj) => Object.values(obj).reduce((acc, value) => {
+    if ((0, isNumber_1.default)(value)) {
+        return [...acc, value];
+    }
+    return [...acc, ...getAllIndices(value)];
+}, []);
+const getAllIndicesByKey = (obj, keys) => {
+    const [key, ...rest] = keys;
+    if (rest.length === 0) {
+        const value = obj[key];
+        if ((0, isNumber_1.default)(value)) {
+            return [value];
+        }
+        return getAllIndices(value);
+    }
+    const nextObj = obj[key];
+    if (isRecursiveRecord(nextObj)) {
+        return getAllIndicesByKey(nextObj, rest);
+    }
+    throw new Error('Expected a RecursiveRecord object');
+};
+const getColSpanByKey = (currentColumnPosition, obj, keys) => {
+    const allIndices = getAllIndicesByKey(obj, keys).sort((a, b) => a - b);
+    if (allIndices.length === 0) {
+        throw new Error('Cannot get span from empty indices array');
+    }
+    const currentColumnPositionIndex = allIndices.indexOf(currentColumnPosition);
+    const previousColumnPosition = allIndices[currentColumnPositionIndex - 1];
+    if (currentColumnPositionIndex < 0) {
+        throw new Error('Cannot get span for index that does not exist in indices array');
+    }
+    const isFirstColInSpan = !(0, isNumber_1.default)(previousColumnPosition) ||
+        previousColumnPosition !== currentColumnPosition - 1;
+    if (!isFirstColInSpan) {
+        return 0;
+    }
+    return allIndices
+        .slice(currentColumnPositionIndex)
+        .reduce((acc, curr, i) => {
+        if (curr === currentColumnPosition + i) {
+            return acc + 1;
+        }
+        return acc;
+    }, 0);
+};
+const combinedRetrofit = (data, getField, getFieldLabel) => {
+    const indexValues = data.indexValues.length ? data.indexValues : [[]];
+    const baseIdInfo = (0, last_1.default)(data.headerValues);
+    const uniqueIdsForDataValueColumns = Array(data.headerValues[0].length);
+    data.headerValues.forEach((headerRow) => {
+        headerRow.forEach((headerColValue, colIndex) => {
+            uniqueIdsForDataValueColumns[colIndex] = `${(uniqueIdsForDataValueColumns[colIndex] ?? '') +
+                headerColValue.fieldId}__`;
+        });
+    });
+    const getMetricAsRowTotalValueFromAxis = (total, rowIndex) => {
+        const value = (0, last_1.default)(data.indexValues[rowIndex]);
+        if (!value || !value.fieldId)
+            throw new Error('Invalid pivot data');
+        const item = getField(value.fieldId);
+        if (!(0, field_1.isSummable)(item)) {
+            return null;
+        }
+        const formattedValue = (0, formatting_1.formatItemValue)(item, total);
+        return {
+            raw: total,
+            formatted: formattedValue,
+        };
+    };
+    const getRowTotalValueFromAxis = (field, total) => {
+        if (!field || !field.fieldId)
+            throw new Error('Invalid pivot data');
+        const item = getField(field.fieldId);
+        const formattedValue = (0, formatting_1.formatItemValue)(item, total);
+        return {
+            raw: total,
+            formatted: formattedValue,
+        };
+    };
+    let pivotColumnInfo = [];
+    const allCombinedData = indexValues.map((row, rowIndex) => {
+        const newRow = row.map((cell, colIndex) => {
+            if (cell.type === 'label') {
+                const cellValue = getFieldLabel(cell.fieldId);
+                return {
+                    ...cell,
+                    fieldId: `label-${colIndex}`,
+                    value: {
+                        raw: cellValue,
+                        formatted: cellValue,
+                    },
+                    columnType: 'label',
+                };
+            }
+            return {
+                ...cell,
+                columnType: 'indexValue',
+            };
+        });
+        const remappedDataValues = data.dataValues[rowIndex].map((dataValue, colIndex) => {
+            const baseIdInfoForCol = baseIdInfo
+                ? baseIdInfo[colIndex]
+                : undefined;
+            const baseId = baseIdInfoForCol?.fieldId;
+            const id = uniqueIdsForDataValueColumns[colIndex] + colIndex;
+            return {
+                baseId,
+                fieldId: id,
+                value: dataValue || {},
+            };
+        });
+        const remappedRowTotals = data.rowTotals?.[rowIndex]?.map((total, colIndex) => {
+            const baseId = `row-total-${colIndex}`;
+            const id = baseId;
+            const underlyingData = (0, last_1.default)(data.rowTotalFields)?.[colIndex];
+            const value = data.pivotConfig.metricsAsRows
+                ? getMetricAsRowTotalValueFromAxis(total, rowIndex)
+                : getRowTotalValueFromAxis(underlyingData, total);
+            const underlyingId = data.pivotConfig.metricsAsRows
+                ? undefined
+                : underlyingData?.fieldId;
+            return {
+                baseId,
+                fieldId: id,
+                underlyingId,
+                value,
+                columnType: 'rowTotal',
+            };
+        });
+        const entireRow = [
+            ...newRow,
+            ...remappedDataValues,
+            ...(remappedRowTotals || []),
+        ];
+        if (rowIndex === 0) {
+            pivotColumnInfo = entireRow.map((cell) => ({
+                fieldId: cell.fieldId,
+                baseId: 'baseId' in cell ? cell.baseId : undefined,
+                underlyingId: 'underlyingId' in cell ? cell.underlyingId : undefined,
+                columnType: 'columnType' in cell ? cell.columnType : undefined,
+            }));
+        }
+        const altRow = {};
+        entireRow.forEach((cell) => {
+            const val = cell.value;
+            if (val && 'formatted' in val && val.formatted !== undefined) {
+                altRow[cell.fieldId] = {
+                    value: {
+                        raw: val.raw,
+                        formatted: val.formatted,
+                    },
+                };
+            }
+        });
+        return altRow;
+    });
+    // eslint-disable-next-line no-param-reassign
+    data.retrofitData = { allCombinedData, pivotColumnInfo };
+    return data;
+};
+const pivotQueryResults = ({ pivotConfig, metricQuery, rows, options, getField, getFieldLabel, }) => {
+    if (rows.length === 0) {
+        throw new Error('Cannot pivot results with no rows');
+    }
+    const hiddenMetricFieldIds = pivotConfig.hiddenMetricFieldIds || [];
+    const summableMetricFieldIds = pivotConfig.summableMetricFieldIds || [];
+    const columnOrder = (pivotConfig.columnOrder || []).filter((id) => !hiddenMetricFieldIds.includes(id));
+    const dimensions = [...metricQuery.dimensions];
+    // Headers (column index)
+    const headerDimensions = pivotConfig.pivotDimensions.filter((pivotDimension) => dimensions.includes(pivotDimension));
+    const headerDimensionValueTypes = headerDimensions.map((d) => ({
+        type: field_1.FieldType.DIMENSION,
+        fieldId: d,
+    }));
+    const headerMetricValueTypes = pivotConfig.metricsAsRows ? [] : [{ type: field_1.FieldType.METRIC }];
+    const headerValueTypes = [
+        ...headerDimensionValueTypes,
+        ...headerMetricValueTypes,
+    ];
+    // Indices (row index)
+    const indexDimensions = dimensions
+        .filter((d) => !pivotConfig.pivotDimensions.includes(d))
+        .slice()
+        .sort((a, b) => columnOrder.indexOf(a) - columnOrder.indexOf(b));
+    const indexDimensionValueTypes = indexDimensions.map((d) => ({
+        type: field_1.FieldType.DIMENSION,
+        fieldId: d,
+    }));
+    const indexMetricValueTypes = pivotConfig.metricsAsRows ? [{ type: field_1.FieldType.METRIC }] : [];
+    const indexValueTypes = [
+        ...indexDimensionValueTypes,
+        ...indexMetricValueTypes,
+    ];
+    // Metrics
+    const metrics = [
+        ...metricQuery.metrics,
+        ...metricQuery.tableCalculations.map((tc) => tc.name),
+    ]
+        .filter((m) => !hiddenMetricFieldIds.includes(m))
+        .sort((a, b) => columnOrder.indexOf(a) - columnOrder.indexOf(b))
+        .map((id) => ({ fieldId: id }));
+    if (metrics.length === 0) {
+        throw new Error('Cannot pivot results with no metrics');
+    }
+    const N_ROWS = rows.length;
+    // For every row in the results, compute the index and header values to determine the shape of the result set
+    const indexValues = [];
+    const headerValuesT = [];
+    const rowIndices = {};
+    const columnIndices = {};
+    let rowCount = 0;
+    let columnCount = 0;
+    for (let nRow = 0; nRow < N_ROWS; nRow += 1) {
+        const row = rows[nRow];
+        for (let nMetric = 0; nMetric < metrics.length; nMetric += 1) {
+            const metric = metrics[nMetric];
+            const indexRowValues = indexDimensions
+                .map((fieldId) => ({
+                type: 'value',
+                fieldId,
+                value: row[fieldId].value,
+                colSpan: 1,
+            }))
+                .concat(pivotConfig.metricsAsRows
+                ? [
+                    {
+                        type: 'label',
+                        fieldId: metric.fieldId,
+                    },
+                ]
+                : []);
+            const headerRowValues = headerDimensions
+                .map((fieldId) => ({
+                type: 'value',
+                fieldId,
+                value: row[fieldId].value,
+                colSpan: 1,
+            }))
+                .concat(pivotConfig.metricsAsRows
+                ? []
+                : [
+                    {
+                        type: 'label',
+                        fieldId: metric.fieldId,
+                    },
+                ]);
+            // Write the index values
+            if (setIndexByKey(rowIndices, indexRowValues.map((l) => l.type === 'value' ? String(l.value?.raw) : l.fieldId), rowCount)) {
+                rowCount += 1;
+                indexValues.push(indexRowValues);
+            }
+            // Write the header values
+            if (setIndexByKey(columnIndices, headerRowValues.map((l) => l.type === 'value' ? String(l.value.raw) : l.fieldId), columnCount)) {
+                columnCount += 1;
+                if (columnCount > options.maxColumns) {
+                    throw new Error(`Cannot pivot results with more than ${options.maxColumns} columns. Try adding a filter to limit your results.`);
+                }
+                headerValuesT.push(headerRowValues);
+            }
+        }
+    }
+    const headerValues = headerValuesT[0]?.map((_, colIndex) => headerValuesT.map((row, rowIndex) => {
+        const cell = row[colIndex];
+        if (cell.type === 'label') {
+            return cell;
+        }
+        const keys = row
+            .slice(0, colIndex + 1)
+            .reduce((acc, l) => l.type === 'value'
+            ? [...acc, String(l.value.raw)]
+            : acc, []);
+        const cellWithSpan = {
+            ...cell,
+            colSpan: getColSpanByKey(rowIndex, columnIndices, keys),
+        };
+        return cellWithSpan;
+    })) ?? [];
+    const hasIndex = indexValueTypes.length > 0;
+    const hasHeader = headerValueTypes.length > 0;
+    // Compute the size of the data values
+    const N_DATA_ROWS = hasIndex ? rowCount : 1;
+    const N_DATA_COLUMNS = hasHeader ? columnCount : 1;
+    // Compute the data values
+    const dataValues = create2DArray(N_DATA_ROWS, N_DATA_COLUMNS);
+    if (N_DATA_ROWS === 0 || N_DATA_COLUMNS === 0) {
+        throw new Error('Cannot pivot results with no data');
+    }
+    // Compute pivoted data
+    for (let nRow = 0; nRow < N_ROWS; nRow += 1) {
+        const row = rows[nRow];
+        for (let nMetric = 0; nMetric < metrics.length; nMetric += 1) {
+            const metric = metrics[nMetric];
+            const { value } = row[metric.fieldId];
+            const rowKeys = [
+                ...indexDimensions.map((d) => row[d].value.raw),
+                ...(pivotConfig.metricsAsRows ? [metric.fieldId] : []),
+            ];
+            const columnKeys = [
+                ...headerDimensions.map((d) => row[d].value.raw),
+                ...(pivotConfig.metricsAsRows ? [] : [metric.fieldId]),
+            ];
+            const rowKeysString = rowKeys.map(String);
+            const columnKeysString = columnKeys.map(String);
+            const rowIndex = hasIndex
+                ? getIndexByKey(rowIndices, rowKeysString)
+                : 0;
+            const columnIndex = hasHeader
+                ? getIndexByKey(columnIndices, columnKeysString)
+                : 0;
+            dataValues[rowIndex][columnIndex] = value;
+        }
+    }
+    // compute row totals
+    let rowTotalFields;
+    let rowTotals;
+    if (pivotConfig.rowTotals && hasHeader) {
+        if (pivotConfig.metricsAsRows) {
+            const N_TOTAL_COLS = 1;
+            const N_TOTAL_ROWS = headerValues.length;
+            rowTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
+            rowTotals = create2DArray(N_DATA_ROWS, N_TOTAL_COLS);
+            // set the last header cell as the "Total"
+            rowTotalFields[N_TOTAL_ROWS - 1][N_TOTAL_COLS - 1] = {
+                fieldId: undefined,
+            };
+            rowTotals = rowTotals.map((row, rowIndex) => row.map(() => dataValues[rowIndex].reduce((acc, value) => acc + parseNumericValue(value), 0)));
+        }
+        else {
+            const N_TOTAL_COLS = summableMetricFieldIds.length;
+            const N_TOTAL_ROWS = headerValues.length;
+            rowTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
+            rowTotals = create2DArray(N_DATA_ROWS, N_TOTAL_COLS);
+            summableMetricFieldIds.forEach((fieldId, metricIndex) => {
+                rowTotalFields[N_TOTAL_ROWS - 1][metricIndex] = {
+                    fieldId,
+                };
+            });
+            rowTotals = rowTotals.map((row, rowIndex) => row.map((_, totalColIndex) => {
+                const totalColFieldId = rowTotalFields[N_TOTAL_ROWS - 1][totalColIndex]
+                    ?.fieldId;
+                const valueColIndices = totalColFieldId
+                    ? getAllIndicesForFieldId(columnIndices, totalColFieldId)
+                    : [];
+                return dataValues[rowIndex]
+                    .filter((__, dataValueColIndex) => valueColIndices.includes(dataValueColIndex))
+                    .reduce((acc, value) => acc + parseNumericValue(value), 0);
+            }));
+        }
+    }
+    let columnTotalFields;
+    let columnTotals;
+    if (pivotConfig.columnTotals && hasIndex) {
+        if (pivotConfig.metricsAsRows) {
+            const N_TOTAL_ROWS = summableMetricFieldIds.length;
+            const N_TOTAL_COLS = indexValueTypes.length;
+            columnTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
+            columnTotals = create2DArray(N_TOTAL_ROWS, N_DATA_COLUMNS);
+            summableMetricFieldIds.forEach((fieldId, metricIndex) => {
+                columnTotalFields[metricIndex][N_TOTAL_COLS - 1] = {
+                    fieldId,
+                };
+            });
+            columnTotals = columnTotals.map((row, rowIndex) => row.map((_, totalColIndex) => {
+                const totalColFieldId = columnTotalFields[rowIndex][N_TOTAL_COLS - 1]?.fieldId;
+                const valueColIndices = totalColFieldId
+                    ? getAllIndicesForFieldId(rowIndices, totalColFieldId)
+                    : [];
+                return dataValues
+                    .filter((__, dataValueColIndex) => valueColIndices.includes(dataValueColIndex))
+                    .reduce((acc, value) => acc + parseNumericValue(value[totalColIndex]), 0);
+            }));
+        }
+        else {
+            const N_TOTAL_COLS = indexValues[0].length;
+            const N_TOTAL_ROWS = 1;
+            columnTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
+            columnTotals = create2DArray(N_TOTAL_ROWS, N_DATA_COLUMNS);
+            // set the last index cell as the "Total"
+            columnTotalFields[N_TOTAL_ROWS - 1][N_TOTAL_COLS - 1] = {
+                fieldId: undefined,
+            };
+            columnTotals = columnTotals.map((row, _totalRowIndex) => row.map((_col, colIndex) => dataValues
+                .map((dataRow) => dataRow[colIndex])
+                .reduce((acc, value) => acc + parseNumericValue(value), 0)));
+        }
+    }
+    const titleFields = create2DArray(hasHeader ? headerValueTypes.length : 1, hasIndex ? indexValueTypes.length : 1);
+    headerValueTypes.forEach((headerValueType, headerIndex) => {
+        if (headerValueType.type === field_1.FieldType.DIMENSION) {
+            titleFields[headerIndex][hasIndex ? indexValueTypes.length - 1 : 0] = {
+                fieldId: headerValueType.fieldId,
+                direction: 'header',
+            };
+        }
+    });
+    indexValueTypes.forEach((indexValueType, indexIndex) => {
+        if (indexValueType.type === field_1.FieldType.DIMENSION) {
+            titleFields[hasHeader ? headerValueTypes.length - 1 : 0][indexIndex] = {
+                fieldId: indexValueType.fieldId,
+                direction: 'index',
+            };
+        }
+    });
+    const cellsCount = (indexValueTypes.length === 0 ? titleFields[0].length : 0) +
+        indexValueTypes.length +
+        dataValues[0].length +
+        (pivotConfig.rowTotals && rowTotals ? rowTotals[0].length : 0);
+    const rowsCount = dataValues.length || 0;
+    const pivotData = {
+        titleFields,
+        headerValueTypes,
+        headerValues,
+        indexValueTypes,
+        indexValues,
+        dataColumnCount: N_DATA_COLUMNS,
+        dataValues,
+        rowTotalFields,
+        columnTotalFields,
+        rowTotals,
+        columnTotals,
+        cellsCount,
+        rowsCount,
+        pivotConfig,
+        retrofitData: {
+            allCombinedData: [],
+            pivotColumnInfo: [],
+        },
+    };
+    return combinedRetrofit(pivotData, getField, getFieldLabel);
+};
+exports.pivotQueryResults = pivotQueryResults;
+const pivotResultsAsCsv = (pivotConfig, rows, itemMap, metricQuery, customLabels, onlyRaw, maxColumnLimit) => {
+    const getFieldLabel = (fieldId) => {
+        const customLabel = customLabels?.[fieldId];
+        if (customLabel !== undefined)
+            return customLabel;
+        const field = itemMap[fieldId];
+        return (field && (0, field_1.isField)(field) && field?.label) || fieldId;
+    };
+    const pivotedResults = (0, exports.pivotQueryResults)({
+        pivotConfig,
+        metricQuery,
+        rows,
+        options: {
+            maxColumns: maxColumnLimit,
+        },
+        getField: (fieldId) => itemMap && itemMap[fieldId],
+        getFieldLabel,
+    });
+    const formatField = onlyRaw ? 'raw' : 'formatted';
+    const headers = pivotedResults.headerValues.reduce((acc, row, i) => {
+        const values = row.map((header) => 'value' in header
+            ? header.value[formatField]
+            : getFieldLabel(header.fieldId));
+        const fields = pivotedResults.titleFields[i];
+        const fieldLabels = fields.map((field) => field ? getFieldLabel(field.fieldId) : '-');
+        acc[i] = [...fieldLabels, ...values];
+        return acc;
+    }, [[]]);
+    const fieldIds = Object.values(pivotedResults.retrofitData.pivotColumnInfo).map((field) => field.fieldId);
+    const hasIndex = pivotedResults.indexValues.length > 0;
+    const pivotedRows = pivotedResults.retrofitData.allCombinedData.map((row) => {
+        // Fields that return `null` don't appear in the pivot table
+        // If there are no index fields, we need to add an empty string to the beginning of the row
+        const noIndexPrefix = hasIndex ? [] : [''];
+        const formattedRows = fieldIds.map((fieldId) => row[fieldId]?.value?.[formatField] || '-');
+        return [...noIndexPrefix, ...formattedRows];
+    });
+    return [...headers, ...pivotedRows];
+};
+exports.pivotResultsAsCsv = pivotResultsAsCsv;

package/dist/pivotTable/pivotQueryResults.mock.d.ts

@@ -0,0 +1,8 @@
+import { type MetricQuery } from '../types/metricQuery';
+import { type ResultRow } from '../types/results';
+export declare const METRIC_QUERY_2DIM_2METRIC: Pick<MetricQuery, 'metrics' | 'dimensions' | 'tableCalculations' | 'additionalMetrics'>;
+export declare const RESULT_ROWS_2DIM_2METRIC: ResultRow[];
+export declare const METRIC_QUERY_1DIM_2METRIC: Pick<MetricQuery, 'metrics' | 'dimensions' | 'tableCalculations' | 'additionalMetrics'>;
+export declare const RESULT_ROWS_1DIM_2METRIC: ResultRow[];
+export declare const METRIC_QUERY_0DIM_2METRIC: Pick<MetricQuery, 'metrics' | 'dimensions' | 'tableCalculations' | 'additionalMetrics'>;
+export declare const RESULT_ROWS_0DIM_2METRIC: ResultRow[];

package/dist/pivotTable/pivotQueryResults.mock.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESULT_ROWS_0DIM_2METRIC = exports.METRIC_QUERY_0DIM_2METRIC = exports.RESULT_ROWS_1DIM_2METRIC = exports.METRIC_QUERY_1DIM_2METRIC = exports.RESULT_ROWS_2DIM_2METRIC = exports.METRIC_QUERY_2DIM_2METRIC = void 0;
+exports.METRIC_QUERY_2DIM_2METRIC = {
+    metrics: ['views', 'devices'],
+    dimensions: ['page', 'site'],
+    tableCalculations: [],
+};
+exports.RESULT_ROWS_2DIM_2METRIC = [
+    {
+        page: { value: { raw: '/home', formatted: '/home' } },
+        site: { value: { raw: 'blog', formatted: 'Blog' } },
+        views: { value: { raw: 6, formatted: '6.0' } },
+        devices: { value: { raw: 7, formatted: '7.0' } },
+    },
+    {
+        page: { value: { raw: '/about', formatted: '/about' } },
+        site: { value: { raw: 'blog', formatted: 'Blog' } },
+        views: { value: { raw: 12, formatted: '12.0' } },
+        devices: { value: { raw: 0, formatted: '0.0' } },
+    },
+    {
+        page: { value: { raw: '/first-post', formatted: '/first-post' } },
+        site: { value: { raw: 'blog', formatted: 'Blog' } },
+        views: { value: { raw: 11, formatted: '11.0' } },
+        devices: { value: { raw: 1, formatted: '1.0' } },
+    },
+    {
+        page: { value: { raw: '/home', formatted: '/home' } },
+        site: { value: { raw: 'docs', formatted: 'Docs' } },
+        views: { value: { raw: 2, formatted: '2.0' } },
+        devices: { value: { raw: 10, formatted: '10.0' } },
+    },
+    {
+        page: { value: { raw: '/about', formatted: '/about' } },
+        site: { value: { raw: 'docs', formatted: 'Docs' } },
+        views: { value: { raw: 2, formatted: '2.0' } },
+        devices: { value: { raw: 13, formatted: '13.0' } },
+    },
+];
+exports.METRIC_QUERY_1DIM_2METRIC = {
+    metrics: ['views', 'devices'],
+    dimensions: ['page'],
+    tableCalculations: [],
+};
+exports.RESULT_ROWS_1DIM_2METRIC = [
+    {
+        page: { value: { raw: '/home', formatted: '/home' } },
+        views: { value: { raw: 6, formatted: '6.0' } },
+        devices: { value: { raw: 7, formatted: '7.0' } },
+    },
+    {
+        page: { value: { raw: '/about', formatted: '/about' } },
+        views: { value: { raw: 12, formatted: '12.0' } },
+        devices: { value: { raw: 0, formatted: '0.0' } },
+    },
+    {
+        page: { value: { raw: '/first-post', formatted: '/first-post' } },
+        views: { value: { raw: 11, formatted: '11.0' } },
+        devices: { value: { raw: 1, formatted: '1.0' } },
+    },
+];
+exports.METRIC_QUERY_0DIM_2METRIC = {
+    metrics: ['views', 'devices'],
+    dimensions: [],
+    tableCalculations: [],
+};
+exports.RESULT_ROWS_0DIM_2METRIC = [
+    {
+        views: { value: { raw: 6, formatted: '6.0' } },
+        devices: { value: { raw: 7, formatted: '7.0' } },
+    },
+];

package/dist/pivotTable/pivotQueryResults.test.d.ts

@@ -0,0 +1 @@
+export {};