@lightdash/common 0.2104.6 → 0.2104.8

package/dist/types/utils/virtualView.js

@@ -0,0 +1,98 @@
+import { ExploreCompiler } from '../compiler/exploreCompiler';
+import { SupportedDbtAdapter } from '../types/dbt';
+import { ExploreType } from '../types/explore';
+import { DimensionType, FieldType, friendlyName, } from '../types/field';
+import { WarehouseTypes } from '../types/projects';
+import { WeekDay } from './timeFrames';
+export const createVirtualView = (virtualViewName, sql, columns, warehouseClient, label) => {
+    const exploreCompiler = new ExploreCompiler(warehouseClient);
+    const fieldQuoteChar = warehouseClient.getFieldQuoteChar();
+    const dimensions = columns.reduce((acc, column) => {
+        acc[column.reference] = {
+            name: column.reference,
+            label: friendlyName(column.reference),
+            type: column.type ?? DimensionType.STRING,
+            table: virtualViewName,
+            fieldType: FieldType.DIMENSION,
+            sql: `${fieldQuoteChar}${column.reference}${fieldQuoteChar}`,
+            tableLabel: friendlyName(virtualViewName),
+            hidden: false,
+        };
+        return acc;
+    }, {});
+    const compiledTable = {
+        name: virtualViewName,
+        label: label || friendlyName(virtualViewName),
+        sqlTable: `(${sql})`, // Wrap the sql in a subquery to avoid issues with reserved words
+        dimensions,
+        metrics: {},
+        lineageGraph: { nodes: [], edges: [] },
+        database: warehouseClient.credentials.type,
+        schema: '', // TODO: what should this be?
+    };
+    const explore = exploreCompiler.compileExplore({
+        name: virtualViewName,
+        label: label || friendlyName(virtualViewName),
+        tags: [],
+        baseTable: virtualViewName,
+        joinedTables: [],
+        tables: { [virtualViewName]: compiledTable },
+        targetDatabase: warehouseClient.getAdapterType(),
+        meta: {},
+    });
+    const virtualView = {
+        ...explore,
+        type: ExploreType.VIRTUAL,
+    };
+    return virtualView;
+};
+export const createTemporaryVirtualView = (virtualViewName, sql, columns) => {
+    // Create a fake warehouseClient for compilation purposes
+    const fakeWarehouseClient = {
+        credentials: {
+            type: WarehouseTypes.BIGQUERY,
+            project: '',
+            dataset: '',
+            timeoutSeconds: 0,
+            priority: 'interactive',
+            keyfileContents: {},
+            retries: 3,
+            location: '',
+            maximumBytesBilled: 0,
+        },
+        getCatalog: async () => ({}),
+        getAsyncQueryResults: async () => ({
+            queryId: null,
+            queryMetadata: null,
+            totalRows: 0,
+            durationMs: 0,
+            fields: {},
+            pageCount: 0,
+            rows: [],
+        }),
+        streamQuery: async () => { },
+        executeAsyncQuery: async () => ({
+            queryId: null,
+            queryMetadata: null,
+            totalRows: 0,
+            durationMs: 0,
+        }),
+        runQuery: async () => ({ fields: {}, rows: [] }),
+        test: async () => { },
+        getStartOfWeek: () => WeekDay.MONDAY,
+        getAdapterType: () => SupportedDbtAdapter.BIGQUERY,
+        getStringQuoteChar: () => "'",
+        getEscapeStringQuoteChar: () => "''",
+        getFieldQuoteChar: () => '"',
+        getFloatingType: () => 'FLOAT',
+        getMetricSql: () => '',
+        concatString: (...args) => args.join(''),
+        getAllTables: async () => [],
+        getFields: async () => ({}),
+        parseWarehouseCatalog: () => ({}),
+        parseError: (error) => error,
+        escapeString: (value) => value,
+    };
+    return createVirtualView(virtualViewName, sql, columns, fakeWarehouseClient);
+};
+//# sourceMappingURL=virtualView.js.map

