@qrvey/utils 1.11.0 → 1.12.0-0-chart-v2-0

package/dist/cjs/charts/adapters/chartBuilderAdapter.js

@@ -0,0 +1,654 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrendsChartsConfig = exports.getPanelConfig = exports.fromV2ToV1 = exports.buildChartBodyV1 = void 0;
+const chartBuilder_1 = require("../helpers/chartBuilder");
+const chartBuilderParse_1 = require("./chartBuilderParse");
+/**
+ * The function `buildChartBodyV1` checks if the input body is already in version 2 format, and if not,
+ * converts it from version 2 to version 1.
+ * @param {any} body - The `body` parameter is of type `any`, which means it can be any data type.
+ * @returns either the original `body` if it has a property `v2`, or the result of calling the
+ * `fromV2ToV1` function with `body` as the argument and `false` as the second argument.
+ */
+function buildChartBodyV1(body) {
+    if (body.v2)
+        return body;
+    return fromV2ToV1(body, false);
+}
+exports.buildChartBodyV1 = buildChartBodyV1;
+/**
+ * The function `fromV2ToV1` converts a V2 chart object to a V1 chart object in TypeScript.
+ * @param {any} opts - The `opts` parameter is an object that contains various settings and
+ * configurations for a chart. It is optional and has a default value of an empty object `{}`.
+ * @param [inPreviewMode=true] - The `inPreviewMode` parameter is a boolean value that indicates
+ * whether the function is being called in preview mode or not. It is set to `true` by default.
+ * @returns the variable `data`.
+ */
+function fromV2ToV1(opts = {}, inPreviewMode = true) {
+    var _a, _b;
+    if (!(opts === null || opts === void 0 ? void 0 : opts.stylesSettings) ||
+        (((0, chartBuilder_1.isChartMetric)(opts.type) || (0, chartBuilder_1.isChartMinMax)(opts.type)) &&
+            (0, chartBuilder_1._isEmpty)(opts.dimensions.values))) {
+        return;
+    }
+    const objCopy = (0, chartBuilder_1._cloneDeep)(opts);
+    const chart_ms = [
+        "BAR_CHART_MS" /* CHART_TYPE.BAR_CHART_MS */,
+        "LINE_CHART_MS" /* CHART_TYPE.LINE_CHART_MS */,
+        "SYMBOL_CHART_MS" /* CHART_TYPE.SYMBOL_CHART_MS */,
+    ];
+    const chart_cb = [...chart_ms, "COMBO_CHART" /* CHART_TYPE.COMBO_CHART */];
+    const chart_base = [
+        "BAR_CHART" /* CHART_TYPE.BAR_CHART */,
+        "LINE_CHART" /* CHART_TYPE.LINE_CHART */,
+        "SYMBOL_CHART" /* CHART_TYPE.SYMBOL_CHART */,
+        "MINMAX_CHART" /* CHART_TYPE.MINMAX_CHART */,
+        "FUNNEL_CHART" /* CHART_TYPE.FUNNEL_CHART */,
+    ];
+    const bar_type = objCopy.stylesSettings.bar_type;
+    objCopy.bar_width = objCopy.stylesSettings.bar_width;
+    objCopy.isMulti = (0, chartBuilder_1.isChartMultiserie)(objCopy.type);
+    objCopy.isChartOptions = [...chart_base, ...chart_cb].includes(objCopy.type);
+    objCopy.isCombolayer = [
+        "COMBO_CHART" /* CHART_TYPE.COMBO_CHART */,
+        "COMBINED_CHART" /* CHART_TYPE.COMBINED_CHART */,
+    ].includes(objCopy.type);
+    objCopy.isReference = (0, chartBuilder_1.hasReferenceLayer)((_a = opts === null || opts === void 0 ? void 0 : opts.dimensions) === null || _a === void 0 ? void 0 : _a.reference);
+    objCopy.isTrend =
+        objCopy.type !== "MINMAX_CHART" /* CHART_TYPE.MINMAX_CHART */ &&
+            (0, chartBuilder_1.hasTrendLayer)((_b = opts === null || opts === void 0 ? void 0 : opts.dimensions) === null || _b === void 0 ? void 0 : _b.trend);
+    const isBarMs = objCopy.isMulti && objCopy.type === "BAR_CHART_MS" /* CHART_TYPE.BAR_CHART_MS */;
+    objCopy.is100 = isBarMs && bar_type === "h100" /* BAR_TYPE.FULL */;
+    objCopy.isCombo =
+        objCopy.isTrend ||
+            objCopy.isMulti ||
+            objCopy.isCombolayer ||
+            objCopy.isReference;
+    objCopy.isComboCalc = objCopy.isCombolayer;
+    objCopy.isStakedBar =
+        (isBarMs || objCopy.isCombo) &&
+            (objCopy.is100 || bar_type === "Stacked" /* BAR_TYPE.STACKED */) &&
+            objCopy.type !== "BAR_CHART" /* CHART_TYPE.BAR_CHART */;
+    objCopy.isSmallMultiples =
+        [...chart_base, ...chart_cb].includes(objCopy.type) &&
+            objCopy.type !== "FUNNEL_CHART" /* CHART_TYPE.FUNNEL_CHART */ &&
+            (0, chartBuilder_1.hasSmallMultiple)(opts.dimensions.smallmultiple);
+    const layerList = getLayerList(objCopy);
+    if (!layerList)
+        return;
+    const data = getPanelBodyByChart(objCopy.type, objCopy, layerList, inPreviewMode);
+    data.v2 = opts;
+    return data;
+}
+exports.fromV2ToV1 = fromV2ToV1;
+function getPanelBodyByChart(chart, obj, layerList, inPreviewMode) {
+    let panelBody = Object.assign(Object.assign({}, (0, chartBuilder_1._pick)(obj, [
+        "title",
+        "name",
+        "metricid",
+        "chartid",
+        "type",
+        "position",
+        "createDate",
+        "modifyDate",
+        "dataSet",
+        "isOldChart",
+        "isMulti",
+        "bar_width",
+        "isComboCalc",
+    ])), { globalSettings: getGlobalSettings(obj.type, obj), preFilters: obj.preFilters || [], defaultFilters: obj.defaultFilters || {}, oldInternalFilters: obj.oldInternalFilters, dateGroup: (0, chartBuilder_1._get)(layerList[0], "dateGroup"), timeGroup: (0, chartBuilder_1._get)(layerList[0], "timeGroup"), layerList });
+    panelBody.name = obj.name || obj.title; // Retro for metrics
+    panelBody.dataset = obj.dataset; // AT Retro
+    switch (chart) {
+        case "BOXWHISKER_CHART" /* CHART_TYPE.BOXWHISKER_CHART */:
+            panelBody.globalSettings.sortX = {
+                type: "Label" /* ACTION_SORT.LABEL */,
+                order: "Asc" /* ACTION_SORT_DIR.ASC */,
+            }; // remove when box and whishker support sorting by UI settings
+            break;
+        case "CROSSTAB_CHART" /* CHART_TYPE.CROSSTAB_CHART */:
+            panelBody = Object.assign(Object.assign({}, panelBody), { chart: getCrosstabConfig(obj) });
+            break;
+        case "EXPANDABLE_TABLE_CHART" /* CHART_TYPE.EXPANDABLE_TABLE_CHART */:
+        case "TABLE_CHART" /* CHART_TYPE.TABLE_CHART */: {
+            const isSimpleTable = !obj.dimensions["categories" /* CHART_DIMENSION.CATEGORIES */].length;
+            const attrMax = isSimpleTable
+                ? "globalSettings.max_rows.value"
+                : "globalSettings.max_groups.value";
+            const maxRecords = (0, chartBuilder_1._get)(obj, attrMax);
+            panelBody = Object.assign(Object.assign({}, panelBody), { globalSettings: Object.assign(Object.assign({}, panelBody.globalSettings), { maxRecords }), chart: getTableConfig(obj, inPreviewMode) });
+            break;
+        }
+        case "INDICATOR" /* CHART_TYPE.INDICATOR_METRIC */:
+        case "DIAL" /* CHART_TYPE.DIAL_METRIC */:
+        case "BULLET" /* CHART_TYPE.BULLET_METRIC */: {
+            const { comparison } = (0, chartBuilder_1._cloneDeep)(obj.dimensions);
+            panelBody = Object.assign(Object.assign(Object.assign({}, panelBody), { globalSettings: Object.assign(Object.assign({}, panelBody.globalSettings), { 
+                    // TODO: Rebase this implementation to refactor
+                    comparisonType: (0, chartBuilder_1._get)(comparison, "[0].comparison.type", "CHANGE" /* COMPARISON_TYPE.CHANGE */) }) }), getMetricConfigData(chart, obj));
+            break;
+        }
+        case "GEO_CHART_DOT" /* CHART_TYPE.GEO_CHART_DOT */:
+        case "GEO_CHART_BUBBLE" /* CHART_TYPE.GEO_CHART_BUBBLE */:
+        case "GEO_CHART_CHOROPLETH" /* CHART_TYPE.GEO_CHART_CHOROPLETH */:
+            panelBody = Object.assign(Object.assign({}, panelBody), { isSmallMultiples: obj.isSmallMultiples, chart: getGeoMapConfig(obj) });
+            break;
+        default:
+            panelBody = Object.assign(Object.assign({}, panelBody), { isChartOptions: true, isCombolayer: obj.isCombolayer, isReference: obj.isReference, isMulti: obj.isMulti, isCombo: obj.isCombo, isSmallMultiples: obj.isSmallMultiples, isTrend: obj.isTrend, is100: obj.is100, isStakedBar: obj.isStakedBar, isSplit: false });
+            break;
+    }
+    return panelBody;
+}
+function getPanelConfig(config = {}, opts = {}) {
+    return Object.assign(Object.assign({}, config), { type: getPanelType(opts.type), inBuilder: true, editable: true, panel: {
+            header: { visible: false },
+            body: { hasOverlay: false },
+        }, previewFilters: (0, chartBuilder_1._get)(config, "filterData.logic"), data: fromV2ToV1(Object.assign(Object.assign({}, opts), { appid: config.app_id || config.appid })) });
+}
+exports.getPanelConfig = getPanelConfig;
+function getPanelType(chart) {
+    return [
+        "INDICATOR" /* CHART_TYPE.INDICATOR_METRIC */,
+        "DIAL" /* CHART_TYPE.DIAL_METRIC */,
+        "BULLET" /* CHART_TYPE.BULLET_METRIC */,
+    ].includes(chart)
+        ? "METRIC"
+        : "CHART";
+}
+function getMetricConfigData(chart, obj) {
+    const { values, thresholds, comparison } = (0, chartBuilder_1._cloneDeep)(obj.dimensions);
+    let data = {
+        value: Object.assign(Object.assign({}, values[0]), { property: parsePropertyComplexData(values[0]) }),
+        dataSet: {},
+        valueAggregate: values[0] && values[0].aggregate,
+    };
+    if ((0, chartBuilder_1._get)(comparison, "[0]")) {
+        const dateColumn = Object.assign({}, comparison[0]);
+        const config = dateColumn.comparison;
+        delete dateColumn.comparison;
+        data = Object.assign(Object.assign({}, data), { dateColumn, timePeriod: chartBuilder_1.timePeriod.find((tp) => tp.label === config.time_period.value), comparison: chartBuilder_1.timePeriod.find((tp) => tp.label === config.time_comparison.value) });
+        if (config.time_period.value === "CUSTOM_RANGE" /* TIME_PERIOD.CUSTOM_RANGE */) {
+            data = Object.assign(Object.assign({}, data), { timePeriodCustomRange: chartBuilder_1.timePeriodCustomRange.find((tpc) => tpc.label === config.time_period.range), timePeriodDate: config.time_period.start, timePeriodEndDate: config.time_period.end });
+        }
+        if (config.time_comparison.value === "CUSTOM_RANGE" /* TIME_PERIOD.CUSTOM_RANGE */) {
+            data = Object.assign(Object.assign({}, data), { comparisonCustomRange: chartBuilder_1.timePeriodCustomRange.find((tpc) => tpc.label === config.time_comparison.range), comparisonDate: config.time_comparison.start, comparisonEndDate: config.time_comparison.end });
+        }
+    }
+    return {
+        appid: obj.appid,
+        type: { label: chart },
+        thresholdsList: thresholds === null || thresholds === void 0 ? void 0 : thresholds.map((thr) => ({
+            label: thr.custom_label || thr.label,
+            color: thr.color,
+            operator: { label: thr.operator },
+            value: thr.value,
+            initValue: thr.value,
+            endValue: thr.max_value,
+        })),
+        data,
+        individualSettings: (0, chartBuilderParse_1.parseStyleSettingByType)(chart, obj),
+        dataset: data.dataSet,
+    };
+}
+function getLayerList(opts) {
+    if (!isValidData(opts)) {
+        return;
+    }
+    const dimensions = (0, chartBuilder_1._cloneDeep)(opts.dimensions);
+    let list = [];
+    /** ******* Categort/Value based charts **********/
+    const category = getCategory(dimensions, opts);
+    const valueColumn = getValue(category, dimensions, opts);
+    const dateGroup = category && (0, chartBuilder_1.isColumnDate)(category) && category.dateGroup
+        ? category.dateGroup
+        : undefined;
+    const timeGroup = category && (0, chartBuilder_1.isTimeColumn)(category) && category.timeGroup
+        ? category.timeGroup
+        : undefined;
+    const scaleType = category &&
+        ((0, chartBuilder_1.isColumnDate)(category) || (0, chartBuilder_1.isTimeColumn)(category)) &&
+        category.scaleType
+        ? category.scaleType
+        : undefined;
+    const valueLayer = Object.assign(Object.assign({}, parseLayer(category, valueColumn, 0, opts)), parseAxisLabels(valueColumn, opts));
+    list = [valueLayer];
+    if (dateGroup) {
+        list[0] = Object.assign(Object.assign({}, list[0]), { dateGroup });
+    }
+    if (timeGroup) {
+        list[0] = Object.assign(Object.assign({}, list[0]), { timeGroup });
+    }
+    if (scaleType) {
+        list[0] = Object.assign(Object.assign({}, list[0]), { scaleType });
+    }
+    if (opts.isMulti) {
+        const seriesValue = dimensions.series.length
+            ? dimensions.series[0]
+            : valueColumn;
+        list[0].multiserie = {
+            maxDataPoints: (0, chartBuilder_1._get)(opts, "globalSettings.max_series_point.value", true),
+            maxNumDataPoints: (0, chartBuilder_1._get)(opts, "globalSettings.max_series_point.option", 50),
+            type: opts.stylesSettings.bar_type,
+            serie: Object.assign(Object.assign({}, seriesValue), { property: parsePropertyComplexData(seriesValue) }),
+        };
+    }
+    if (opts.isCombolayer) {
+        const dimensionProp = opts.type === "COMBINED_CHART" /* CHART_TYPE.COMBINED_CHART */ ? "values" : "series";
+        list = [
+            ...list,
+            ...getComboLayers(category, dimensions, opts, dimensionProp),
+        ];
+    }
+    if (opts.isTrend) {
+        list = [...list, getTrendLayer(dimensions.trend[0])];
+    }
+    if (opts.isSmallMultiples) {
+        list = [...list, getSmallMultipleLayer(dimensions.smallmultiple[0])];
+    }
+    if (opts.isReference) {
+        list = [...list, ...getReferenceLayers(dimensions.reference)];
+    }
+    if (opts.type === "HEATMAP_CHART" /* CHART_TYPE.HEATMAP_CHART */ && dimensions.pivots.length) {
+        list[0].pivot = Object.assign(Object.assign({}, dimensions.pivots[0]), { property: parsePropertyComplexData(dimensions.pivots[0]) });
+        list[0].pivotLabel = (0, chartBuilder_1._get)(opts.stylesSettings, "pivot_axis.custom_label");
+    }
+    if (opts.type === "TABLE_CHART" /* CHART_TYPE.TABLE_CHART */ ||
+        opts.type === "EXPANDABLE_TABLE_CHART" /* CHART_TYPE.EXPANDABLE_TABLE_CHART */ ||
+        opts.type === "CROSSTAB_CHART" /* CHART_TYPE.CROSSTAB_CHART */) {
+        list = [{ type: opts.type }];
+    }
+    if (opts.type === "BOXWHISKER_CHART" /* CHART_TYPE.BOXWHISKER_CHART */ && dimensions.pivots.length) {
+        list[0].distribution = Object.assign(Object.assign({}, dimensions.pivots[0]), { property: parsePropertyComplexData(dimensions.pivots[0]) });
+    }
+    if (opts.type === "GEO_CHART_BUBBLE" /* CHART_TYPE.GEO_CHART_BUBBLE */) {
+        list[0].mapType = { label: "BUBBLE" };
+    }
+    if (opts.type === "GEO_CHART_DOT" /* CHART_TYPE.GEO_CHART_DOT */) {
+        list[0].mapType = { label: "DOT" };
+        list[0].value = Object.assign(Object.assign({}, list[0].category), { property: parsePropertyComplexData(list[0].category) }); // fix https://qrveydev.atlassian.net/browse/CB-689
+    }
+    if (opts.type === "GEO_CHART_CHOROPLETH" /* CHART_TYPE.GEO_CHART_CHOROPLETH */) {
+        list[0].mapType = { label: "CHOROPLETH" };
+    }
+    /** ******* Tabular/multicolum based charts **********/
+    // logic here
+    return list;
+}
+function parseAxisLabels(valueColumn, opts) {
+    const Y_AXIS_ATTR = "y_axis.custom_label";
+    const X_AXIS_ATTR = "x_axis.custom_label";
+    const axisLabels = {
+        chartValuLabelTemp: (0, chartBuilder_1._get)(opts.stylesSettings, Y_AXIS_ATTR),
+        chartLabelTemp: (0, chartBuilder_1._get)(opts.stylesSettings, X_AXIS_ATTR),
+    };
+    if (opts.type === "COMBO_CHART" /* CHART_TYPE.COMBO_CHART */ ||
+        opts.type === "COMBINED_CHART" /* CHART_TYPE.COMBINED_CHART */) {
+        const valueStyleObj = opts.isCombolayer
+            ? valueColumn.comboLayer
+            : opts.stylesSettings;
+        if (opts.type === "COMBO_CHART" /* CHART_TYPE.COMBO_CHART */)
+            axisLabels.chartValuLabelTemp = (0, chartBuilder_1._get)(valueStyleObj, Y_AXIS_ATTR);
+    }
+    return axisLabels;
+}
+function parseLayer(category, value, index, opts) {
+    const isCombinedMainLayer = opts.type === "COMBINED_CHART" /* CHART_TYPE.COMBINED_CHART */ && index === 0;
+    const isCombinedOtherLayer = opts.type === "COMBINED_CHART" /* CHART_TYPE.COMBINED_CHART */ && index > 0;
+    const layerType = isCombinedMainLayer
+        ? (0, chartBuilder_1._get)(opts, "stylesSettings.combined_type")
+        : opts.type === "COMBO_CHART" /* CHART_TYPE.COMBO_CHART */ && opts.isStakedBar
+            ? "BAR_CHART" /* CHART_TYPE.BAR_CHART */
+            : (0, chartBuilder_1._get)(value, "comboLayer.layer_type");
+    const getOptions = () => isCombinedMainLayer
+        ? (0, chartBuilder_1._get)(opts, "stylesSettings")
+        : (0, chartBuilder_1._get)(value, "comboLayer");
+    const visualizationType = opts.type === "COMBINED_CHART" /* CHART_TYPE.COMBINED_CHART */
+        ? isCombinedMainLayer
+            ? layerType
+            : "COMBO_CHART"
+        : opts.type;
+    return {
+        category: Object.assign(Object.assign({}, category), { property: parsePropertyComplexData(category) }),
+        value: Object.assign(Object.assign({}, value), { property: parsePropertyComplexData(value), calculation: (0, chartBuilder_1.allowTableCalculation)(opts.type) &&
+                parseCalculation(value, opts, isCombinedOtherLayer) }),
+        aggregate: value ? value.aggregate : { label: "COUNT" },
+        type: getOldChartType(opts.type, opts.previousType, layerType),
+        visualization: (0, chartBuilderParse_1.parseStyleSettingByType)(visualizationType, opts, getOptions()),
+        property: parsePropertyComplexData(category),
+        index,
+    };
+}
+function parsePropertyComplexData(column) {
+    return (0, chartBuilder_1._get)(column, "property.value", null);
+}
+function parseCalculation(column = {}, chart, ignoreReset = false) {
+    const reset = getResetCalculation(column, chart, ignoreReset);
+    return (column.calculation && {
+        aggregate: (0, chartBuilder_1._get)(column, "calculation.value", "SUM"),
+        abbreviation: (0, chartBuilder_1._get)(column, "calculation.abbreviation"),
+        reset,
+        direction: chart.isMulti && !ignoreReset ? "vertical" : null,
+    });
+}
+function getResetCalculation(column = {}, chart, ignoreReset = false) {
+    if (chart &&
+        ((chart.type === "HEATMAP_CHART" /* CHART_TYPE.HEATMAP_CHART */ &&
+            chart.dimensions.pivots.length) ||
+            chart.isSmallMultiples ||
+            (chart.isMulti && !ignoreReset)))
+        return 0;
+    if (column.calculation &&
+        chart &&
+        (chart.type === "TABLE_CHART" /* CHART_TYPE.TABLE_CHART */ ||
+            chart.type === "EXPANDABLE_TABLE_CHART" /* CHART_TYPE.EXPANDABLE_TABLE_CHART */))
+        return chart.dimensions.categories.length > 1 &&
+            column.calculation.levels &&
+            column.calculation.levels.id !== "TABLE"
+            ? column.calculation.levels.colIndex
+            : null;
+    return null;
+}
+function parseSortOrder(chartType, column = {}) {
+    const sortDirection = column.sortOrder || typeof column.sorting !== "string"
+        ? (0, chartBuilder_1._get)(column, "sorting.order")
+        : column.sorting;
+    if (chartType === "CROSSTAB_CHART" /* CHART_TYPE.CROSSTAB_CHART */) {
+        // parse from simple string sorting-option to Crosstab (dateGroup) sorting-option object
+        const isDategroupSortOpt = typeof sortDirection === "string" && column.dateGroup;
+        return Object.assign(Object.assign({}, (typeof column.sorting !== "string" ? column.sorting : {})), { order: isDategroupSortOpt
+                ? {
+                    [column.dateGroup.text]: sortDirection || "asc",
+                }
+                : sortDirection });
+    }
+    // parse from Crosstab (dateGroup) sorting-option object to simple string sortion-option
+    const isDategroupSortOpt = column.dateGroup && typeof sortDirection !== "string";
+    return Object.assign(Object.assign({}, (typeof column.sorting !== "string" ? column.sorting : {})), { order: isDategroupSortOpt
+            ? sortDirection && (0, chartBuilder_1._get)(column, `sorting.order.${column.dateGroup.text}`)
+            : sortDirection });
+}
+function getValue(category, dimensions, opts) {
+    if (opts.type === "BOXWHISKER_CHART" /* CHART_TYPE.BOXWHISKER_CHART */ ||
+        opts.type === "MINMAX_CHART" /* CHART_TYPE.MINMAX_CHART */)
+        return dimensions.values[0];
+    const value = dimensions.values[0] || category;
+    return getColumnFromDimension(value, dimensions, opts);
+}
+function getCategory(dimensions, opts) {
+    if (opts.type === "BOXWHISKER_CHART" /* CHART_TYPE.BOXWHISKER_CHART */ ||
+        opts.type === "MINMAX_CHART" /* CHART_TYPE.MINMAX_CHART */)
+        return dimensions.categories[0];
+    if ([
+        "GEO_CHART_DOT" /* CHART_TYPE.GEO_CHART_DOT */,
+        "GEO_CHART_BUBBLE" /* CHART_TYPE.GEO_CHART_BUBBLE */,
+        "GEO_CHART_CHOROPLETH" /* CHART_TYPE.GEO_CHART_CHOROPLETH */,
+    ].includes(opts.type))
+        return dimensions.categories[0];
+    const category = (0, chartBuilder_1._get)(dimensions, "categories[0]") || dimensions.values[0];
+    if (category && category.calculation)
+        delete category.calculation;
+    return getColumnFromDimension(category, dimensions, opts);
+}
+function getColumnFromDimension(column, dimensions, { isCombolayer, isMulti }) {
+    let _column = column;
+    if (_column) {
+        return _column;
+    }
+    if (isCombolayer || isMulti) {
+        _column = dimensions.series[0];
+        if (!isMulti) {
+            dimensions.series.shift();
+        }
+    }
+    return _column;
+}
+function getComboLayers(category, dimensions, opts, prop) {
+    const comboLayers = (0, chartBuilder_1._isEmpty)(dimensions[prop]) ? [] : [...dimensions[prop]];
+    if (opts.type === "COMBINED_CHART" /* CHART_TYPE.COMBINED_CHART */)
+        comboLayers.shift();
+    return comboLayers.map((value, index) => {
+        return Object.assign(Object.assign({}, parseLayer(category, value, index + 1, opts)), { layer: { label: (0, chartBuilder_1._get)(value, "comboLayer.layer_type") }, label: (0, chartBuilder_1._get)(value, "comboLayer.y_axis.custom_label", value.text), combopt: { label: "COMBO" }, axis: { label: (0, chartBuilder_1._get)(value, "comboLayer.y_axis.position") } });
+    });
+}
+function getTrendLayer(trend) {
+    return {
+        visualization: {
+            thickness: trend.thickness,
+            style: trend.line_style,
+            color: trend.color,
+        },
+        trendtype: { label: trend.type },
+        combopt: { label: "TREND" },
+    };
+}
+function getReferenceLayers(references) {
+    return references.map((ref) => ({
+        index: Date.now(),
+        axis: Object.assign(Object.assign({}, ref.axis), { property: parsePropertyComplexData(ref.axis) }),
+        aggregate: { label: ref.aggregate },
+        labelType: { label: !ref.custom_label ? "VALUE" : "CUSTOM" },
+        combopt: { label: "REFERENCE" },
+        label: ref.custom_label,
+        value: ref.value,
+        valuetype: ref.type,
+        visualization: {
+            color: ref.color,
+            fill: ref.fill,
+            thickness: ref.thickness,
+            style: ref.line_style,
+            opacity: ref.opacity,
+        },
+    }));
+}
+function getSmallMultipleLayer(column) {
+    return {
+        visualization: {
+            displayBorder: column.smallMultiple.borders,
+            maxMultiplePanels: column.smallMultiple.limit.value,
+            displayMultiplePanels: column.smallMultiple.limit.active,
+            labels: {
+                axis: column.smallMultiple.labels,
+            },
+        },
+        combopt: { label: "SMALL_MULTIPLES" },
+        smallMultiplesColumn: Object.assign(Object.assign({}, column), { property: parsePropertyComplexData(column) }),
+        groupValue: Object.assign({}, column.dateGroup), // Group Value is needed in old chart editor and an-panel. Best practice is to use dateGroup from column object
+    };
+}
+function getTrendsChartsConfig(trendInfo) {
+    trendInfo.trendByColumn.sorting = {
+        order: trendInfo.trendSort === "Asc" ? "asc" : "desc",
+    };
+    const opts = {
+        type: trendInfo.charType,
+        dimensions: {
+            categories: [trendInfo.trendByColumn],
+            pivots: [],
+            values: [trendInfo.column],
+        },
+    };
+    return getTableConfig(opts, true, true);
+}
+exports.getTrendsChartsConfig = getTrendsChartsConfig;
+function getTableConfig(opts, inPreviewMode, isTrendChart = false) {
+    const fields = {};
+    const params = [
+        { objKey: "categories", fieldKey: "groupsList", type: "group" },
+        { objKey: "values", fieldKey: "columnsList", type: "column" },
+    ];
+    let count = 0;
+    params.forEach((param) => {
+        if (opts.dimensions[param.objKey].length) {
+            fields[param.fieldKey] = opts.dimensions[param.objKey].map((item) => {
+                const column = {
+                    data: Object.assign(Object.assign({}, item), { property: parsePropertyComplexData(item) }),
+                    index: new Date().getTime() + (0, chartBuilder_1.randomKey)(),
+                    type: param.type,
+                    label: item.label || item.text,
+                    visualization: item.visualization || "Values",
+                    aggregate: setTotalAggregateInPreview(item.totalAggregate, inPreviewMode),
+                    calculation: opts.dimensions.categories.length
+                        ? parseCalculation(item, opts)
+                        : null,
+                    dataField: (0, chartBuilder_1.columnKey)(item.id, item.type, item.property, count + 1),
+                    qrveyid: item.qrveyid,
+                    dateGroup: item.dateGroup,
+                    sorting: parseSortOrder(opts.type, item),
+                    sortIndex: item.sortIndex,
+                    width: item.width,
+                };
+                if (item.aggregate)
+                    column.groupAggregate = Object.assign({}, item.aggregate);
+                count += 1;
+                return column;
+            });
+        }
+    });
+    if (isTrendChart)
+        return { fields };
+    const isGrouped = fields.groupsList && !!fields.groupsList.length;
+    return {
+        fields,
+        isGrouped,
+        conditions: opts.conditions,
+        visualization: (0, chartBuilderParse_1.parseStyleSettingByType)("TABLE_CHART" /* CHART_TYPE.TABLE_CHART */, Object.assign(Object.assign({}, opts), { isGrouped })),
+        totals: opts.dimensions.tableTotals,
+        isMultipleSorted: opts.isMultipleSorted,
+        trendsChart: opts.trendsCharts || [],
+    };
+}
+function getCrosstabConfig(opts) {
+    const fields = {};
+    const params = [
+        { objKey: "pivots", fieldKey: "columnsList", type: "column" },
+        { objKey: "categories", fieldKey: "rowsList", type: "row" },
+        { objKey: "values", fieldKey: "valuesList", type: "data" },
+    ];
+    params.forEach((param) => {
+        const dimension = param.objKey === "values" && !opts.dimensions[param.objKey].length
+            ? [opts.dimensions.categories[0] || opts.dimensions.pivots[0]]
+            : opts.dimensions[param.objKey];
+        fields[param.fieldKey] = dimension.map((item) => {
+            const column = {
+                data: Object.assign(Object.assign({}, item), { property: parsePropertyComplexData(item) }),
+                index: new Date().getTime() + (0, chartBuilder_1.randomKey)(),
+                type: param.type,
+                qrveyid: item.qrveyid,
+                label: item.label || item.text,
+                sorting: parseSortOrder(opts.type, item),
+            };
+            if (item.dateGroup)
+                column.dateGroup = item.dateGroup;
+            if (item.aggregate && param.type === "data")
+                column.aggregate = Object.assign({}, item.aggregate);
+            return column;
+        });
+    });
+    const rowGrandTotals = [
+        "SHOW" /* CROSSTAB_TOTALS_OPTIONS.BOTH */,
+        "ROWSONLY" /* CROSSTAB_TOTALS_OPTIONS.ROWS */,
+    ].includes(opts.globalSettings.crosstab_totals.option);
+    const columnGrandTotals = [
+        "SHOW" /* CROSSTAB_TOTALS_OPTIONS.BOTH */,
+        "COLUMNSONLY" /* CROSSTAB_TOTALS_OPTIONS.COLUMNS */,
+    ].includes(opts.globalSettings.crosstab_totals.option);
+    return {
+        fields,
+        visualization: (0, chartBuilderParse_1.parseStyleSettingByType)("CROSSTAB_CHART" /* CHART_TYPE.CROSSTAB_CHART */, opts),
+        config: {
+            showBorders: false,
+            width: 442,
+            height: 361,
+            fieldChooser: { enabled: false },
+            fieldPanel: {
+                visible: opts.globalSettings.crosstab_labels.value,
+                showFilterFields: false,
+                allowFieldDragging: false,
+                showColumnFields: true,
+                showRowFields: true,
+                showDataFields: false,
+                texts: { columnFieldArea: "", rowFieldArea: "" },
+            },
+            rowHeaderLayout: "tree",
+            showRowGrandTotals: opts.globalSettings.crosstab_totals.value && rowGrandTotals,
+            showColumnGrandTotals: opts.globalSettings.crosstab_totals.value && columnGrandTotals,
+            showRowTotals: opts.globalSettings.crosstab_subtotals,
+            showColumnTotals: opts.globalSettings.crosstab_subtotals,
+            allowSorting: opts.globalSettings.crosstab_labels.options.sorting,
+            allowSortingBySummary: false,
+        },
+    };
+}
+function getGeoMapConfig(opts) {
+    const fields = {};
+    const params = [
+        { objKey: "categories", fieldKey: "categories", type: "column" },
+        { objKey: "values", fieldKey: "values", type: "column" },
+    ];
+    params.forEach((param) => {
+        if (opts.dimensions[param.objKey].length) {
+            fields[param.fieldKey] = opts.dimensions[param.objKey].map((item) => {
+                const column = {
+                    data: Object.assign(Object.assign({}, item), { property: parsePropertyComplexData(item) }),
+                    index: new Date().getTime() + (0, chartBuilder_1.randomKey)(),
+                    type: param.type,
+                    qrveyid: item.qrveyid,
+                };
+                if (item.aggregate && param.type === "data")
+                    column.aggregate = Object.assign({}, item.aggregate);
+                return column;
+            });
+        }
+    });
+    return {
+        fields,
+    };
+}
+function isValidData(opts) {
+    let chartDimensions = [
+        "categories" /* CHART_DIMENSION.CATEGORIES */,
+        "values" /* CHART_DIMENSION.VALUES */,
+    ];
+    if (opts.isCombo) {
+        chartDimensions = [...chartDimensions, "series" /* CHART_DIMENSION.SERIES */];
+    }
+    if ([
+        "GEO_CHART_DOT" /* CHART_TYPE.GEO_CHART_DOT */,
+        "GEO_CHART_BUBBLE" /* CHART_TYPE.GEO_CHART_BUBBLE */,
+        "GEO_CHART_CHOROPLETH" /* CHART_TYPE.GEO_CHART_CHOROPLETH */,
+    ].includes(opts.type)) {
+        return !(0, chartBuilder_1._isEmpty)(opts.dimensions["categories" /* CHART_DIMENSION.CATEGORIES */]);
+    }
+    if (opts.type === "CROSSTAB_CHART" /* CHART_TYPE.CROSSTAB_CHART */)
+        chartDimensions = [...chartDimensions, "pivots" /* CHART_DIMENSION.PIVOT */];
+    return chartDimensions.some((dimension) => !(0, chartBuilder_1._isEmpty)(opts.dimensions[dimension]));
+}
+function getOldChartType(type, prevType, layerType) {
+    let chartType = type;
+    if (chartType === "COMBO_CHART" /* CHART_TYPE.COMBO_CHART */ ||
+        chartType === "COMBINED_CHART" /* CHART_TYPE.COMBINED_CHART */) {
+        chartType =
+            layerType || ((0, chartBuilder_1.isChartBasic)(prevType) ? prevType : "BAR_CHART" /* CHART_TYPE.BAR_CHART */);
+    }
+    if (chartType === "BAR_CHART_MS" /* CHART_TYPE.BAR_CHART_MS */) {
+        chartType = "BAR_CHART" /* CHART_TYPE.BAR_CHART */;
+    }
+    if (chartType === "LINE_CHART_MS" /* CHART_TYPE.LINE_CHART_MS */) {
+        chartType = "LINE_CHART" /* CHART_TYPE.LINE_CHART */;
+    }
+    if (chartType === "SYMBOL_CHART_MS" /* CHART_TYPE.SYMBOL_CHART_MS */) {
+        chartType = "SYMBOL_CHART" /* CHART_TYPE.SYMBOL_CHART */;
+    }
+    if ((0, chartBuilder_1.isChartMap)(type)) {
+        chartType = "GEO_CHART" /* CHART_TYPE.GEO_CHART */;
+    }
+    return chartType;
+}
+function getGlobalSettings(_chartType, opts) {
+    return (0, chartBuilderParse_1.parseGlobalSettingByType)(_chartType, opts);
+}
+function setTotalAggregateInPreview(totalAggregate, _inPreviewMode) {
+    if (!totalAggregate)
+        return;
+    return totalAggregate;
+}