@gooddata/react-components/dist/helpers/dimensions.js

GoodData.UI - A powerful JavaScript library for building analytical applications

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
// (C) 2007-2020 GoodData Corporation
var get = require("lodash/get");
var visualizationTypes_1 = require("../constants/visualizationTypes");
var dimensions_1 = require("../constants/dimensions");
var bucketNames_1 = require("../constants/bucketNames");
var conversion_1 = require("../helpers/conversion");
var constants_1 = require("../components/visualizations/chart/constants");
var mdObjBucketHelper_1 = require("./mdObjBucketHelper");
var data_1 = require("./geoChart/data");
function getDimensionTotals(bucket) {
    var bucketTotals = get(bucket, "totals", []);
    return bucketTotals.map(function (total) {
        return {
            measureIdentifier: total.measureIdentifier,
            type: total.type,
            attributeIdentifier: total.attributeIdentifier,
        };
    });
}
exports.getDimensionTotals = getDimensionTotals;
function getPivotTableDimensions(buckets) {
    var rowAttributes = buckets.find(
    // ATTRIBUTE for backwards compatibility with Table component. Actually ROWS
    function (bucket) { return bucket.localIdentifier === bucketNames_1.ATTRIBUTE; });
    var columnAttributes = buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.COLUMNS; });
    var measures = buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.MEASURES; });
    var rowAttributesItemIdentifiers = get(rowAttributes, "items", []).map(function (a) { return a.visualizationAttribute.localIdentifier; });
    var columnAttributesItemIdentifiers = get(columnAttributes, "items", []).map(function (a) { return a.visualizationAttribute.localIdentifier; });
    var measuresItemIdentifiers = get(measures, "items.length") ? [dimensions_1.MEASUREGROUP] : [];
    var totals = getDimensionTotals(rowAttributes);
    var totalsProp = totals.length ? { totals: totals } : {};
    return [
        __assign({ itemIdentifiers: rowAttributesItemIdentifiers }, totalsProp),
        {
            itemIdentifiers: columnAttributesItemIdentifiers.concat(measuresItemIdentifiers),
        },
    ];
}
exports.getPivotTableDimensions = getPivotTableDimensions;
function getTableDimensions(buckets) {
    var attributes = buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.ATTRIBUTE; });
    var measures = buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.MEASURES; });
    var attributesItemIdentifiers = get(attributes, "items", []).map(function (a) { return a.visualizationAttribute.localIdentifier; });
    var measuresItemIdentifiers = measures && measures.items && measures.items.length ? [dimensions_1.MEASUREGROUP] : [];
    var totals = getDimensionTotals(attributes);
    var totalsProp = totals.length ? { totals: totals } : {};
    return [
        __assign({ itemIdentifiers: attributesItemIdentifiers }, totalsProp),
        {
            itemIdentifiers: measuresItemIdentifiers,
        },
    ];
}
exports.getTableDimensions = getTableDimensions;
function getLocalIdentifierFromAttribute(attribute) {
    return attribute.visualizationAttribute.localIdentifier;
}
function getPieOrDonutDimensions(mdObject) {
    var view = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.VIEW; });
    if (view && view.items.length) {
        return [
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
            {
                itemIdentifiers: view.items.map(getLocalIdentifierFromAttribute),
            },
        ];
    }
    return [
        {
            itemIdentifiers: [],
        },
        {
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        },
    ];
}
function getBarDimensions(mdObject) {
    var view = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.VIEW; });
    var stack = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.STACK; });
    var hasNoStacks = !stack || !stack.items || stack.items.length === 0;
    if (hasNoStacks) {
        return [
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
            {
                itemIdentifiers: ((view && view.items) || []).map(getLocalIdentifierFromAttribute),
            },
        ];
    }
    return [
        {
            itemIdentifiers: ((stack && stack.items) || []).map(getLocalIdentifierFromAttribute),
        },
        {
            itemIdentifiers: ((view && view.items) || [])
                .map(getLocalIdentifierFromAttribute)
                .concat([dimensions_1.MEASUREGROUP]),
        },
    ];
}
function getAreaDimensions(mdObject) {
    var view = mdObjBucketHelper_1.findBucketByLocalIdentifier(mdObject.buckets, bucketNames_1.VIEW);
    var stack = mdObjBucketHelper_1.findBucketByLocalIdentifier(mdObject.buckets, bucketNames_1.STACK);
    var hasNoStacks = !stack || !stack.items || stack.items.length === 0;
    var haveManyViewItems = view && view.items && view.items.length > 1;
    if (haveManyViewItems) {
        // only take first two view items
        var _a = view.items
            .slice(0, constants_1.VIEW_BY_ATTRIBUTES_LIMIT)
            .map(getLocalIdentifierFromAttribute), viewItemIdentifier = _a[0], stackItemIdentifier = _a[1];
        return [
            {
                itemIdentifiers: [stackItemIdentifier],
            },
            {
                itemIdentifiers: [viewItemIdentifier, dimensions_1.MEASUREGROUP],
            },
        ];
    }
    if (hasNoStacks) {
        return [
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
            {
                itemIdentifiers: ((view && view.items) || []).map(getLocalIdentifierFromAttribute),
            },
        ];
    }
    return [
        {
            itemIdentifiers: ((stack && stack.items) || []).map(getLocalIdentifierFromAttribute),
        },
        {
            itemIdentifiers: ((view && view.items) || [])
                .map(getLocalIdentifierFromAttribute)
                .concat([dimensions_1.MEASUREGROUP]),
        },
    ];
}
function getLineDimensions(mdObject) {
    var trend = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.TREND; });
    var segment = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.SEGMENT; });
    var hasNoSegments = !segment || !segment.items || segment.items.length === 0;
    if (hasNoSegments) {
        return [
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
            {
                itemIdentifiers: ((trend && trend.items) || []).map(function (t) {
                    return t.visualizationAttribute.localIdentifier;
                }),
            },
        ];
    }
    return [
        {
            itemIdentifiers: ((segment && segment.items) || []).map(function (s) { return s.visualizationAttribute.localIdentifier; }),
        },
        {
            itemIdentifiers: ((trend && trend.items) || [])
                .map(function (t) {
                return t.visualizationAttribute.localIdentifier;
            })
                .concat([dimensions_1.MEASUREGROUP]),
        },
    ];
}
function getHeadlinesDimensions() {
    return [{ itemIdentifiers: ["measureGroup"] }];
}
exports.getHeadlinesDimensions = getHeadlinesDimensions;
function getXirrDimensions(mdObject) {
    var attribute = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.ATTRIBUTE; });
    if (attribute && attribute.items.length) {
        return [
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP].concat(attribute.items.map(getLocalIdentifierFromAttribute)),
            },
        ];
    }
    return [
        {
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        },
    ];
}
exports.getXirrDimensions = getXirrDimensions;
function getScatterDimensions(mdObject) {
    var attribute = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.ATTRIBUTE; });
    if (attribute && attribute.items.length) {
        return [
            {
                itemIdentifiers: attribute.items.map(getLocalIdentifierFromAttribute),
            },
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
        ];
    }
    return [
        {
            itemIdentifiers: [],
        },
        {
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        },
    ];
}
function getGeoChartDimensions(buckets) {
    var _a = conversion_1.convertBucketsToAFM(buckets), _b = _a.attributes, attributes = _b === void 0 ? [] : _b, _c = _a.measures, measures = _c === void 0 ? [] : _c;
    var chartDimensions = [];
    if (measures.length > 0) {
        chartDimensions.push({ itemIdentifiers: [dimensions_1.MEASUREGROUP] });
    }
    chartDimensions.push({ itemIdentifiers: attributes.map(function (attr) { return attr.localIdentifier; }) });
    return chartDimensions;
}
exports.getGeoChartDimensions = getGeoChartDimensions;
// Heatmap
function getHeatmapDimensionsFromMdObj(mdObject) {
    var buckets = mdObject.buckets;
    return getHeatmapDimensionsFromBuckets(buckets);
}
exports.getHeatmapDimensionsFromMdObj = getHeatmapDimensionsFromMdObj;
function getHeatmapDimensionsFromBuckets(buckets) {
    var view = buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.VIEW; });
    var stack = buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.STACK; });
    var hasNoStacks = !stack || !stack.items || stack.items.length === 0;
    if (hasNoStacks) {
        return [
            {
                itemIdentifiers: ((view && view.items) || []).map(getLocalIdentifierFromAttribute),
            },
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
        ];
    }
    return [
        {
            itemIdentifiers: ((view && view.items) || []).map(getLocalIdentifierFromAttribute),
        },
        {
            itemIdentifiers: ((stack && stack.items) || [])
                .map(getLocalIdentifierFromAttribute)
                .concat([dimensions_1.MEASUREGROUP]),
        },
    ];
}
exports.getHeatmapDimensionsFromBuckets = getHeatmapDimensionsFromBuckets;
function getBubbleDimensions(mdObject) {
    var view = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.VIEW; });
    var stack = mdObject.buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.STACK; });
    var hasNoStacks = !stack || !stack.items || stack.items.length === 0;
    if (hasNoStacks) {
        return [
            {
                itemIdentifiers: ((view && view.items) || []).map(getLocalIdentifierFromAttribute),
            },
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
        ];
    }
    return [
        {
            itemIdentifiers: ((view && view.items) || [])
                .map(getLocalIdentifierFromAttribute)
                .concat(((stack && stack.items) || []).map(getLocalIdentifierFromAttribute)),
        },
        {
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        },
    ];
}
/**
 * generateDimensions
 * is a function that generates dimensions based on buckets and visualization objects.
 * WARNING: It duplicates logic from pluggable visualizations.
 *          Remove once react components support pluggable visualizations.
 * @param mdObject:VisualizationObject.IVisualizationObjectContent - metadata object with buckets
 * @param type:VisType - visualization type string
 * @internal
 */