package/dist/types/utils/virtualView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtualView.js","sourceRoot":"","sources":["../../../src/utils/virtualView.ts"],"names":[],"mappings":"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"}

package/dist/types/utils/warehouse.js

@@ -0,0 +1,57 @@
+import { SupportedDbtAdapter } from '../types/dbt';
+import { WarehouseTypes } from '../types/projects';
+import { VizAggregationOptions } from '../visualizations/types';
+import assertUnreachable from './assertUnreachable';
+/**
+ * @deprecated use WarehouseSqlBuilder.getFieldQuoteChar instead
+ * @param warehouseType
+ */
+export const getFieldQuoteChar = (warehouseType) => {
+    if (warehouseType) {
+        switch (warehouseType) {
+            case WarehouseTypes.BIGQUERY:
+            case WarehouseTypes.DATABRICKS:
+                return '`';
+            case WarehouseTypes.SNOWFLAKE:
+            case WarehouseTypes.REDSHIFT:
+            case WarehouseTypes.POSTGRES:
+            case WarehouseTypes.TRINO:
+            case WarehouseTypes.CLICKHOUSE:
+                return '"';
+            default:
+                return assertUnreachable(warehouseType, `Unknown warehouse type ${warehouseType}`);
+        }
+    }
+    return '"';
+};
+export const getAggregatedField = (warehouseSqlBuilder, aggregation, reference) => {
+    const q = warehouseSqlBuilder.getFieldQuoteChar();
+    const adapterType = warehouseSqlBuilder.getAdapterType();
+    switch (adapterType) {
+        case SupportedDbtAdapter.BIGQUERY:
+        case SupportedDbtAdapter.DATABRICKS:
+        case SupportedDbtAdapter.SNOWFLAKE:
+        case SupportedDbtAdapter.REDSHIFT:
+        case SupportedDbtAdapter.TRINO:
+            const aggregationFunction = aggregation === VizAggregationOptions.ANY
+                ? 'ANY_VALUE'
+                : aggregation;
+            return `${aggregationFunction}(${q}${reference}${q})`;
+        case SupportedDbtAdapter.POSTGRES:
+            if (aggregation === VizAggregationOptions.ANY) {
+                // ANY_VALUE on Postgres is only available from version v16+
+                return `(ARRAY_AGG(${q}${reference}${q}))[1]`;
+            }
+            break;
+        case SupportedDbtAdapter.CLICKHOUSE:
+            if (aggregation === VizAggregationOptions.ANY) {
+                // ClickHouse uses any() function for ANY_VALUE equivalent
+                return `any(${q}${reference}${q})`;
+            }
+            break;
+        default:
+            return assertUnreachable(adapterType, `Unknown warehouse type ${adapterType}`);
+    }
+    return `${aggregation}(${q}${reference}${q})`;
+};
+//# sourceMappingURL=warehouse.js.map

