@qrvey/utils 1.5.0-2 → 1.5.0-5

package/dist/charts/adapters/endpointDataGet.js

@@ -0,0 +1,428 @@
+import { COLUMN, isNumericalColumn } from "../../columns";
+import { FILTER_OPERATOR, } from "../../filters";
+import { cloneDeep, isEmpty, _get } from "../../general";
+import { isColumnDate } from "./endpointDataValidators";
+export function getDrilldownId(ctx, data) {
+    return !ctx.config.isFromAN
+        ? ctx.config.id || data.chartid || data.chart_id
+        : data.chartid || data.chart_id;
+}
+export function getPivotBody(layer, body) {
+    const value = _get(layer, "value");
+    const pivot = _get(layer, "pivot", _get(layer, "multiserie.serie"));
+    const type = _get(layer, "type", "");
+    let obj;
+    if ((type === "HEATMAP_CHART" || !_get(body, "isDrillDown")) && pivot) {
+        const uSorting = _get(pivot, "sorting");
+        const sorting = _get(body, "globalSettings.sortX", {});
+        let pSortOption = {
+            sortBy: uSorting || getValidSortingType(body) === "Label"
+                ? "CATEGORY"
+                : "VALUE",
+            sortDirection: ((uSorting && uSorting.order) ||
+                sorting.order ||
+                "ASC").toUpperCase(),
+        };
+        /** TODO: Remove line on  implement universal sorting on Heatmap */
+        pSortOption =
+            value && value.calculation
+                ? { sortBy: "CATEGORY", sortDirection: "ASC" }
+                : pSortOption;
+        const maxDataPoints = pivot.type !== "DATE"
+            ? _get(layer, "multiserie.maxDataPoints")
+                ? _get(layer, "multiserie.maxNumDataPoints", 50)
+                : undefined
+            : 50;
+        obj = {
+            linkid: pivot.linkid,
+            maxDataPoints: maxDataPoints,
+            property: pivot.property,
+            qrveyid: pivot.qrveyid || body.qrveyid,
+            questionid: pivot.id || pivot.bucketId,
+            sortOption: pSortOption,
+            type: pivot.type,
+        };
+        setDateGroup(pivot, pivot, obj);
+    }
+    return obj;
+}
+export function getValidSortingType(body) {
+    const sorting = _get(body, "globalSettings.sortX", {});
+    const type = _get(body, "layerList[0].type");
+    const notAllowValue = type === "HEATMAP_CHART" && _get(body, "layerList[0].pivot");
+    return !sorting.type || sorting.type == "Label" || notAllowValue
+        ? "Label"
+        : "Value";
+}
+export function getCategoryBody(layer, body) {
+    var _a;
+    const maxDataPoints = _get(body, "globalSettings.maxNumDataPoints");
+    const category = _get(layer, "category");
+    if (category && category.bucketId)
+        category.id = category.bucketId;
+    const categoryId = category ? category.id : null;
+    const sorting = _get(body, "globalSettings.sortX", {});
+    const pSortOption = {
+        sortBy: ((_a = sorting === null || sorting === void 0 ? void 0 : sorting.column) === null || _a === void 0 ? void 0 : _a.isHidden)
+            ? "VALUE"
+            : getValidSortingType(body) === "Label"
+                ? "CATEGORY"
+                : "VALUE",
+        sortDirection: (sorting.order || "ASC").toUpperCase(),
+        order: getSortOrder(sorting, category, body),
+    };
+    let obj;
+    if (categoryId) {
+        obj = {
+            questionid: category.id,
+            linkid: category.linkid,
+            maxDataPoints,
+            property: category.property,
+            qrveyid: category.qrveyid || body.qrveyid,
+            type: category.type || body.type,
+            sortOption: isNumericalColumn(category) &&
+                _get(category, "scaleType.value") === "CONTINUOUS"
+                ? undefined
+                : pSortOption,
+        };
+        setDateGroup(category, body, obj);
+    }
+    return obj;
+}
+export function getComboBody(layer, body, filters, newModel = false) {
+    const obj = {};
+    try {
+        const category = getCategoryBody(_get(body, "layerList[0]"), body);
+        const pSmallMultiple = getSmallMultipleBody(body.layerList.find((ly) => _get(ly, "combopt.label") === "SMALL_MULTIPLES"), body);
+        if (newModel) {
+            obj.dimensions = [];
+            if (pSmallMultiple)
+                obj.dimensions.push(pSmallMultiple);
+            obj.dimensions.push(category);
+        }
+        else {
+            obj.category = category;
+        }
+        obj.summaries = getSummariesBody(layer, body);
+        obj.aggFilters = getAggFiltersResults(filters, obj.summaries);
+    }
+    catch (error) {
+        console.error(error);
+    }
+    return obj;
+}
+export function getSmallMultipleBody(layer, body) {
+    if (!layer)
+        return null;
+    const category = _get(layer, "smallMultiplesColumn");
+    const maxDataPoints = !isColumnDate(category)
+        ? _get(layer, "visualization.maxMultiplePanels", undefined)
+        : undefined;
+    if (category && category.bucketId)
+        category.id = category.bucketId;
+    const categoryId = category ? category.id : null;
+    let obj;
+    if (categoryId) {
+        obj = {
+            questionid: category.id,
+            linkid: category.linkid,
+            maxDataPoints: maxDataPoints,
+            property: category.property,
+            qrveyid: category.qrveyid || body.qrveyid,
+            type: category.type || body.type,
+        };
+        if (isNumericalColumn(category))
+            obj.numberAsRange = true;
+        setDateGroup(category, category, obj);
+    }
+    return obj;
+}
+export function getAggFiltersResults(logics = [], summaries = []) {
+    function concatAggFilters(aggFilters, operator = FILTER_OPERATOR.AND) {
+        const expressions = aggFilters.filter(Boolean);
+        if (!expressions.length)
+            return undefined;
+        else if (expressions.length === 1)
+            return expressions[0];
+        return {
+            operator,
+            expressions: aggFilters.filter(Boolean),
+        };
+    }
+    function getExpressionsInLogic(logicsData = []) {
+        return logicsData.reduce((expressions, logic) => {
+            logic.filters.forEach((filter) => {
+                expressions = expressions.concat(filter.expressions[0].expressions);
+            });
+            return expressions;
+        }, []);
+    }
+    function getAggregateFilters(logicsData = []) {
+        logicsData = cloneDeep(logicsData);
+        const aggregateLogics = logicsData.reduce((newLogics, logic) => {
+            if (!logic)
+                return newLogics;
+            // if ([FILTER_SCOPE.DEFAULT, FILTER_SCOPE.CHART].includes(logic.scope)) {
+            logic.filters.forEach((filter, index) => {
+                const expressions = _get(filter, "expressions[0].expressions");
+                if (!isEmpty(expressions)) {
+                    const aggregateFilters = filter.expressions[0].expressions.filter((expression) => !isEmpty(expression.uiExtras.column.aggregate));
+                    logic.filters[index].expressions[0].expressions = aggregateFilters;
+                    if (!filter.expressions[0].expressions.length)
+                        logic.filters[index] = undefined;
+                }
+            });
+            logic.filters = logic.filters.filter((filter) => filter);
+            if (logic.filters.length)
+                newLogics.push(logic);
+            //}
+            return newLogics;
+        }, []);
+        return aggregateLogics;
+    }
+    const aggregateFilters = getAggregateFilters(logics);
+    const aggFilters = aggregateFilters
+        .map((aggFilter) => {
+        const expressions = getExpressionsInLogic([aggFilter]);
+        return (expressions &&
+            expressions.length && {
+            operator: FILTER_OPERATOR.OR,
+            expressions: expressions
+                .map((expression) => {
+                const summaryIndex = summaries.findIndex((summary) => expression.questionid === summary.questionid &&
+                    expression.qrveyid === summary.qrveyid &&
+                    expression.linkid === summary.linkid &&
+                    _get(expression.uiExtras.column, "aggregate") ===
+                        summary.aggregate);
+                if (summaryIndex > -1 ||
+                    expression.questionType === COLUMN.AGGREGATED_FORMULA) {
+                    return {
+                        enabled: expression.enabled,
+                        summaryIndex,
+                        validationType: expression.validationType,
+                        value: expression.value,
+                    };
+                }
+                return;
+            })
+                .filter(Boolean),
+        });
+    })
+        .filter((aggFilter) => aggFilter && aggFilter.expressions && aggFilter.expressions.length);
+    return aggFilters && concatAggFilters(aggFilters);
+}
+export function getRefenceBody(layer) {
+    let obj;
+    try {
+        obj = {
+            type: "REFERENCE_LINE",
+            referenceType: layer.valuetype,
+            referenceValue: layer.value,
+            valueId: _get(layer, "axis.id"),
+            aggregate: _get(layer, "aggregate.label"),
+            value: {
+                questionid: _get(layer, "axis.id"),
+                qrveyid: _get(layer, "axis.qrveyid"),
+                linkid: _get(layer, "axis.linkid"),
+                property: _get(layer, "axis.property"),
+                type: _get(layer, "axis.type", _get(layer, "axis.label")),
+            },
+        };
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return obj;
+}
+export function getTrendBody(layer) {
+    let obj;
+    try {
+        obj = {
+            type: "TREND_LINE",
+            trendType: layer.trendtype.label,
+        };
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return obj;
+}
+export function getRefenceBodyU(layer, body) {
+    let obj;
+    const layerType = layer.valuetype === "Fixed";
+    const pSmallMultiple = getSmallMultipleBody(body.layerList.find((ly) => _get(ly, "combopt.label") === "SMALL_MULTIPLES"), body);
+    if (!layerType) {
+        obj = {
+            summaries: [
+                {
+                    aggregate: _get(layer, "aggregate.label"),
+                    linkid: _get(layer, "axis.linkid"),
+                    property: _get(layer, "axis.property"),
+                    qrveyid: _get(layer, "axis.qrveyid") || body.qrveyid,
+                    questionid: _get(layer, "axis.id"),
+                    type: _get(layer, "axis.type", _get(layer, "axis.label")),
+                },
+            ],
+        };
+        if (pSmallMultiple)
+            obj.dimensions = [pSmallMultiple];
+    }
+    else {
+        obj = { type: "REFERENCE_LINE" };
+    }
+    return obj;
+}
+export function getLayerBody(layer, dateGroup, qrveyid) {
+    let obj;
+    try {
+        if (_get(layer, "mapType.label") == "DOT")
+            obj = {};
+        // eslint-disable-next-line no-extra-boolean-cast
+        else if (!!~["BOXWHISKER_CHART", "WORD_CLOUD"].indexOf(layer.type)) {
+            obj = {
+                valueId: _get(layer, "value.id"),
+                aggregate: _get(layer, "aggregate.label"),
+            };
+        }
+        else {
+            obj = {
+                valueId: layer.value.id,
+                aggregate: layer.aggregate.label,
+            };
+        }
+        obj.type =
+            layer.type || _get(layer, "layer.label", _get(layer, "combopt.label"));
+        obj.property = layer.property;
+        if (layer.value)
+            obj.value = {
+                questionid: layer.value.id,
+                type: layer.value.type,
+                qrveyid: layer.value.qrveyid,
+                linkid: layer.value.linkid,
+                property: layer.value.property,
+            };
+        if (layer.mapType)
+            obj.mapType = layer.mapType.label;
+        if (layer.multiserie && layer.multiserie.serie) {
+            if (layer.multiserie.serie.type === "BUCKET") {
+                obj.multiValueId = layer.multiserie.serie.bucketId; //required
+                obj.multiValueType = "BUCKET";
+            }
+            else {
+                obj.multiValueId = layer.multiserie.serie.id; //required
+                obj.multiValueType = undefined;
+            }
+            obj.isMulti = true;
+            obj.multiValueAxis = {
+                questionid: layer.multiserie.serie.id,
+                groupType: _get(layer, "multiserie.type"),
+                questionType: _get(layer, "multiserie.serie.type"),
+                type: _get(layer, "multiserie.serie.type"),
+                groupValue: _get(layer, "multiserie.dateGroup.label"),
+                property: _get(layer, "multiserie.serie.property"),
+                qrveyid: _get(layer, "multiserie.serie.qrveyid"),
+                linkid: _get(layer, "multiserie.serie.linkid"),
+            };
+            if (_get(layer, "multiserie.maxDataPoints", false))
+                obj.multiValueAxis.maxDataPoints = _get(layer, "multiserie.maxNumDataPoints", 50);
+        }
+        if (dateGroup && dateGroup.label) {
+            obj.groupType = "DATE";
+            obj.groupValue = dateGroup.label;
+        }
+        if (layer.pivot) {
+            obj.pivot = {};
+            obj.pivot.qrveyid = _get(layer, "pivot.qrveyid", qrveyid);
+            obj.pivot.linkid = _get(layer, "pivot.linkid");
+            obj.pivot.groupType = _get(layer, "pivot.type");
+            obj.pivot.type = _get(layer, "pivot.type");
+            const labelBucketId = _get(layer, "pivot.bucketId", null);
+            if (labelBucketId !== null) {
+                obj.pivot.labelBucketId = labelBucketId;
+            }
+            else {
+                obj.pivot.questionid = _get(layer, "pivot.id");
+            }
+            obj.pivot.groupValue = _get(layer, "pivot.dateGroup.label");
+            obj.pivot.property = _get(layer, "pivot.property");
+        }
+    }
+    catch (error) {
+        console.error(error);
+    }
+    return obj;
+}
+function getSortOrder(sorting = {}, category = {}, body = {}) {
+    var _a;
+    const order = (sorting.order || "ASC").toUpperCase();
+    const column = sorting.column || {};
+    const aggregate = (_a = body.globalSettings) === null || _a === void 0 ? void 0 : _a.sortAggregation;
+    return column.isHidden
+        ? [
+            {
+                hidden: true,
+                type: column.type,
+                sortDirection: order,
+                questionid: column.id,
+                qrveyid: column.qrveyid,
+                aggregate: aggregate === null || aggregate === void 0 ? void 0 : aggregate.label,
+                property: column.property || category.property,
+            },
+        ]
+        : [
+            {
+                summaryIndex: 0,
+                sortDirection: order,
+            },
+        ];
+}
+export function setDateGroup(column, body, obj) {
+    if (isColumnDate(column) && !isEmpty(_get(body, "dateGroup.label"))) {
+        obj["groupType"] = COLUMN.DATE;
+        obj["groupValue"] = body.dateGroup.label;
+        if (_get(body, "dateGroup.datePart", false)) {
+            obj["maxDataPoints"] = obj["maxDataPoints"] || 60;
+        }
+    }
+}
+export function getSummariesBody(layer, body) {
+    let value = _get(layer, "value");
+    let aggregate = _get(layer, "aggregate");
+    if (layer.type === "WORD_CLOUD" && !value)
+        value = _get(layer, "category");
+    if (layer.type === "WORD_CLOUD" && !aggregate)
+        aggregate = { label: "COUNT", text: "Count" };
+    let obj;
+    if (layer.type === "MINMAX_CHART" && value) {
+        const min = aggregateGenerator("MIN", value.linkid, value.property, value.qrveyid || body.qrveyid, value.id, value.type);
+        const max = aggregateGenerator("MAX", value.linkid, value.property, value.qrveyid || body.qrveyid, value.id, value.type);
+        obj = [min, max];
+        if (body.globalSettings.average)
+            obj.push(aggregateGenerator("AVG", value.linkid, value.property, value.qrveyid || body.qrveyid, value.id, value.type));
+    }
+    else if (value) {
+        obj = [
+            {
+                aggregate: aggregate && aggregate.label,
+                linkid: value.linkid,
+                property: value.property,
+                qrveyid: value.qrveyid || body.qrveyid,
+                questionid: value.id,
+                type: value.type,
+            },
+        ];
+        if (value.calculation)
+            obj[0].calculations = value.calculation;
+    }
+    return obj;
+}
+function aggregateGenerator(aggregate, linkid, property, qrveyid, questionid, type) {
+    return {
+        type,
+        linkid,
+        qrveyid,
+        property,
+        questionid,
+        aggregate: aggregate !== null && aggregate !== void 0 ? aggregate : "SUM",
+    };
+}

package/dist/charts/adapters/endpointDataValidators.d.ts

@@ -0,0 +1,4 @@
+export declare function isNotValid(mainLayer: any): boolean;
+export declare function validChartTypeWithEndPoint(chartType: any): boolean;
+export declare function hasMinorVersion(version: any, current: any): boolean;
+export declare function isColumnDate(column: any): boolean;

package/dist/charts/adapters/endpointDataValidators.js

@@ -0,0 +1,54 @@
+import { COLUMN } from "../../columns";
+import { CHART_TYPE } from "../../constants";
+export function isNotValid(mainLayer) {
+    if (!mainLayer)
+        return;
+    const chartType = mainLayer.type;
+    switch (chartType) {
+        case CHART_TYPE.GEO_CHART:
+            if (mainLayer.mapType && mainLayer.mapType.label === "DOT")
+                return !mainLayer.category;
+            break;
+        case CHART_TYPE.WORD_CLOUD:
+            return !mainLayer.category;
+        case CHART_TYPE.BOXWHISKER_CHART:
+            return !mainLayer.value;
+        case CHART_TYPE.MINMAX_CHART:
+            return !mainLayer.value;
+        case CHART_TYPE.TABLE_CHART:
+        case CHART_TYPE.CROSSTAB_CHART:
+        case CHART_TYPE.EXPANDABLE_TABLE_CHART:
+            return true;
+    }
+    return (!mainLayer.category ||
+        !mainLayer.value ||
+        (chartType !== "SYMBOL_CHART" && !mainLayer.aggregate));
+}
+export function validChartTypeWithEndPoint(chartType) {
+    return [
+        CHART_TYPE.BAR_CHART,
+        CHART_TYPE.LINE_CHART,
+        CHART_TYPE.MINMAX_CHART,
+        CHART_TYPE.SYMBOL_CHART,
+        CHART_TYPE.PIE_CHART,
+        CHART_TYPE.HEATMAP_CHART,
+        CHART_TYPE.WORD_CLOUD,
+        CHART_TYPE.FUNNEL_CHART,
+    ].includes(chartType);
+}
+export function hasMinorVersion(version, current) {
+    const splitVersion = (v) => v.split(".").map((t) => parseInt(t));
+    const currentVersion = splitVersion(current);
+    const chartVersion = splitVersion(version);
+    if (chartVersion[0] < currentVersion[0])
+        return true;
+    else if (chartVersion[1] < currentVersion[1])
+        return true;
+    return false;
+}
+export function isColumnDate(column) {
+    if (column == null)
+        return;
+    return (column.type === COLUMN.DATE ||
+        (column.type === COLUMN.FORMULA && column.formulaType === "date"));
+}

package/dist/charts/adapters/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./endpointDataValidators";
+export * from "./endpointDataGet";
+export * from "./endpointData";

package/dist/charts/adapters/index.js

@@ -0,0 +1,3 @@
+export * from "./endpointDataValidators";
+export * from "./endpointDataGet";
+export * from "./endpointData";

package/dist/charts/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./constants/index";
 export * from "./interfaces/index";
+export * from "./adapters/index";

package/dist/charts/index.js

@@ -1,2 +1,3 @@
 export * from "./constants/index";
 export * from "./interfaces/index";
+export * from "./adapters/index";

package/dist/cjs/charts/adapters/endpointData.d.ts

@@ -0,0 +1,90 @@
+import { IFUData } from "../../filters";
+export declare function configSetup(config?: any): {
+    config: {
+        id: any;
+        data: any;
+        type: any;
+        domain: any;
+        model: any;
+        tab_id: any;
+        app_id: any;
+        api_key: any;
+        user_id: any;
+        view_id: any;
+        page_id: any;
+        chart_id: any;
+        qv_token: any;
+        qrvey_id: any;
+        question: any;
+        metric_id: any;
+        summary_id: any;
+        formulaType: any;
+        summary_type: any;
+        custom_tokens: any;
+        section: any;
+        panel_view: any;
+        previewFilters: any;
+        filterData: any;
+        i18n: any;
+        visibleFilters: IFUData;
+        appliedFilters: IFUData;
+        customDrillLogic: any[];
+        isFromAN: any;
+        editable: any;
+        inBuilder: any;
+        clickable: any;
+        userFilters: any;
+        customdrill: any;
+        widgetConfig: any;
+        drilldowns: any;
+        filterPermissions: any;
+        chartBuilderConfig: any;
+        other_config: any;
+        predefined_filters: any;
+        locale: any;
+        lang: string;
+        panel: {
+            header: {
+                menu: any;
+                filter: any;
+                draggable: any;
+                title_prefix: any;
+                fit_panel: any;
+                visible: any;
+                ui: {
+                    isFiltered: boolean;
+                    isDisplayReady: boolean;
+                    isScrollableXY: boolean;
+                };
+                externalDownload: any;
+            };
+            body: {
+                popup: any;
+                tooltip: any;
+                hasTimeout: boolean;
+                hasOverlay: any;
+                stylesTheme: {
+                    original_match_color: any;
+                    match_color: any;
+                };
+                ui: {
+                    isLoading: boolean;
+                    settingsStyle: any;
+                    timeoutMessage: string;
+                };
+            };
+            footer: {
+                visible: any;
+            };
+        };
+    };
+    data: {};
+    scopes: {};
+    baseConfig: {};
+    customdrills: any[];
+};
+export declare function configMetricData(metricObj?: any): any;
+export declare function configChartData(chartData: any, model: any, setup?: any): {
+    charts: any;
+    logic: import("../../filters").IFBLogic[];
+};