@gooddata/react-components
Version:
GoodData.UI - A powerful JavaScript library for building analytical applications
652 lines • 32.1 kB
JavaScript
"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) 2019-2020 GoodData Corporation
var set = require("lodash/set");
var get = require("lodash/get");
var uniq = require("lodash/uniq");
var uniqBy = require("lodash/uniqBy");
var negate = require("lodash/negate");
var includes = require("lodash/includes");
var every = require("lodash/every");
var forEach = require("lodash/forEach");
var cloneDeep = require("lodash/cloneDeep");
var isEmpty = require("lodash/isEmpty");
var flatMap = require("lodash/flatMap");
var compact = require("lodash/compact");
var without = require("lodash/without");
var visualizationTypes_1 = require("../../constants/visualizationTypes");
var BucketNames = require("../../constants/bucketNames");
var OverTimeComparison_1 = require("../../interfaces/OverTimeComparison");
var Visualization_1 = require("../interfaces/Visualization");
var bucket_1 = require("../constants/bucket");
var uiConfig_1 = require("../constants/uiConfig");
var translations_1 = require("./translations");
var mdObjBucketHelper_1 = require("../../helpers/mdObjBucketHelper");
var bulletChartOptions_1 = require("../../components/visualizations/chart/chartOptions/bulletChartOptions");
function sanitizeFilters(newReferencePoint) {
var attributeBucketItems = getAllAttributeItems(newReferencePoint.buckets);
var measureBucketItems = getAllMeasureItems(newReferencePoint.buckets);
newReferencePoint.filters = newReferencePoint.filters || {
localIdentifier: "filters",
items: [],
};
var filteredFilters = newReferencePoint.filters.items.filter(function (filterBucketItem) {
var filter = filterBucketItem.filters[0];
if (Visualization_1.isAttributeFilter(filter) || Visualization_1.isDateFilter(filter)) {
if (filterBucketItem.autoCreated === false) {
return true;
}
return attributeBucketItems.some(function (attributeBucketItem) { return attributeBucketItem.attribute === filter.attribute; });
}
else if (Visualization_1.isMeasureValueFilter(filter)) {
if (attributeBucketItems.length === 0) {
return false;
}
return measureBucketItems.some(function (measureBucketItem) {
return measureBucketItem.localIdentifier === filter.measureLocalIdentifier;
});
}
return false;
});
return __assign({}, newReferencePoint, { filters: __assign({}, newReferencePoint.filters, { items: filteredFilters }) });
}
exports.sanitizeFilters = sanitizeFilters;
function isDerivedBucketItem(measureItem) {
return !!measureItem.masterLocalIdentifier;
}
exports.isDerivedBucketItem = isDerivedBucketItem;
function isArithmeticBucketItem(bucketItem) {
return !!bucketItem.operandLocalIdentifiers;
}
function isDerivedOfTypeBucketItem(measureItem, derivedType) {
if (!isDerivedBucketItem(measureItem)) {
return false;
}
return measureItem.overTimeComparisonType === derivedType;
}
function findDerivedTypesReferencedByArithmeticMeasure(measure, allMeasures, visitedMeasures) {
return measure.operandLocalIdentifiers.reduce(function (types, operandIdentifier) {
if (operandIdentifier === null || visitedMeasures.has(operandIdentifier)) {
return types;
}
var operand = findMeasureByLocalIdentifier(operandIdentifier, allMeasures);
if (operand === undefined) {
return types;
}
if (isArithmeticBucketItem(operand)) {
visitedMeasures.add(operandIdentifier);
findDerivedTypesReferencedByArithmeticMeasure(operand, allMeasures, visitedMeasures).forEach(function (type) { return types.add(type); });
}
else if (isDerivedBucketItem(operand) && !types.has(operand.overTimeComparisonType)) {
types.add(operand.overTimeComparisonType);
}
return types;
}, new Set());
}
/**
* Get array of unique over time comparison types used in ancestors of the provided arithmetic measure.
*
* @param measure - the (possibly) arithmetic measure
* @param buckets - all buckets
* @return empty array if there are no derived measures in the arithmetic measure ancestors, empty array if provided
* measure is not arithmetic, array of unique {OverTimeComparisonType} of derived ancestor measures found in arithmetic
* measure tree.
*/
function getDerivedTypesFromArithmeticMeasure(measure, buckets) {
if (!isArithmeticBucketItem(measure)) {
return [];
}
var allMeasures = flatMap(buckets, function (bucket) { return bucket.items; });
var overTimeComparisonTypes = findDerivedTypesReferencedByArithmeticMeasure(measure, allMeasures, new Set());
return Array.from(overTimeComparisonTypes);
}
exports.getDerivedTypesFromArithmeticMeasure = getDerivedTypesFromArithmeticMeasure;
function filterOutDerivedMeasures(measures) {
return measures.filter(function (measure) { return !isDerivedBucketItem(measure); });
}
exports.filterOutDerivedMeasures = filterOutDerivedMeasures;
function isArithmeticMeasureFromDerived(measure, buckets) {
return getDerivedTypesFromArithmeticMeasure(measure, buckets).length > 0;
}
function filterOutArithmeticMeasuresFromDerived(measures, buckets) {
return measures.filter(function (measure) { return !isArithmeticMeasureFromDerived(measure, buckets); });
}
exports.filterOutArithmeticMeasuresFromDerived = filterOutArithmeticMeasuresFromDerived;
function isArithmeticMeasureFromDerivedOfTypeOnly(measure, buckets, derivedType) {
var arithmeticMeasureDerivedTypes = getDerivedTypesFromArithmeticMeasure(measure, buckets);
return arithmeticMeasureDerivedTypes.length === 1 && arithmeticMeasureDerivedTypes[0] === derivedType;
}
function keepOnlyMasterAndDerivedMeasuresOfType(measures, derivedType) {
return measures.filter(function (measure) { return !isDerivedBucketItem(measure) || isDerivedOfTypeBucketItem(measure, derivedType); });
}
exports.keepOnlyMasterAndDerivedMeasuresOfType = keepOnlyMasterAndDerivedMeasuresOfType;
function filterOutIncompatibleArithmeticMeasures(measures, buckets, derivedOfTypeToKeep) {
return measures.filter(function (measure) {
return !isArithmeticBucketItem(measure) ||
!isArithmeticMeasureFromDerived(measure, buckets) ||
isArithmeticMeasureFromDerivedOfTypeOnly(measure, buckets, derivedOfTypeToKeep);
});
}
exports.filterOutIncompatibleArithmeticMeasures = filterOutIncompatibleArithmeticMeasures;
function isDateBucketItem(bucketItem) {
return !!bucketItem && bucketItem.attribute === bucket_1.DATE_DATASET_ATTRIBUTE;
}
exports.isDateBucketItem = isDateBucketItem;
exports.isNotDateBucketItem = negate(isDateBucketItem);
function getDateFilter(filtersBucket) {
var dateFiltersInclEmpty = flatMap(filtersBucket.items, function (filterItem) {
var filters = get(filterItem, "filters", []);
return filters.find(Visualization_1.isDateFilter);
});
var dateFilters = compact(dateFiltersInclEmpty);
return dateFilters.length ? dateFilters[0] : null;
}
exports.getDateFilter = getDateFilter;
function getComparisonTypeFromFilters(filtersBucket) {
if (isEmpty(filtersBucket)) {
return OverTimeComparison_1.OverTimeComparisonTypes.NOTHING;
}
var dateFilter = getDateFilter(filtersBucket);
return !isEmpty(dateFilter) && dateFilter.overTimeComparisonType
? dateFilter.overTimeComparisonType
: OverTimeComparison_1.OverTimeComparisonTypes.NOTHING;
}
exports.getComparisonTypeFromFilters = getComparisonTypeFromFilters;
function bucketSupportsSubtitle(visualizationType, bucketLocalIdentifier) {
if (visualizationType === visualizationTypes_1.VisualizationTypes.HEADLINE) {
return true;
}
if (visualizationType === visualizationTypes_1.VisualizationTypes.SCATTER) {
return bucketLocalIdentifier !== BucketNames.ATTRIBUTE;
}
if (visualizationType === visualizationTypes_1.VisualizationTypes.BUBBLE) {
return bucketLocalIdentifier !== BucketNames.VIEW;
}
if (visualizationType === visualizationTypes_1.VisualizationTypes.COMBO) {
return bucketLocalIdentifier !== BucketNames.VIEW;
}
if (visualizationType === visualizationTypes_1.VisualizationTypes.PUSHPIN) {
return (bucketLocalIdentifier !== BucketNames.LOCATION && bucketLocalIdentifier !== BucketNames.SEGMENT);
}
if (visualizationType === visualizationTypes_1.VisualizationTypes.BULLET) {
return bucketLocalIdentifier !== BucketNames.VIEW;
}
return false;
}
function setBucketTitles(referencePoint, visualizationType, intl) {
var buckets = get(referencePoint, bucket_1.BUCKETS);
var updatedUiConfig = cloneDeep(get(referencePoint, uiConfig_1.UICONFIG));
forEach(buckets, function (bucket) {
var localIdentifier = get(bucket, "localIdentifier", "");
// skip disabled buckets
if (!get(updatedUiConfig, [bucket_1.BUCKETS, localIdentifier, "enabled"], false)) {
return;
}
if (bucketSupportsSubtitle(visualizationType, localIdentifier)) {
var subtitleId = generateBucketSubtitleId(localIdentifier, visualizationType);
var subtitle = translations_1.getTranslation(subtitleId, intl);
set(updatedUiConfig, [bucket_1.BUCKETS, localIdentifier, "subtitle"], subtitle);
}
var titleId = generateBucketTitleId(localIdentifier, visualizationType);
var title = translations_1.getTranslation(titleId, intl);
set(updatedUiConfig, [bucket_1.BUCKETS, localIdentifier, "title"], title);
});
return updatedUiConfig;
}
exports.setBucketTitles = setBucketTitles;
function generateBucketTitleId(localIdentifier, visualizationType) {
return "dashboard.bucket." + localIdentifier + "_title." + visualizationType;
}
exports.generateBucketTitleId = generateBucketTitleId;
function generateBucketSubtitleId(localIdentifier, visualizationType) {
return "dashboard.bucket." + localIdentifier + "_subtitle." + visualizationType;
}
exports.generateBucketSubtitleId = generateBucketSubtitleId;
function getItemsCount(buckets, localIdentifier) {
return getBucketItems(buckets, localIdentifier).length;
}
exports.getItemsCount = getItemsCount;
function getBucketItems(buckets, localIdentifier) {
return get(buckets.find(function (bucket) { return bucket.localIdentifier === localIdentifier; }), "items", []);
}
exports.getBucketItems = getBucketItems;
// return bucket items matching localIdentifiers from any bucket
function getItemsFromBuckets(buckets, localIdentifiers, types) {
return localIdentifiers.reduce(function (bucketItems, localIdentifier) {
return bucketItems.concat(types
? getBucketItemsByType(buckets, localIdentifier, types)
: getBucketItems(buckets, localIdentifier));
}, []);
}
exports.getItemsFromBuckets = getItemsFromBuckets;
function getBucketItemsByType(buckets, localIdentifier, types) {
var itemsOfType = [];
var bucketItems = getBucketItems(buckets, localIdentifier);
bucketItems.forEach(function (item) {
if (includes(types, item.type)) {
itemsOfType.push(item);
}
});
return itemsOfType;
}
exports.getBucketItemsByType = getBucketItemsByType;
function getPreferredBucketItems(buckets, preference, type) {
var bucket = getPreferredBucket(buckets, preference, type);
return get(bucket, "items", []);
}
exports.getPreferredBucketItems = getPreferredBucketItems;
function getPreferredBucket(buckets, preference, type) {
return preference.reduce(function (result, preference) {
if (result) {
return result;
}
return buckets.find(function (bucket) {
var preferenceMatch = bucket.localIdentifier === preference;
var typeMatch = every(get(bucket, "items", []), function (item) { return type.indexOf(item.type) !== -1; });
return preferenceMatch && typeMatch;
});
}, undefined);
}
exports.getPreferredBucket = getPreferredBucket;
function getAllBucketItemsByType(bucket, types) {
return bucket.items.reduce(function (resultItems, item) {
if (includes(types, item.type)) {
resultItems.push(item);
}
return resultItems;
}, []);
}
exports.getAllBucketItemsByType = getAllBucketItemsByType;
function getAllItemsByType(buckets, types) {
return buckets.reduce(function (items, bucket) { return items.concat(getAllBucketItemsByType(bucket, types)); }, []);
}
exports.getAllItemsByType = getAllItemsByType;
function removeDuplicateBucketItems(buckets) {
var usedIdentifiersMap = {};
return buckets.map(function (bucket) {
var filteredBucketItems = bucket.items.filter(function (bucketItem) {
var isDuplicate = usedIdentifiersMap[bucketItem.localIdentifier];
usedIdentifiersMap[bucketItem.localIdentifier] = true;
return !isDuplicate;
});
return filteredBucketItems.length === bucket.items.length
? bucket
: __assign({}, bucket, { items: filteredBucketItems });
});
}
exports.removeDuplicateBucketItems = removeDuplicateBucketItems;
function getTotalsFromBucket(buckets, bucketName) {
var selectedBucket = buckets.find(function (bucket) { return bucket.localIdentifier === bucketName; });
return get(selectedBucket, "totals", []);
}
exports.getTotalsFromBucket = getTotalsFromBucket;
function getUniqueAttributes(buckets) {
var attributes = getAllItemsByType(buckets, [bucket_1.ATTRIBUTE, bucket_1.DATE]);
return uniqBy(attributes, function (attribute) { return get(attribute, "attribute"); });
}
exports.getUniqueAttributes = getUniqueAttributes;
function getMeasures(buckets) {
return getAllItemsByType(buckets, [bucket_1.METRIC]);
}
exports.getMeasures = getMeasures;
function getFirstValidMeasure(buckets) {
var measures = getMeasures(buckets);
var validMeasures = measures.filter(isValidMeasure);
return validMeasures[0] || null;
}
exports.getFirstValidMeasure = getFirstValidMeasure;
function isValidMeasure(measure) {
if (isArithmeticBucketItem(measure)) {
return measure.operandLocalIdentifiers.every(function (operandLocalIdentifier) { return operandLocalIdentifier !== null; });
}
return true;
}
function getFirstAttribute(buckets) {
return getUniqueAttributes(buckets)[0] || null;
}
exports.getFirstAttribute = getFirstAttribute;
function getMeasureItems(buckets) {
var preference = [BucketNames.MEASURES, BucketNames.SECONDARY_MEASURES, BucketNames.TERTIARY_MEASURES];
var preferredMeasures = preference.reduce(function (acc, pref) {
var prefBucketItems = getPreferredBucketItems(buckets, [pref], [bucket_1.METRIC]);
return acc.concat(prefBucketItems);
}, []);
// if not found in prefered bucket use all available measure items
if (isEmpty(get(preferredMeasures, "items", []))) {
return getMeasures(buckets);
}
return get(preferredMeasures, "items", []);
}
exports.getMeasureItems = getMeasureItems;
function getBucketItemsWithExcludeByType(buckets, excludedBucket, type) {
var includedBuckets = buckets.filter(function (bucket) { return !includes(excludedBucket, bucket.localIdentifier); });
return getAllItemsByType(includedBuckets, type);
}
exports.getBucketItemsWithExcludeByType = getBucketItemsWithExcludeByType;
function getStackItems(buckets, itemTypes) {
if (itemTypes === void 0) { itemTypes = [bucket_1.ATTRIBUTE]; }
var preferredStacks = getPreferredBucket(buckets, [BucketNames.STACK, BucketNames.SEGMENT], itemTypes);
return get(preferredStacks, "items", []);
}
exports.getStackItems = getStackItems;
function getAttributeItems(buckets) {
return getAllAttributeItemsWithPreference(buckets, [
BucketNames.LOCATION,
BucketNames.VIEW,
BucketNames.TREND,
]);
}
exports.getAttributeItems = getAttributeItems;
function getAttributeItemsWithoutStacks(buckets) {
return getAttributeItems(buckets).filter(function (attribute) {
return !includes(getStackItems(buckets), attribute);
});
}
exports.getAttributeItemsWithoutStacks = getAttributeItemsWithoutStacks;
function getAllCategoriesAttributeItems(buckets) {
var stackItemsWithDate = getStackItems(buckets, [bucket_1.ATTRIBUTE, bucket_1.DATE]);
return getAttributeItems(buckets).filter(function (attribute) {
return !includes(stackItemsWithDate, attribute);
});
}
exports.getAllCategoriesAttributeItems = getAllCategoriesAttributeItems;
function getAllAttributeItems(buckets) {
return getAllItemsByType(buckets, [bucket_1.ATTRIBUTE, bucket_1.DATE]);
}
exports.getAllAttributeItems = getAllAttributeItems;
function getAllMeasureItems(buckets) {
return getAllItemsByType(buckets, [bucket_1.METRIC]);
}
// get all attributes from buckets, but items from prefered buckets are first
function getAllAttributeItemsWithPreference(buckets, preference) {
var preferredAttributes = preference.reduce(function (acc, pref) {
var prefBucket = getPreferredBucket(buckets, [pref], [bucket_1.ATTRIBUTE, bucket_1.DATE]);
return acc.concat(get(prefBucket, "items", []));
}, []);
var allBucketNames = buckets.map(function (bucket) { return get(bucket, "localIdentifier"); });
var otherBucketNames = allBucketNames.filter(function (bucketName) { return !includes(preference, bucketName); });
var allOtherAttributes = otherBucketNames.reduce(function (attributes, bucketName) {
return attributes.concat(getBucketItemsByType(buckets, bucketName, [bucket_1.ATTRIBUTE, bucket_1.DATE]));
}, []);
return preferredAttributes.concat(allOtherAttributes);
}
exports.getAllAttributeItemsWithPreference = getAllAttributeItemsWithPreference;
function getDateItems(buckets) {
return getAttributeItemsWithoutStacks(buckets).filter(isDateBucketItem);
}
exports.getDateItems = getDateItems;
function hasItemsAboveLimit(bucket, itemsLimit) {
var masterBucketItems = filterOutDerivedMeasures(bucket.items);
return masterBucketItems.length > itemsLimit;
}
function applyItemsLimit(bucket, itemsLimit) {
if (itemsLimit !== undefined && hasItemsAboveLimit(bucket, itemsLimit)) {
var newBucket = cloneDeep(bucket);
newBucket.items = newBucket.items.slice(0, itemsLimit);
return newBucket;
}
return bucket;
}
function applyUiConfigOnBucket(bucket, bucketUiConfig) {
return applyItemsLimit(bucket, get(bucketUiConfig, "itemsLimit"));
}
function applyUiConfig(referencePoint) {
var buckets = referencePoint.buckets;
var uiConfig = referencePoint.uiConfig.buckets;
var newBuckets = buckets.map(function (bucket) {
return applyUiConfigOnBucket(bucket, uiConfig[bucket.localIdentifier]);
});
set(referencePoint, "buckets", newBuckets);
return referencePoint;
}
exports.applyUiConfig = applyUiConfig;
function hasBucket(buckets, localIdentifier) {
return buckets.some(function (bucket) { return bucket.localIdentifier === localIdentifier; });
}
exports.hasBucket = hasBucket;
function findBucket(buckets, localIdentifier) {
return buckets.find(function (bucket) { return get(bucket, "localIdentifier") === localIdentifier; });
}
exports.findBucket = findBucket;
function getBucketsByNames(buckets, names) {
return buckets.filter(function (bucket) { return includes(names, get(bucket, "localIdentifier")); });
}
exports.getBucketsByNames = getBucketsByNames;
function getFirstMasterWithDerived(measureItems) {
var masters = filterOutDerivedMeasures(measureItems);
var chosenMaster = masters[0];
return measureItems.filter(function (measureItem) {
return measureItem.masterLocalIdentifier === chosenMaster.localIdentifier ||
measureItem === chosenMaster;
});
}
exports.getFirstMasterWithDerived = getFirstMasterWithDerived;
function removeAllArithmeticMeasuresFromDerived(extendedReferencePoint) {
var originalBuckets = cloneDeep(extendedReferencePoint.buckets);
forEach(extendedReferencePoint.buckets, function (bucket) {
bucket.items = filterOutArithmeticMeasuresFromDerived(bucket.items, originalBuckets);
});
return extendedReferencePoint;
}
exports.removeAllArithmeticMeasuresFromDerived = removeAllArithmeticMeasuresFromDerived;
function removeAllDerivedMeasures(extendedReferencePoint) {
forEach(extendedReferencePoint.buckets, function (bucket) {
bucket.items = filterOutDerivedMeasures(bucket.items);
});
return extendedReferencePoint;
}
exports.removeAllDerivedMeasures = removeAllDerivedMeasures;
function findMasterBucketItem(derivedBucketItem, bucketItems) {
return bucketItems.find(function (item) { return item.localIdentifier === derivedBucketItem.masterLocalIdentifier; });
}
exports.findMasterBucketItem = findMasterBucketItem;
function findMasterBucketItems(bucketItems) {
return bucketItems.filter(function (measure) { return !isDerivedBucketItem(measure); });
}
exports.findMasterBucketItems = findMasterBucketItems;
function findDerivedBucketItems(masterBucketItem, bucketItems) {
return bucketItems.filter(function (measure) { return measure.masterLocalIdentifier === masterBucketItem.localIdentifier; });
}
exports.findDerivedBucketItems = findDerivedBucketItems;
function findDerivedBucketItem(masterBucketItem, bucketItems) {
return bucketItems.find(function (bucketItem) { return bucketItem.masterLocalIdentifier === masterBucketItem.localIdentifier; });
}
exports.findDerivedBucketItem = findDerivedBucketItem;
function hasDerivedBucketItems(masterBucketItem, buckets) {
return buckets.some(function (bucket) {
return bucket.items.some(function (bucketItem) { return bucketItem.masterLocalIdentifier === masterBucketItem.localIdentifier; });
});
}
exports.hasDerivedBucketItems = hasDerivedBucketItems;
function getFilteredMeasuresForStackedCharts(buckets) {
var hasStacks = getStackItems(buckets).length > 0;
if (hasStacks) {
var limitedBuckets = limitNumberOfMeasuresInBuckets(buckets, 1);
return getMeasureItems(limitedBuckets);
}
return getMeasureItems(buckets);
}
exports.getFilteredMeasuresForStackedCharts = getFilteredMeasuresForStackedCharts;
function noRowsAndHasOneMeasure(buckets) {
var measureBucket = buckets.find(function (bucket) { return bucket.localIdentifier === BucketNames.MEASURES; });
var rows = buckets.find(function (bucket) { return bucket.localIdentifier === BucketNames.VIEW; });
var hasOneMeasure = measureBucket && measureBucket.items.length === 1;
var hasRows = rows && rows.items.length > 0;
return Boolean(hasOneMeasure && !hasRows);
}
exports.noRowsAndHasOneMeasure = noRowsAndHasOneMeasure;
function noColumnsAndHasOneMeasure(buckets) {
var measureBucket = buckets.find(function (bucket) { return bucket.localIdentifier === BucketNames.MEASURES; });
var columns = buckets.find(function (bucket) { return bucket.localIdentifier === BucketNames.STACK; });
var hasOneMeasure = measureBucket && measureBucket.items.length === 1;
var hasColumn = columns && columns.items.length > 0;
return Boolean(hasOneMeasure && !hasColumn);
}
exports.noColumnsAndHasOneMeasure = noColumnsAndHasOneMeasure;
function limitNumberOfMeasuresInBuckets(buckets, measuresLimitCount, tryToSelectDerivedWithMaster) {
if (tryToSelectDerivedWithMaster === void 0) { tryToSelectDerivedWithMaster = false; }
var allMeasures = getMeasureItems(buckets);
var selectedMeasuresLocalIdentifiers = [];
// try to select measures one per bucket
buckets.forEach(function (bucket) {
var currentBucketMeasures = getAllBucketItemsByType(bucket, [bucket_1.METRIC]);
if (currentBucketMeasures.length === 0) {
return;
}
selectedMeasuresLocalIdentifiers = getLimitedMeasuresLocalIdentifiers(currentBucketMeasures, 1, allMeasures, measuresLimitCount, tryToSelectDerivedWithMaster, selectedMeasuresLocalIdentifiers);
});
// if it was not possible to select all measures one per bucket then limit them globally
if (selectedMeasuresLocalIdentifiers.length < measuresLimitCount) {
selectedMeasuresLocalIdentifiers = getLimitedMeasuresLocalIdentifiers(allMeasures, measuresLimitCount, allMeasures, measuresLimitCount, tryToSelectDerivedWithMaster, selectedMeasuresLocalIdentifiers);
}
return pruneBucketMeasureItems(buckets, selectedMeasuresLocalIdentifiers);
}
exports.limitNumberOfMeasuresInBuckets = limitNumberOfMeasuresInBuckets;
function getLimitedMeasuresLocalIdentifiers(measures, measuresLimitCount, allMeasures, allMeasuresLimitCount, tryToSelectDerivedWithMaster, alreadySelectedMeasures) {
var selectedMeasures = alreadySelectedMeasures;
// try to select measures one by one together with their dependencies
measures.forEach(function (measure) {
if (selectedMeasures.length - alreadySelectedMeasures.length === measuresLimitCount) {
return;
}
var measureDependencies = getDependenciesLocalIdentifiers(measure, allMeasures);
var measureWithDependencies = [measure.localIdentifier].concat(measureDependencies);
if (tryToSelectDerivedWithMaster) {
var derivedMeasures = getDerivedLocalIdentifiers(measure, allMeasures);
var masterDerivedAndDependencies = measureWithDependencies.concat(derivedMeasures);
selectedMeasures = tryToSelectMeasures(masterDerivedAndDependencies, selectedMeasures, allMeasuresLimitCount);
}
selectedMeasures = tryToSelectMeasures(measureWithDependencies, selectedMeasures, allMeasuresLimitCount);
});
return selectedMeasures;
}
function getDerivedLocalIdentifiers(measure, allMeasures) {
var derivedMeasures = findDerivedBucketItems(measure, allMeasures);
return derivedMeasures.map(function (derivedMeasure) { return derivedMeasure.localIdentifier; });
}
function findMeasureByLocalIdentifier(localIdentifier, measures) {
return measures.find(function (measure) { return measure.localIdentifier === localIdentifier; });
}
function getDependenciesLocalIdentifiers(measure, allMeasures) {
var directDependencies = [];
if (measure.masterLocalIdentifier) {
directDependencies.push(measure.masterLocalIdentifier);
}
if (measure.operandLocalIdentifiers) {
measure.operandLocalIdentifiers
.filter(function (operandLocalIdentifier) { return operandLocalIdentifier !== null; })
.forEach(function (operandLocalIdentifier) {
var operandMeasure = findMeasureByLocalIdentifier(operandLocalIdentifier, allMeasures);
if (operandMeasure !== undefined) {
directDependencies.push(operandLocalIdentifier);
}
});
}
var indirectDependencies = [];
directDependencies.forEach(function (dependencyLocalIdentifier) {
var dependencyMeasure = findMeasureByLocalIdentifier(dependencyLocalIdentifier, allMeasures);
var dependenciesOfDependency = getDependenciesLocalIdentifiers(dependencyMeasure, allMeasures);
indirectDependencies.push.apply(indirectDependencies, dependenciesOfDependency);
});
return uniq(directDependencies.concat(indirectDependencies));
}
function tryToSelectMeasures(measures, alreadySelectedMeasures, limit) {
var measuresToBePlaced = without.apply(void 0, [measures].concat(alreadySelectedMeasures));
if (measuresToBePlaced.length <= limit - alreadySelectedMeasures.length) {
return alreadySelectedMeasures.concat(measuresToBePlaced);
}
return alreadySelectedMeasures;
}
function pruneBucketMeasureItems(buckets, measureLocalIdentifiersToBeKept) {
return buckets.map(function (bucket) {
var prunedItems = bucket.items.filter(function (item) {
return measureLocalIdentifiersToBeKept.indexOf(item.localIdentifier) > -1 ||
item.type !== bucket_1.METRIC;
});
return __assign({}, bucket, { items: prunedItems });
});
}
function isShowOnSecondaryAxis(item) {
return get(item, bucket_1.SHOW_ON_SECONDARY_AXIS, false);
}
exports.isShowOnSecondaryAxis = isShowOnSecondaryAxis;
function setMeasuresShowOnSecondaryAxis(items, value) {
return items.map(function (item) {
var _a;
return (__assign({}, item, (_a = {}, _a[bucket_1.SHOW_ON_SECONDARY_AXIS] = value, _a)));
});
}
exports.setMeasuresShowOnSecondaryAxis = setMeasuresShowOnSecondaryAxis;
function removeShowOnSecondaryAxis(items) {
return setMeasuresShowOnSecondaryAxis(items, null);
}
exports.removeShowOnSecondaryAxis = removeShowOnSecondaryAxis;
function getAllMeasuresShowOnSecondaryAxis(buckets) {
return getAllItemsByType(buckets, [bucket_1.METRIC]).filter(isShowOnSecondaryAxis);
}
exports.getAllMeasuresShowOnSecondaryAxis = getAllMeasuresShowOnSecondaryAxis;
function getItemsLocalIdentifiers(items) {
return items.map(function (item) { return get(item, "localIdentifier", ""); });
}
exports.getItemsLocalIdentifiers = getItemsLocalIdentifiers;
var getAvailableMeasureBucketsLocalIdentifiers = function (type) {
return (type === visualizationTypes_1.VisualizationTypes.BULLET && bulletChartOptions_1.SUPPORTED_MEASURE_BUCKETS) || [];
};
exports.getOccupiedMeasureBucketsLocalIdentifiers = function (type, mdObject, executionResultData) {
var availableMeasureBucketsLocalIdentifiers = getAvailableMeasureBucketsLocalIdentifiers(type);
var buckets = get(mdObject, "buckets", []);
var notEmptyMeasureBucketsLocalIdentifiers = mdObjBucketHelper_1.filterOutEmptyBuckets(buckets)
.map(function (bucket) { return bucket.localIdentifier; })
.filter(function (bucketLocalIdentifier) {
return availableMeasureBucketsLocalIdentifiers.indexOf(bucketLocalIdentifier) >= 0;
});
return !isEmpty(notEmptyMeasureBucketsLocalIdentifiers)
? notEmptyMeasureBucketsLocalIdentifiers
: availableMeasureBucketsLocalIdentifiers.slice(0, executionResultData.length);
};
exports.transformMeasureBuckets = function (measureBucketItemsLimits, buckets) {
var unusedMeasures = [];
var newBuckets = measureBucketItemsLimits.map(function (_a) {
var localIdentifier = _a.localIdentifier, itemsLimit = _a.itemsLimit;
var preferedBucketlocalIdentifiers = localIdentifier === BucketNames.MEASURES
? [BucketNames.MEASURES, BucketNames.SIZE]
: localIdentifier === BucketNames.SECONDARY_MEASURES
? [BucketNames.SECONDARY_MEASURES, BucketNames.COLOR]
: [localIdentifier];
var preferredBucketItems = getPreferredBucketItems(buckets, preferedBucketlocalIdentifiers, [
bucket_1.METRIC,
]);
var measuresToBePlaced = preferredBucketItems.splice(0, itemsLimit);
if (measuresToBePlaced.length === 0) {
return {
localIdentifier: localIdentifier,
items: unusedMeasures.splice(0, itemsLimit),
};
}
unusedMeasures = unusedMeasures.concat(preferredBucketItems);
return {
localIdentifier: localIdentifier,
items: measuresToBePlaced,
};
});
return newBuckets.map(function (bucket, bucketIndex) {
var bucketItemsLimit = measureBucketItemsLimits[bucketIndex].itemsLimit;
var freeSlotsCount = bucketItemsLimit - bucket.items.length;
if (freeSlotsCount === 0) {
return bucket;
}
return __assign({}, bucket, { items: bucket.items.concat(unusedMeasures.splice(0, freeSlotsCount)) });
});
};
//# sourceMappingURL=bucketHelper.js.map