package/dist/types/utils/warehouse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warehouse.js","sourceRoot":"","sources":["../../../src/utils/warehouse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AAEpD;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC7B,aAAyC,EAC3C,EAAE;IACA,IAAI,aAAa,EAAE,CAAC;QAChB,QAAQ,aAAa,EAAE,CAAC;YACpB,KAAK,cAAc,CAAC,QAAQ,CAAC;YAC7B,KAAK,cAAc,CAAC,UAAU;gBAC1B,OAAO,GAAG,CAAC;YACf,KAAK,cAAc,CAAC,SAAS,CAAC;YAC9B,KAAK,cAAc,CAAC,QAAQ,CAAC;YAC7B,KAAK,cAAc,CAAC,QAAQ,CAAC;YAC7B,KAAK,cAAc,CAAC,KAAK,CAAC;YAC1B,KAAK,cAAc,CAAC,UAAU;gBAC1B,OAAO,GAAG,CAAC;YACf;gBACI,OAAO,iBAAiB,CACpB,aAAa,EACb,0BAA0B,aAAa,EAAE,CAC5C,CAAC;QACV,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACf,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAC9B,mBAAwC,EACxC,WAAkC,EAClC,SAAiB,EACX,EAAE;IACR,MAAM,CAAC,GAAG,mBAAmB,CAAC,iBAAiB,EAAE,CAAC;IAClD,MAAM,WAAW,GAAG,mBAAmB,CAAC,cAAc,EAAE,CAAC;IACzD,QAAQ,WAAW,EAAE,CAAC;QAClB,KAAK,mBAAmB,CAAC,QAAQ,CAAC;QAClC,KAAK,mBAAmB,CAAC,UAAU,CAAC;QACpC,KAAK,mBAAmB,CAAC,SAAS,CAAC;QACnC,KAAK,mBAAmB,CAAC,QAAQ,CAAC;QAClC,KAAK,mBAAmB,CAAC,KAAK;YAC1B,MAAM,mBAAmB,GACrB,WAAW,KAAK,qBAAqB,CAAC,GAAG;gBACrC,CAAC,CAAC,WAAW;gBACb,CAAC,CAAC,WAAW,CAAC;YACtB,OAAO,GAAG,mBAAmB,IAAI,CAAC,GAAG,SAAS,GAAG,CAAC,GAAG,CAAC;QAE1D,KAAK,mBAAmB,CAAC,QAAQ;YAC7B,IAAI,WAAW,KAAK,qBAAqB,CAAC,GAAG,EAAE,CAAC;gBAC5C,4DAA4D;gBAC5D,OAAO,cAAc,CAAC,GAAG,SAAS,GAAG,CAAC,OAAO,CAAC;YAClD,CAAC;YACD,MAAM;QACV,KAAK,mBAAmB,CAAC,UAAU;YAC/B,IAAI,WAAW,KAAK,qBAAqB,CAAC,GAAG,EAAE,CAAC;gBAC5C,0DAA0D;gBAC1D,OAAO,OAAO,CAAC,GAAG,SAAS,GAAG,CAAC,GAAG,CAAC;YACvC,CAAC;YACD,MAAM;QACV;YACI,OAAO,iBAAiB,CACpB,WAAW,EACX,0BAA0B,WAAW,EAAE,CAC1C,CAAC;IACV,CAAC;IACD,OAAO,GAAG,WAAW,IAAI,CAAC,GAAG,SAAS,GAAG,CAAC,GAAG,CAAC;AAClD,CAAC,CAAC"}

package/dist/types/visualizations/CartesianChartDataModel.js