function generateDimensions(mdObject, type) {
    switch (type) {
        case visualizationTypes_1.VisualizationTypes.TABLE: {
            return getPivotTableDimensions(mdObject.buckets);
        }
        case visualizationTypes_1.VisualizationTypes.PIE:
        case visualizationTypes_1.VisualizationTypes.DONUT:
        case visualizationTypes_1.VisualizationTypes.FUNNEL: {
            return getPieOrDonutDimensions(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.TREEMAP: {
            return getTreemapDimensionsFromMdObj(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.LINE: {
            return getLineDimensions(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.AREA: {
            return getAreaDimensions(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.BAR:
        case visualizationTypes_1.VisualizationTypes.COMBO:
        case visualizationTypes_1.VisualizationTypes.COMBO2:
        case visualizationTypes_1.VisualizationTypes.COLUMN:
        case visualizationTypes_1.VisualizationTypes.BULLET: {
            return getBarDimensions(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.HEADLINE: {
            return getHeadlinesDimensions();
        }
        case visualizationTypes_1.VisualizationTypes.SCATTER: {
            return getScatterDimensions(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.HEATMAP: {
            return getHeatmapDimensionsFromMdObj(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.BUBBLE: {
            return getBubbleDimensions(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.XIRR: {
            return getXirrDimensions(mdObject);
        }
        case visualizationTypes_1.VisualizationTypes.PUSHPIN: {
            var buckets = data_1.getGeoBucketsFromMdObject(mdObject);
            return getGeoChartDimensions(buckets);
        }
    }
    return [];
}
exports.generateDimensions = generateDimensions;
function generateStackedDimensions(buckets) {
    var viewBucket = buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.ATTRIBUTE; });
    var stackBucket = buckets.find(function (bucket) { return bucket.localIdentifier === bucketNames_1.STACK; });
    var viewByAttributes = viewBucket && viewBucket.items;
    var stackByAttribute = stackBucket && stackBucket.items[0];
    var stackByAttributeLocalIdentifier = stackByAttribute
        ? stackByAttribute.visualizationAttribute.localIdentifier
        : undefined;
    var viewByAttributeLocalIdentifiers = viewByAttributes && viewByAttributes.map(getLocalIdentifierFromAttribute);
    return [
        {
            itemIdentifiers: stackByAttributeLocalIdentifier ? [stackByAttributeLocalIdentifier] : [],
        },
        {
            itemIdentifiers: viewByAttributeLocalIdentifiers
                ? viewByAttributeLocalIdentifiers.concat([dimensions_1.MEASUREGROUP]) : [dimensions_1.MEASUREGROUP],
        },
    ];
}
exports.generateStackedDimensions = generateStackedDimensions;
function generateDefaultDimensions(afm) {
    return [
        {
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        },
        {
            itemIdentifiers: (afm.attributes || []).map(function (a) { return a.localIdentifier; }),
        },
    ];
}
exports.generateDefaultDimensions = generateDefaultDimensions;
function isStackedChart(buckets, stackedBuckedName) {
    if (stackedBuckedName === void 0) { stackedBuckedName = bucketNames_1.STACK; }
    return buckets.some(function (bucket) { return bucket.localIdentifier === stackedBuckedName && bucket.items.length > 0; });
}
exports.isStackedChart = isStackedChart;
// for ScatterPlot and BubbleChart
function generateDefaultDimensionsForPointsCharts(afm) {
    return [
        {
            itemIdentifiers: (afm.attributes || []).map(function (a) { return a.localIdentifier; }),
        },
        {
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        },
    ];
}
exports.generateDefaultDimensionsForPointsCharts = generateDefaultDimensionsForPointsCharts;
// for PieChart, DonutChart
exports.generateDefaultDimensionsForRoundChart = function (afm) {
    if ((afm.attributes || []).length === 0) {
        return [
            {
                itemIdentifiers: [],
            },
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
        ];
    }
    return [
        {
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        },
        {
            itemIdentifiers: (afm.attributes || []).map(function (a) { return a.localIdentifier; }),
        },
    ];
};
// Treemap
function getTreemapDimensionsFromMdObj(mdObject) {
    var buckets = mdObject.buckets;
    return getTreemapDimensionsFromBuckets(buckets);
}
exports.getTreemapDimensionsFromMdObj = getTreemapDimensionsFromMdObj;
function getTreemapDimensionsFromBuckets(buckets) {
    var afm = conversion_1.convertBucketsToAFM(buckets);
    return getTreemapDimensionsFromAFM(afm);
}
exports.getTreemapDimensionsFromBuckets = getTreemapDimensionsFromBuckets;
function getTreemapDimensionsFromAFM(afm) {
    var attributes = afm.attributes || [];
    if (attributes.length === 1) {
        return [
            {
                itemIdentifiers: [dimensions_1.MEASUREGROUP],
            },
            {
                itemIdentifiers: attributes.map(function (a) { return a.localIdentifier; }),
            },
        ];
    }
    return [
        {
            itemIdentifiers: attributes.map(function (a) { return a.localIdentifier; }),
        },
        {
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        },
    ];
}
exports.getTreemapDimensionsFromAFM = getTreemapDimensionsFromAFM;
function getGeneralDimensionsFromAFM(afm) {
    var attributes = afm.attributes || [];
    var measures = afm.measures || [];
    var dimensions = [];
    if (attributes.length > 0) {
        dimensions.push({
            itemIdentifiers: attributes.map(function (attribute) { return attribute.localIdentifier; }),
        });
    }
    if (measures.length > 0) {
        dimensions.push({
            itemIdentifiers: [dimensions_1.MEASUREGROUP],
        });
    }
    return dimensions;
}
exports.getGeneralDimensionsFromAFM = getGeneralDimensionsFromAFM;
//# sourceMappingURL=dimensions.js.map