@@ -0,0 +1,515 @@
+import intersectionBy from 'lodash/intersectionBy';
+import { getFirstIndexColumns } from '../pivot/utils';
+import { capitalize, CustomFormatType, DimensionType, Format, friendlyName, } from '../types/field';
+import { ChartKind, ECHARTS_DEFAULT_COLORS, } from '../types/savedCharts';
+import { applyCustomFormat } from '../utils/formatting';
+import { createStack100TooltipFormatter, transformToPercentageStacking, } from './chartTransformations';
+import { SortByDirection, StackType, VizAggregationOptions, VizIndexType, } from './types';
+// Empty config as default. This makes sense to be defined by the DataModel,
+// but is this the right place?
+const defaultFieldConfig = {
+    x: {
+        reference: 'x',
+        type: VizIndexType.CATEGORY,
+    },
+    y: [
+        {
+            reference: 'y',
+            aggregation: VizAggregationOptions.SUM,
+        },
+    ],
+    groupBy: [],
+};
+export var ValueLabelPositionOptions;
+(function (ValueLabelPositionOptions) {
+    ValueLabelPositionOptions["HIDDEN"] = "hidden";
+    ValueLabelPositionOptions["TOP"] = "top";
+    ValueLabelPositionOptions["BOTTOM"] = "bottom";
+    ValueLabelPositionOptions["LEFT"] = "left";
+    ValueLabelPositionOptions["RIGHT"] = "right";
+    ValueLabelPositionOptions["INSIDE"] = "inside";
+})(ValueLabelPositionOptions || (ValueLabelPositionOptions = {}));
+export class CartesianChartDataModel {
+    constructor(args) {
+        this.resultsRunner = args.resultsRunner;
+        this.fieldConfig = args.fieldConfig ?? defaultFieldConfig;
+        this.type = args.type ?? ChartKind.VERTICAL_BAR;
+    }
+    // Get the formatter for the tooltip, which has a simple callback signature
+    static getTooltipFormatter(format) {
+        if (format === Format.PERCENT) {
+            return (value) => applyCustomFormat(value, {
+                type: CustomFormatType.PERCENT,
+            });
+        }
+        return undefined;
+    }
+    // Get the formatter for the value label,
+    // which has more complex inputs
+    static getValueFormatter(format) {
+        if (format === Format.PERCENT) {
+            // Echarts doesn't export the types for this function
+            return (params) => {
+                const value = params.value[params.dimensionNames[params.encode.y[0]]];
+                return applyCustomFormat(value, {
+                    type: CustomFormatType.PERCENT,
+                });
+            };
+        }
+        return undefined;
+    }
+    mergeConfig(chartKind, existingConfig) {
+        const newDefaultLayout = this.getDefaultLayout();
+        const someFieldsMatch = existingConfig?.fieldConfig?.x?.reference ===
+            newDefaultLayout?.x?.reference ||
+            intersectionBy(existingConfig?.fieldConfig?.y || [], newDefaultLayout?.y || [], 'reference').length > 0;
+        let mergedLayout = existingConfig?.fieldConfig;
+        if (!existingConfig?.fieldConfig || !someFieldsMatch) {
+            mergedLayout = newDefaultLayout;
+        }
+        return {
+            metadata: {
+                version: 1,
+            },
+            type: chartKind,
+            fieldConfig: mergedLayout ?? existingConfig?.fieldConfig,
+            display: existingConfig?.display ?? {},
+        };
+    }
+    getChartOptions() {
+        return {
+            indexLayoutOptions: this.resultsRunner.getPivotQueryDimensions(),
+            valuesLayoutOptions: {
+                preAggregated: this.resultsRunner.getPivotQueryMetrics(),
+                customAggregations: this.resultsRunner.getPivotQueryCustomMetrics(),
+            },
+            pivotLayoutOptions: this.resultsRunner.getPivotQueryDimensions(),
+        };
+    }
+    getDefaultLayout() {
+        const dimensions = this.resultsRunner.getPivotQueryDimensions();
+        const metrics = this.resultsRunner.getPivotQueryMetrics();
+        // TODO: the types could be cleaned up here to have fewer 'in' checks.
+        const categoricalColumns = [...dimensions, ...metrics].filter((column) => 'dimensionType' in column &&
+            column.dimensionType === DimensionType.STRING);
+        const booleanColumns = [...dimensions, ...metrics].filter((column) => 'dimensionType' in column &&
+            column.dimensionType === DimensionType.BOOLEAN);
+        const dateColumns = [...dimensions, ...metrics].filter((column) => 'dimensionType' in column &&
+            [DimensionType.DATE, DimensionType.TIMESTAMP].includes(column.dimensionType));
+        const numericColumns = [...dimensions, ...metrics].filter((column) => 'dimensionType' in column &&
+            column.dimensionType === DimensionType.NUMBER);
+        const xColumn = dateColumns[0] ||
+            categoricalColumns[0] ||
+            booleanColumns[0] ||
+            numericColumns[0] ||
+            dimensions[0];
+        if (xColumn === undefined) {
+            return undefined;
+        }
+        const x = {
+            reference: xColumn.reference,
+            type: 'axisType' in xColumn
+                ? xColumn.axisType
+                : VizIndexType.CATEGORY,
+        };
+        const yColumn = metrics[0] ||
+            numericColumns.filter((column) => column.reference !== x.reference)[0] ||
+            booleanColumns.filter((column) => column.reference !== x.reference)[0] ||
+            categoricalColumns.filter((column) => column.reference !== x.reference)[0];
+        if (yColumn === undefined) {
+            return undefined;
+        }
+        const y = [
+            {
+                reference: yColumn.reference,
+                aggregation: 'dimensionType' in yColumn &&
+                    yColumn.dimensionType === DimensionType.NUMBER
+                    ? VizAggregationOptions.SUM
+                    : VizAggregationOptions.COUNT,
+            },
+        ];
+        const sortBy = [
+            { reference: x.reference, direction: SortByDirection.ASC },
+        ];
+        return {
+            x,
+            y,
+            groupBy: [],
+            sortBy,
+        };
+    }
+    getConfigErrors(fieldConfig) {
+        if (!fieldConfig) {
+            return undefined;
+        }
+        const { indexLayoutOptions, valuesLayoutOptions, pivotLayoutOptions } = this.getChartOptions();
+        const indexFieldError = Boolean(fieldConfig?.x?.reference &&
+            indexLayoutOptions.find((x) => x.reference === fieldConfig?.x?.reference) === undefined);
+        const metricFieldError = Boolean(fieldConfig?.y?.some((yField) => yField.reference &&
+            valuesLayoutOptions.preAggregated.find((y) => y.reference === yField.reference) === undefined &&
+            valuesLayoutOptions.customAggregations.find((y) => y.reference === yField.reference) === undefined));
+        const customMetricFieldError = Boolean(fieldConfig?.y?.some((yField) => yField.reference &&
+            valuesLayoutOptions.customAggregations.find((y) => y.reference === yField.reference) === undefined));
+        const groupByFieldError = Boolean(fieldConfig?.groupBy?.some((groupByField) => groupByField.reference &&
+            pivotLayoutOptions.find((x) => x.reference === groupByField.reference) === undefined));
+        if (!indexFieldError &&
+            !metricFieldError &&
+            !customMetricFieldError &&
+            !groupByFieldError) {
+            return undefined;
+        }
+        return {
+            ...(indexFieldError &&
+                fieldConfig?.x?.reference && {
+                indexFieldError: {
+                    reference: fieldConfig.x.reference,
+                },
+            }),
+            // TODO: can we combine metricFieldError and customMetricFieldError?
+            // And maybe take out some noise
+            ...(metricFieldError &&
+                fieldConfig?.y?.map((y) => y.reference) && {
+                metricFieldError: {
+                    references: fieldConfig?.y.reduce((acc, y) => {
+                        const valuesLayoutOption = valuesLayoutOptions.preAggregated.find((v) => v.reference === y.reference);
+                        if (!valuesLayoutOption) {
+                            acc.push(y.reference);
+                        }
+                        return acc;
+                    }, []),
+                },
+            }),
+            ...(customMetricFieldError &&
+                fieldConfig?.y?.map((y) => y.reference) && {
+                customMetricFieldError: {
+                    references: fieldConfig?.y.reduce((acc, y) => {
+                        const valuesLayoutOption = valuesLayoutOptions.customAggregations.find((v) => v.reference === y.reference);
+                        if (!valuesLayoutOption) {
+                            acc.push(y.reference);
+                        }
+                        return acc;
+                    }, []),
+                },
+            }),
+            ...(groupByFieldError &&
+                fieldConfig?.groupBy?.map((gb) => gb.reference) && {
+                groupByFieldError: {
+                    references: fieldConfig.groupBy.map((gb) => gb.reference),
+                },
+            }),
+        };
+    }
+    static getDefaultColor(index, orgColors) {
+        const colorPalette = orgColors || ECHARTS_DEFAULT_COLORS;
+        // This code assigns a color to a series in the chart
+        const color = colorPalette[index % colorPalette.length // This ensures we cycle through the colors if we have more series than colors
+        ];
+        return color;
+    }
+    async getTransformedData(query) {
+        if (!query) {
+            return undefined;
+        }
+        return this.resultsRunner.getPivotedVisualizationData(query);
+    }
+    // TODO: dupe function code - see pie chart
+    async getPivotedChartData({ sortBy, filters, limit, sql, }) {
+        const allDimensionNames = new Set(this.resultsRunner
+            .getPivotQueryDimensions()
+            .map((d) => d.reference));
+        const allSelectedDimensions = [
+            this.fieldConfig?.x?.reference,
+            ...(this.fieldConfig?.groupBy?.map((groupBy) => groupBy.reference) ?? []),
+        ];
+        const [timeDimensions, dimensions] = this.resultsRunner
+            .getPivotQueryDimensions()
+            .reduce((acc, dimension) => {
+            if (allSelectedDimensions.includes(dimension.reference)) {
+                if (dimension.dimensionType === DimensionType.DATE ||
+                    dimension.dimensionType === DimensionType.TIMESTAMP) {
+                    acc[0].push({ name: dimension.reference });
+                }
+                else {
+                    acc[1].push({ name: dimension.reference });
+                }
+            }
+            return acc;
+        }, [[], []]);
+        const { customMetrics, metrics } = this.fieldConfig?.y?.reduce((acc, field) => {
+            if (allDimensionNames.has(field.reference)) {
+                // it's a custom metric
+                const name = `${field.reference}_${field.aggregation}`;
+                acc.customMetrics.push({
+                    name,
+                    baseDimension: field.reference,
+                    aggType: field.aggregation,
+                });
+                acc.metrics.push({ name });
+            }
+            else {
+                acc.metrics.push({ name: field.reference });
+            }
+            return acc;
+        }, { customMetrics: [], metrics: [] }) ?? { customMetrics: [], metrics: [] };
+        const pivot = {
+            index: this.fieldConfig?.x?.reference
+                ? [this.fieldConfig.x?.reference]
+                : [],
+            on: this.fieldConfig?.groupBy?.map((groupBy) => groupBy.reference) ?? [],
+            values: metrics.map((metric) => metric.name),
+        };
+        const query = {
+            sql,
+            limit,
+            filters,
+            sortBy,
+            metrics,
+            dimensions,
+            timeDimensions,
+            pivot,
+            customMetrics,
+        };
+        const pivotedChartData = await this.getTransformedData(query);
+        this.pivotedChartData = pivotedChartData;
+        return pivotedChartData;
+    }
+    getPivotedTableData() {
+        const transformedData = this.pivotedChartData;
+        const firstIndexColumn = getFirstIndexColumns(transformedData?.indexColumn);
+        if (!transformedData ||
+            !firstIndexColumn ||
+            !transformedData.results ||
+            !transformedData.results.length) {
+            return undefined;
+        }
+        return {
+            columns: [
+                firstIndexColumn.reference,
+                ...transformedData.valuesColumns.map((valueColumn) => valueColumn.pivotColumnName),
+            ],
+            rows: transformedData.results,
+        };
+    }
+    getDataDownloadUrl() {
+        const transformedData = this.pivotedChartData;
+        if (!transformedData) {
+            return undefined;
+        }
+        return transformedData.fileUrl;
+    }
+    // Helper function to convert data to percentages for 100% stacking
+    static convertToPercentageStacking(transformedData, xAxisReference) {
+        const yFieldRefs = transformedData.valuesColumns.map((col) => col.pivotColumnName);
+        return transformToPercentageStacking(transformedData.results, xAxisReference, yFieldRefs);
+    }
+    getSpec(display, colors) {
+        const transformedData = this.pivotedChartData;
+        if (!transformedData) {
+            return {};
+        }
+        const { type } = this;
+        const orgColors = colors ?? ECHARTS_DEFAULT_COLORS;
+        const DEFAULT_X_AXIS_TYPE = VizIndexType.CATEGORY;
+        const defaultSeriesType = type === ChartKind.VERTICAL_BAR ? 'bar' : 'line';
+        // Handle both old boolean format and new StackType string format
+        const stackValue = display?.stack;
+        const shouldStack = stackValue === true ||
+            stackValue === StackType.NORMAL ||
+            stackValue === StackType.PERCENT;
+        const shouldStack100 = stackValue === StackType.PERCENT;
+        const xAxisReference = getFirstIndexColumns(transformedData?.indexColumn)?.reference;
+        // Apply 100% stacking transformation if needed
+        let dataToRender = transformedData.results;
+        let originalValues;
+        if (shouldStack100 && xAxisReference) {
+            const result = CartesianChartDataModel.convertToPercentageStacking(transformedData, xAxisReference);
+            dataToRender = result.transformedResults;
+            originalValues = result.originalValues;
+        }
+        const leftYAxisSeriesReferences = [];
+        const rightYAxisSeriesReferences = [];
+        const series = transformedData.valuesColumns.map((seriesColumn, index) => {
+            const seriesColumnId = seriesColumn.pivotColumnName;
+            // NOTE: seriesColumnId is the post pivoted column name and we now store the display based on that.
+            // If there is no display object for the seriesColumnId, we also referenceField for compatibility with
+            // the old display object that stored display info by the field, not the ID.
+            const seriesDisplay = display?.series?.[seriesColumnId] ??
+                display?.series?.[seriesColumn.referenceField];
+            const seriesColor = seriesDisplay?.color;
+            const seriesValueLabelPosition = seriesDisplay?.valueLabelPosition;
+            const seriesType = seriesDisplay?.type ?? defaultSeriesType;
+            // Any value other than 1 is considered the left axis.
+            const whichYAxis = seriesDisplay?.whichYAxis === 1 ? 1 : 0;
+            const seriesFormat = seriesDisplay?.format ??
+                display?.yAxis?.[whichYAxis]?.format;
+            const singleYAxisLabel = 
+            // NOTE: When there's only one y-axis left, set the label on the series as well
+            transformedData.valuesColumns.length === 1 &&
+                display?.yAxis?.[0]?.label
+                ? display.yAxis[0].label
+                : undefined;
+            const seriesLabel = singleYAxisLabel ?? seriesDisplay?.label;
+            if (whichYAxis === 1) {
+                rightYAxisSeriesReferences.push(seriesColumnId);
+            }
+            else {
+                leftYAxisSeriesReferences.push(seriesColumnId);
+            }
+            return {
+                dimensions: [xAxisReference, seriesColumnId],
+                type: seriesType ?? defaultSeriesType,
+                stack: shouldStack && seriesType === 'bar'
+                    ? `stack-${seriesColumn.referenceField}` // Use referenceField for stack ID
+                    : undefined,
+                name: seriesLabel ||
+                    capitalize(seriesColumnId.toLowerCase()).replaceAll('_', ' '), // similar to friendlyName, but this will preserve special characters
+                encode: {
+                    x: xAxisReference,
+                    y: seriesColumnId,
+                },
+                // NOTE: this yAxisIndex is the echarts option, NOT the yAxisIndex
+                // we had been storing in the display object.
+                yAxisIndex: whichYAxis,
+                tooltip: {
+                    valueFormatter: seriesFormat
+                        ? CartesianChartDataModel.getTooltipFormatter(seriesFormat)
+                        : undefined,
+                },
+                label: seriesValueLabelPosition
+                    ? {
+                        show: seriesValueLabelPosition !== 'hidden',
+                        position: seriesValueLabelPosition,
+                        formatter: seriesFormat
+                            ? CartesianChartDataModel.getValueFormatter(seriesFormat)
+                            : undefined,
+                    }
+                    : undefined,
+                labelLayout: {
+                    hideOverlap: true,
+                },
+                color: seriesColor ||
+                    CartesianChartDataModel.getDefaultColor(index, orgColors),
+            };
+        });
+        const xAxisType = display?.xAxis?.type ||
+            getFirstIndexColumns(transformedData.indexColumn)?.type ||
+            DEFAULT_X_AXIS_TYPE;
+        // Determine tooltip configuration
+        let tooltipConfig = {};
+        if (shouldStack100 && xAxisReference && originalValues) {
+            // Custom formatter for 100% stacking: show percentage and actual count
+            tooltipConfig = {
+                formatter: createStack100TooltipFormatter(originalValues, (param) => {
+                    const { encode, dimensionNames } = param;
+                    if (!encode || !dimensionNames)
+                        return undefined;
+                    // encode.y is an array of dimension indices, not field names
+                    // Get the actual field name from dimensionNames using the index
+                    const yFieldIndex = Array.isArray(encode.y)
+                        ? encode.y[0]
+                        : encode.y;
+                    if (yFieldIndex === undefined ||
+                        typeof yFieldIndex !== 'number')
+                        return undefined;
+                    return dimensionNames[yFieldIndex];
+                }, xAxisReference),
+            };
+        }
+        else if (xAxisType === VizIndexType.TIME && xAxisReference) {
+            tooltipConfig = {
+                axisPointer: {
+                    label: {
+                        // ECharts converts timezone values to local time
+                        // so we need to show the original value in the tooltip
+                        // this function is loosely typed because we don't have ECharts types in common
+                        formatter: (params) => params.seriesData[0]?.value[xAxisReference],
+                    },
+                },
+            };
+        }
+        const spec = {
+            tooltip: {
+                trigger: 'axis',
+                appendToBody: true, // Similar to rendering a tooltip in a Portal
+                ...tooltipConfig,
+            },
+            legend: {
+                show: !!(transformedData.valuesColumns.length > 1),
+                type: 'scroll',
+            },
+            xAxis: {
+                type: xAxisType,
+                name: display?.xAxis?.label ||
+                    friendlyName(xAxisReference || 'xAxisColumn'),
+                nameLocation: 'center',
+                nameGap: 30,
+                nameTextStyle: {
+                    fontWeight: 'bold',
+                },
+            },
+            yAxis: [
+                {
+                    type: 'value',
+                    position: display?.yAxis?.[0]?.position || 'left',
+                    name: leftYAxisSeriesReferences.length > 0
+                        ? display?.yAxis?.[0]?.label ||
+                            friendlyName(leftYAxisSeriesReferences[0])
+                        : '',
+                    nameLocation: 'center',
+                    nameGap: 50,
+                    nameRotate: 90,
+                    nameTextStyle: {
+                        fontWeight: 'bold',
+                    },
+                    ...(() => {
+                        if (shouldStack100) {
+                            // For 100% stacking, show percentage on y-axis
+                            return {
+                                max: 100,
+                                axisLabel: {
+                                    formatter: '{value}%',
+                                },
+                            };
+                        }
+                        if (display?.yAxis?.[0]?.format) {
+                            return {
+                                axisLabel: {
+                                    formatter: CartesianChartDataModel.getTooltipFormatter(display.yAxis[0].format),
+                                },
+                            };
+                        }
+                        return {};
+                    })(),
+                },
+                {
+                    type: 'value',
+                    position: 'right',
+                    name: rightYAxisSeriesReferences.length > 0
+                        ? display?.yAxis?.[1]?.label ||
+                            friendlyName(rightYAxisSeriesReferences[0])
+                        : '',
+                    nameLocation: 'center',
+                    nameGap: 50,
+                    nameRotate: -90,
+                    nameTextStyle: {
+                        fontWeight: 'bold',
+                    },
+                    ...(display?.yAxis?.[1]?.format
+                        ? {
+                            axisLabel: {
+                                formatter: CartesianChartDataModel.getTooltipFormatter(display?.yAxis?.[1].format),
+                            },
+                        }
+                        : {}),
+                },
+            ],
+            dataset: {
+                id: 'dataset',
+                source: dataToRender, // Use transformed data for 100% stacking
+            },
+            series,
+        };
+        return spec;
+    }
+}
+//# sourceMappingURL=CartesianChartDataModel.js.map