@dhis2/analytics 26.0.8 → 26.0.9

package/build/es/modules/layoutUiRules/__tests__/rules.spec.js

@@ -1,38 +1,34 @@
 import { ALL_AXIS_IDS } from '../../layout/axis.js';
 import { DIMENSION_ID_DATA, DIMENSION_ID_ORGUNIT, DIMENSION_ID_PERIOD } from '../../predefinedDimensions.js';
-import { testResourceRules, testResourceRequiredProps, testResourceAllRuleProps } from '../rules.js'; // Consts
+import { testResourceRules, testResourceRequiredProps, testResourceAllRuleProps } from '../rules.js';
 
+// Consts
 const lockableDims = [DIMENSION_ID_DATA, DIMENSION_ID_PERIOD, DIMENSION_ID_ORGUNIT];
-const disallowableDims = [DIMENSION_ID_DATA, DIMENSION_ID_PERIOD]; // Helper fns
+const disallowableDims = [DIMENSION_ID_DATA, DIMENSION_ID_PERIOD];
 
+// Helper fns
 const allArrayItemsAreValid = (allItems, validItems) => allItems.every(value => validItems.includes(value));
-
 const allArrayItemsAreValidAxisIds = array => allArrayItemsAreValid(array, ALL_AXIS_IDS);
+const onlyRulesWithProp = ruleProp => testResourceRules.filter(rule => rule[ruleProp]);
 
-const onlyRulesWithProp = ruleProp => testResourceRules.filter(rule => rule[ruleProp]); // Partial tests
-
-
+// Partial tests
 const testPropHasKeysAndValues = ruleProp => it('has keys and values', () => {
   expect(onlyRulesWithProp(ruleProp).every(rule => Object.keys(rule[ruleProp]).length && Object.values(rule[ruleProp]).length)).toBe(true);
 });
-
 const testPropIsArray = ruleProp => it('is an array', () => {
   expect(onlyRulesWithProp(ruleProp).every(rule => Array.isArray(rule[ruleProp]))).toBe(true);
 });
-
 const testKeysAreValidAxisIds = ruleProp => it('keys should be valid axis ids', () => {
   expect(onlyRulesWithProp(ruleProp).every(rule => allArrayItemsAreValidAxisIds(Object.keys(rule[ruleProp])))).toBe(true);
 });
-
 const testNoValuesZero = ruleProp => it('values should not be 0', () => {
   expect(onlyRulesWithProp(ruleProp).every(rule => Object.values(rule[ruleProp]).every(value => value !== 0))).toBe(true);
 });
-
 const testNoValuesNegative = ruleProp => it('values should not be negative', () => {
   expect(onlyRulesWithProp(ruleProp).every(rule => Object.values(rule[ruleProp]).every(value => value >= 0))).toBe(true);
-}); // Test implementations
-
+});
 
+// Test implementations
 describe('verify test resource', () => {
   it('testResourceRules is array', () => {
     expect(Array.isArray(testResourceRules)).toBe(true);

package/build/es/modules/layoutUiRules/rules.js

@@ -2,11 +2,11 @@ import { AXIS_ID_COLUMNS, AXIS_ID_ROWS, AXIS_ID_FILTERS } from '../layout/axis.j
 import { DIMENSION_ID_PERIOD, DIMENSION_ID_DATA, DIMENSION_ID_ORGUNIT } from '../predefinedDimensions.js';
 import { VIS_TYPE_COLUMN, VIS_TYPE_STACKED_COLUMN, VIS_TYPE_BAR, VIS_TYPE_STACKED_BAR, VIS_TYPE_LINE, VIS_TYPE_AREA, VIS_TYPE_STACKED_AREA, VIS_TYPE_RADAR, VIS_TYPE_GAUGE, VIS_TYPE_PIE, VIS_TYPE_SINGLE_VALUE, VIS_TYPE_YEAR_OVER_YEAR_LINE, VIS_TYPE_YEAR_OVER_YEAR_COLUMN, VIS_TYPE_PIVOT_TABLE, VIS_TYPE_SCATTER, VIS_TYPE_LINE_LIST } from '../visTypes.js';
 const RULE_PROP_AVAILABLE_AXES = 'availableAxes',
-      RULE_PROP_MAX_DIMS_PER_AXIS = 'maxNumberOfDimsPerAxis',
-      RULE_PROP_MIN_DIMS_PER_AXIS = 'minNumberOfDimsPerAxis',
-      RULE_PROP_MAX_ITEMS_PER_AXIS = 'maxNumberOfItemsPerAxis',
-      RULE_PROP_DISALLOWED_DIMS = 'disallowedDims',
-      RULE_PROP_LOCKED_DIMS = 'lockedDims';
+  RULE_PROP_MAX_DIMS_PER_AXIS = 'maxNumberOfDimsPerAxis',
+  RULE_PROP_MIN_DIMS_PER_AXIS = 'minNumberOfDimsPerAxis',
+  RULE_PROP_MAX_ITEMS_PER_AXIS = 'maxNumberOfItemsPerAxis',
+  RULE_PROP_DISALLOWED_DIMS = 'disallowedDims',
+  RULE_PROP_LOCKED_DIMS = 'lockedDims';
 const defaultRules = {
   [RULE_PROP_AVAILABLE_AXES]: [AXIS_ID_COLUMNS, AXIS_ID_ROWS, AXIS_ID_FILTERS],
   [RULE_PROP_MAX_DIMS_PER_AXIS]: {
@@ -100,24 +100,24 @@ const visTypeToRules = {
   [VIS_TYPE_SCATTER]: scatterRules,
   [VIS_TYPE_LINE_LIST]: lineListRules
 };
-
 const getRulesByVisType = visType => {
   const rules = visTypeToRules[visType];
-
   if (!rules) {
-    throw new Error("".concat(visType, " is not a known visualization type"));
+    throw new Error(`${visType} is not a known visualization type`);
   }
-
   return rules;
-}; // Selectors
+};
 
+// Selectors
 
 export const getAvailableAxesByVisType = visType => getRulesByVisType(visType)[RULE_PROP_AVAILABLE_AXES] || [];
 export const getMaxNumberOfDimsPerAxisByVisType = visType => getRulesByVisType(visType)[RULE_PROP_MAX_DIMS_PER_AXIS] || {};
 export const getMinNumberOfDimsPerAxisByVisType = visType => getRulesByVisType(visType)[RULE_PROP_MIN_DIMS_PER_AXIS] || {};
 export const getMaxNumberOfItemsPerAxisByVisType = visType => getRulesByVisType(visType)[RULE_PROP_MAX_ITEMS_PER_AXIS] || {};
 export const getDisallowedDimsByVisType = visType => getRulesByVisType(visType)[RULE_PROP_DISALLOWED_DIMS] || [];
-export const getLockedDimsByVisType = visType => getRulesByVisType(visType)[RULE_PROP_LOCKED_DIMS] || {}; // Test exports
+export const getLockedDimsByVisType = visType => getRulesByVisType(visType)[RULE_PROP_LOCKED_DIMS] || {};
+
+// Test exports
 
 export const testResourceRequiredProps = [RULE_PROP_AVAILABLE_AXES];
 export const testResourceRules = [...new Set(Object.values(visTypeToRules))];

package/build/es/modules/layoutUiRules/rulesHelper.js

@@ -1,4 +1,6 @@
-import { getMaxNumberOfItemsPerAxisByVisType, getMaxNumberOfDimsPerAxisByVisType, getMinNumberOfDimsPerAxisByVisType, getLockedDimsByVisType } from './rules.js'; // Selectors
+import { getMaxNumberOfItemsPerAxisByVisType, getMaxNumberOfDimsPerAxisByVisType, getMinNumberOfDimsPerAxisByVisType, getLockedDimsByVisType } from './rules.js';
+
+// Selectors
 
 export { getAvailableAxesByVisType, getDisallowedDimsByVisType } from './rules.js';
 export const getAxisMaxNumberOfItemsByVisType = (visType, axisId) => getMaxNumberOfItemsPerAxisByVisType(visType)[axisId];

package/build/es/modules/layoutUiRules/rulesUtils.js

@@ -8,18 +8,20 @@ export const isDimensionLockedByVisType = (visType, dimensionId) => getAllLocked
 export const isAxisFullByVisType = (visType, axisId, axisDimensionsCount) => axisDimensionsCount >= getAxisMaxNumberOfDimsByVisType(visType, axisId);
 export const canDimensionBeAddedToAxisByVisType = (visType, axis, axisId) => {
   const axisIsFull = isAxisFullByVisType(visType, axisId, axis.length);
-  const transferableDimension = getTransferableDimensionPerAxisByVisType(visType, axisId, axis); // 1 dimension allowed in axis
+  const transferableDimension = getTransferableDimensionPerAxisByVisType(visType, axisId, axis);
+
+  // 1 dimension allowed in axis
   // 1 dimension is already present and not locked
   // the dragged one can be added and will cause the old one to be moved to filters
   // what happens with max limit > 1, axis full and 1 or more locked dimensions?
-
   return !(axisIsFull && !transferableDimension);
 };
 export const getTransferableDimensionPerAxisByVisType = (visType, axisId, axis) => {
   const lockedDimsByVisType = getLockedDimsByVisType(visType);
-  const lockedDimIdsByAxis = Object.keys(lockedDimsByVisType).filter(dimId => lockedDimsByVisType[dimId] === axisId); // return the last "transferable" dimension, this needs to be adjusted
+  const lockedDimIdsByAxis = Object.keys(lockedDimsByVisType).filter(dimId => lockedDimsByVisType[dimId] === axisId);
+
+  // return the last "transferable" dimension, this needs to be adjusted
   // if we allow a defined max limit > 1 and the DND wants to drop the new
   // dimension in a specific position
-
   return axis.filter(dimId => !lockedDimIdsByAxis.includes(dimId)).pop();
 };

package/build/es/modules/legends.js

@@ -4,7 +4,6 @@ export const LEGEND_DISPLAY_STYLE_FILL = 'FILL';
 export const LEGEND_DISPLAY_STYLE_TEXT = 'TEXT';
 export const getLegendByValueFromLegendSet = (legendSet, value) => {
   var _legendSet$legends;
-
   return Number.isInteger(parseInt(value)) ? legendSet === null || legendSet === void 0 ? void 0 : (_legendSet$legends = legendSet.legends) === null || _legendSet$legends === void 0 ? void 0 : _legendSet$legends.find(legend => value >= legend.startValue && value < legend.endValue // TODO: Confirm inclusive/exclusive bounds
   ) : null;
 };
@@ -18,7 +17,6 @@ export const getLegendSetByDisplayStrategy = _ref => {
     legendSets,
     legendSetId
   } = _ref;
-
   if (displayStrategy === LEGEND_DISPLAY_STRATEGY_FIXED && legendSets.length) {
     return legendSets[0];
   } else if (displayStrategy === LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM) {

package/build/es/modules/ouIdHelper/index.js

@@ -3,20 +3,14 @@ const GROUP_ID_PREFIX = 'OU_GROUP';
 export const USER_ORG_UNIT = 'USER_ORGUNIT';
 export const USER_ORG_UNIT_CHILDREN = 'USER_ORGUNIT_CHILDREN';
 export const USER_ORG_UNIT_GRANDCHILDREN = 'USER_ORGUNIT_GRANDCHILDREN';
-
 const hasGroupPrefix = id => id.substr(0, GROUP_ID_PREFIX.length) === GROUP_ID_PREFIX;
-
 const hasLevelPrefix = id => id.substr(0, LEVEL_ID_PREFIX.length) === LEVEL_ID_PREFIX;
-
 const stripLevelPrefix = id => hasLevelPrefix(id) ? id.substr(LEVEL_ID_PREFIX.length + 1) : id;
-
 const stripGroupPrefix = id => hasGroupPrefix(id) ? id.substr(GROUP_ID_PREFIX.length + 1) : id;
-
 const removePrefix = id => stripGroupPrefix(stripLevelPrefix(id));
-
 export const ouIdHelper = Object.freeze({
-  addLevelPrefix: id => "".concat(LEVEL_ID_PREFIX, "-").concat(removePrefix(id)),
-  addGroupPrefix: id => "".concat(GROUP_ID_PREFIX, "-").concat(removePrefix(id)),
+  addLevelPrefix: id => `${LEVEL_ID_PREFIX}-${removePrefix(id)}`,
+  addGroupPrefix: id => `${GROUP_ID_PREFIX}-${removePrefix(id)}`,
   removePrefix,
   hasGroupPrefix,
   hasLevelPrefix

package/build/es/modules/ouLevelUtils/index.js

@@ -3,32 +3,25 @@ import { layoutGetDimension } from '../layout/layoutGetDimension.js';
 import { layoutReplaceDimension } from '../layout/layoutReplaceDimension.js';
 import { ouIdHelper } from '../ouIdHelper/index.js';
 import { DIMENSION_ID_ORGUNIT } from '../predefinedDimensions.js';
-
 const isOuLevelIntId = id => ouIdHelper.hasLevelPrefix(id) ? Number.isInteger(parseInt(ouIdHelper.removePrefix(id), 10)) : false;
-
 const replaceNumericOuLevelWithUid = ouLevels => item => {
   var _ouLevels$find;
-
   if (!isOuLevelIntId(item.id)) {
     return item;
   }
-
   const ouIntId = parseInt(ouIdHelper.removePrefix(item.id), 10);
   const ouUid = (_ouLevels$find = ouLevels.find(l => parseInt(l.level, 10) === ouIntId)) === null || _ouLevels$find === void 0 ? void 0 : _ouLevels$find.id;
   return ouUid ? Object.assign({}, item, {
     id: ouIdHelper.addLevelPrefix(ouUid)
   }) : item;
 };
-
 export const convertOuLevelsToUids = (ouLevels, layout) => {
   const ouDimension = layoutGetDimension(layout, DIMENSION_ID_ORGUNIT);
   const hasNumericOuLevels = ouDimension && dimensionGetItems(ouDimension).some(item => isOuLevelIntId(item.id));
-
   if (hasNumericOuLevels) {
     const replaceNumericOuLevel = replaceNumericOuLevelWithUid(ouLevels);
     const updatedOuItems = dimensionGetItems(ouDimension).map(replaceNumericOuLevel);
     return layoutReplaceDimension(layout, DIMENSION_ID_ORGUNIT, updatedOuItems);
   }
-
   return layout;
 };

package/build/es/modules/outliers/index.js

@@ -27,14 +27,11 @@ export const defaultConfig = {
     [PROP_EXTREME_LINES_VALUE]: DEFAULT_EXTREME_LINES_VALUE
   }
 };
-
 const getExtremeLines = (percentage, xyStats) => {
   const lines = [];
-
   if (!isNumeric(percentage)) {
     return lines;
   }
-
   const xExtremeValue = xyStats.xSum * (percentage / 100);
   const yExtremeValue = xyStats.ySum * (percentage / 100);
   lines.push({
@@ -52,57 +49,49 @@ const getExtremeLines = (percentage, xyStats) => {
   });
   return lines;
 };
-
 const getMinMaxValue = (outlierHelper, isVertical, isMax) => {
   const prop = (isVertical ? 'y' : 'x') + (isMax ? 'Max' : 'Min');
   const extremeValue = outlierHelper.extremeLines && outlierHelper.extremeLines[isVertical ? 1 : 0].value;
   const extremeFactor = isNumber(extremeValue) && isMax ? extremeValue + Math.abs(extremeValue) * 0.1 : extremeValue - Math.abs(extremeValue) * 0.1;
   return [...outlierHelper.thresholds.map(t => getXYStats([t.line[0], t.line[t.line.length - 1]])[prop]), extremeFactor].filter(isNumeric).sort(isMax ? (a, b) => b - a : (a, b) => a - b)[0];
 };
-
 export const getOutlierHelper = function (data) {
   let userConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
   if (data.length < 3) {
     return null;
   }
-
-  const config = { ...defaultConfig,
+  const config = {
+    ...defaultConfig,
     ...userConfig,
-    [PROP_EXTREME_LINES]: { ...defaultConfig[PROP_EXTREME_LINES],
+    [PROP_EXTREME_LINES]: {
+      ...defaultConfig[PROP_EXTREME_LINES],
       ...userConfig[PROP_EXTREME_LINES]
     }
   };
-
   if (config[PROP_THRESHOLD_FACTOR] <= 0 && [STANDARD_Z_SCORE, MODIFIED_Z_SCORE].includes(config[PROP_OUTLIER_METHOD])) {
     return null;
   }
-
   const normalizationHelper = getNormalizationHelper(data, config.normalizationMethod);
   const options = {
     xyStats: getXYStats(data)
   };
   let helper;
-
   switch (config[PROP_OUTLIER_METHOD]) {
     case STANDARD_Z_SCORE:
       helper = getZScoreHelper(normalizationHelper, config, options);
       break;
-
     case MODIFIED_Z_SCORE:
       helper = getModZScoreHelper(normalizationHelper, config, options);
       break;
-
     case IQR:
     default:
       helper = getIQRHelper(normalizationHelper, config, options);
   }
-
   if (config[PROP_EXTREME_LINES][PROP_ENABLED] && isNumeric(config[PROP_EXTREME_LINES][PROP_EXTREME_LINES_VALUE])) {
     helper.extremeLines = getExtremeLines(config[PROP_EXTREME_LINES][PROP_EXTREME_LINES_VALUE], options.xyStats);
-  } // undefined means let highcharts decide
-
+  }
 
+  // undefined means let highcharts decide
   const lineXMin = getMinMaxValue(helper, false, false);
   helper.xAxisMin = lineXMin < 0 && lineXMin < options.xyStats.xMin ? lineXMin : undefined;
   const lineYMin = getMinMaxValue(helper, true, false);

package/build/es/modules/outliers/iqr.js

@@ -6,14 +6,11 @@ export const Q2 = 0.5;
 export const Q3 = 0.75;
 export const getQuartilePosition = (data, quartile) => {
   const pos = (data.length + 1) / 4;
-
   switch (quartile) {
     case Q3:
       return pos * 3;
-
     case Q2:
       return pos * 2;
-
     case Q1:
     default:
       return pos;
@@ -21,18 +18,14 @@ export const getQuartilePosition = (data, quartile) => {
 };
 export const getQuartileValue = function (data) {
   let quartile = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Q1;
-
   if (data.length < 3) {
     return;
   }
-
   const pos = getQuartilePosition(data, quartile);
   const rest = pos % 1;
-
   if (rest === 0) {
     return data[pos - 1];
   }
-
   var base = Math.floor(pos);
   var diff = data[base] - data[base - 1];
   return data[base - 1] + diff * rest;
@@ -51,11 +44,9 @@ export const getIQRHelper = (normalizationHelper, config, _ref) => {
   const [q1ThresholdLine, q3ThresholdLine] = normalizationHelper.getThresholdLines(q1Threshold, q3Threshold);
   const outlierPoints = [];
   const inlierPoints = [];
-
   const detectOutliers = () => normalizationHelper.data.forEach((point, idx) => {
     normalizationHelper.isOutlierByIndex(idx, q1Threshold, q3Threshold) ? outlierPoints.push(point) : inlierPoints.push(point);
   });
-
   return {
     name: IQR,
     thresholds: [{

package/build/es/modules/outliers/modZScore.js

@@ -8,7 +8,9 @@ export const getMean = values => values.reduce((total, value) => total + value,
 export const getMedian = values => {
   const hl = values.length / 2;
   return hl % 1 ? values[Math.floor(hl)] : getMean([values[hl - 1], values[hl]]);
-}; // Absolute deviation
+};
+
+// Absolute deviation
 
 export const getMedianAbsoluteDeviation = function (values) {
   let median = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getMedian(values);
@@ -17,10 +19,14 @@ export const getMedianAbsoluteDeviation = function (values) {
 export const getMeanAbsoluteDeviation = function (values) {
   let mean = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getMean(values);
   return getMean(values.map(value => Math.abs(value - mean)));
-}; // Modified z-scores
+};
+
+// Modified z-scores
 
 export const getModZScore = (value, median, medianAD) => MEDIAN_AD_CORRECTION * (value - median) / medianAD;
-export const getModZScoreMAD0 = (value, median, meanAD) => (value - median) / (meanAD * MEAN_AD_CORRECTION); // Thresholds
+export const getModZScoreMAD0 = (value, median, meanAD) => (value - median) / (meanAD * MEAN_AD_CORRECTION);
+
+// Thresholds
 
 export const getModZScoreThresholds = (thresholdFactor, medianAD, median) => [median - medianAD * thresholdFactor / MEDIAN_AD_CORRECTION, median + medianAD * thresholdFactor / MEDIAN_AD_CORRECTION];
 export const getModZScoreMAD0Thresholds = (thresholdFactor, meanAD, median) => [median - thresholdFactor * meanAD * MEAN_AD_CORRECTION, median + thresholdFactor * meanAD * MEAN_AD_CORRECTION];
@@ -30,18 +36,18 @@ export const getDataWithZScore = function (dataWithNormalization) {
   const median = isNumber(cache.median) ? cache.median : getMedian(normalizedData);
   const medianAD = isNumber(cache.medianAD) ? cache.medianAD : getMedianAbsoluteDeviation();
   let dataWithZScore;
-
   if (medianAD === 0) {
     const meanAD = isNumber(cache.meanAD) ? cache.meanAD : getMeanAbsoluteDeviation(normalizedData);
-    dataWithZScore = dataWithNormalization.map(obj => ({ ...obj,
+    dataWithZScore = dataWithNormalization.map(obj => ({
+      ...obj,
       zScore: getModZScoreMAD0(obj.normalized, median, meanAD)
     }));
   } else {
-    dataWithZScore = dataWithNormalization.map(obj => ({ ...obj,
+    dataWithZScore = dataWithNormalization.map(obj => ({
+      ...obj,
       zScore: getModZScore(obj.normalized, median, medianAD)
     }));
   }
-
   return dataWithZScore;
 };
 export const getModZScoreHelper = (normalizationHelper, config, _ref) => {
@@ -56,11 +62,9 @@ export const getModZScoreHelper = (normalizationHelper, config, _ref) => {
   const [lowThresholdLine, highThresholdLine] = normalizationHelper.getThresholdLines(lowThreshold, highThreshold);
   const outlierPoints = [];
   const inlierPoints = [];
-
   const detectOutliers = () => normalizationHelper.data.forEach((point, idx) => {
     normalizationHelper.isOutlierByIndex(idx, lowThreshold, highThreshold) ? outlierPoints.push(point) : inlierPoints.push(point);
   });
-
   return {
     name: MODIFIED_Z_SCORE,
     thresholds: [{

package/build/es/modules/outliers/normalization.js

@@ -1,5 +1,7 @@
 import { linear } from '../../visualizations/config/adapters/dhis_highcharts/addTrendLines.js';
-export const Y_RESIDUALS_LINEAR = 'Y_RESIDUALS_LINEAR'; // Y residuals
+export const Y_RESIDUALS_LINEAR = 'Y_RESIDUALS_LINEAR';
+
+// Y residuals
 
 const getYResidualsHelper = sortedData => {
   const regression = linear(sortedData);
@@ -18,15 +20,11 @@ const getYResidualsHelper = sortedData => {
       return [low, high];
     }
   };
-
   helper.isOutlierByIndex = (idx, lowThreshold, highThreshold) => helper.normalized[idx] < lowThreshold || helper.normalized[idx] > highThreshold;
-
   return helper;
 };
-
 export const getNormalizationHelper = (data, normalizationMethod) => {
   const sortedData = data.slice().sort((a, b) => a[0] - b[0]);
-
   switch (normalizationMethod) {
     case Y_RESIDUALS_LINEAR:
     default:

package/build/es/modules/outliers/xyStats.js

@@ -9,7 +9,6 @@ export const getXYStats = points => {
   let i;
   let x;
   let y;
-
   for (i = 1; i < points.length; i++) {
     x = points[i][0];
     y = points[i][1];
@@ -20,7 +19,6 @@ export const getXYStats = points => {
     yMin = y < yMin ? y : yMin;
     yMax = y > yMax ? y : yMax;
   }
-
   return {
     xSum,
     ySum,

package/build/es/modules/outliers/zScore.js

@@ -17,11 +17,9 @@ export const getZScoreHelper = (normalizationHelper, config, _ref) => {
   const [lowThresholdLine, highThresholdLine] = normalizationHelper.getThresholdLines(lowZScoreThreshold, highZScoreThreshold);
   const outlierPoints = [];
   const inlierPoints = [];
-
   const detectOutliers = () => normalizationHelper.data.forEach((point, idx) => {
     normalizationHelper.isOutlierByIndex(idx, lowZScoreThreshold, highZScoreThreshold) ? outlierPoints.push(point) : inlierPoints.push(point);
   });
-
   return {
     name: STANDARD_Z_SCORE,
     thresholds: [{

package/build/es/modules/pivotTable/AdaptiveClippingController.js

@@ -1,19 +1,16 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 import { measureTextWithWrapping } from './measureText.js';
 import { CLIPPED_AXIS_PARTITION_SIZE_PX, CLIPPED_CELL_MIN_SIZE } from './pivotTableConstants.js';
 export class AdaptiveClippingController {
   constructor(engine) {
     _defineProperty(this, "columns", void 0);
-
     _defineProperty(this, "rows", void 0);
-
     _defineProperty(this, "engine", void 0);
-
     this.engine = engine;
     this.reset();
   }
-
   addSize(_ref, _ref2) {
     let {
       row,
@@ -23,7 +20,6 @@ export class AdaptiveClippingController {
       width,
       height
     } = _ref2;
-
     if (column >= 0) {
       const columnSize = this.columns.sizes[column] || {
         pre: 0,
@@ -35,7 +31,6 @@ export class AdaptiveClippingController {
       const index = this.engine.rowDepth + column;
       this.columns.headerSizes[index] = Math.max(this.columns.headerSizes[index] || 0, width);
     }
-
     if (row >= 0) {
       const rowSize = this.rows.sizes[row] || {
         pre: 0,
@@ -48,7 +43,6 @@ export class AdaptiveClippingController {
       this.rows.headerSizes[index] = Math.max(this.rows.headerSizes[index] || 0, height);
     }
   }
-
   add(_ref3, renderedValue) {
     let {
       row,
@@ -59,7 +53,6 @@ export class AdaptiveClippingController {
       column
     }, this.measureText(renderedValue));
   }
-
   measureText(renderedValue) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     return measureTextWithWrapping(renderedValue, {
@@ -67,33 +60,23 @@ export class AdaptiveClippingController {
       ...options
     });
   }
-
   getCellSize(contentSize) {
-    return Math.ceil(contentSize) + this.engine.cellPadding * 2 +
-    /*border*/
-    2;
+    return Math.ceil(contentSize) + this.engine.cellPadding * 2 + /*border*/2;
   }
-
   finalizeAxis(axis) {
     axis.headerSize = 0;
     const isColumn = axis.orientation === 'column';
     const map = isColumn ? this.engine.columnMap : this.engine.rowMap;
-
     const getHeader = index => isColumn ? this.engine.getRawColumnHeader(index) : this.engine.getRawRowHeader(index);
-
     map.forEach((index, mapIndex) => {
       var _axis$sizes$index2;
-
       const headerStack = getHeader(index);
       headerStack.forEach((header, level) => {
         const label = this.engine.visualization.showHierarchy && header !== null && header !== void 0 && header.hierarchy ? header.hierarchy.join(' / ') : header === null || header === void 0 ? void 0 : header.name;
-
         if (label) {
           const isLeafHeader = level === headerStack.length - 1;
-
           if (isColumn) {
             var _axis$sizes$index;
-
             const headerSize = this.measureText(label, {
               maxWidth: isLeafHeader ? Math.max(CLIPPED_CELL_MIN_SIZE, ((_axis$sizes$index = axis.sizes[index]) === null || _axis$sizes$index === void 0 ? void 0 : _axis$sizes$index.size) || 0) : 0
             });
@@ -123,7 +106,6 @@ export class AdaptiveClippingController {
     });
     this.populateAxisPartitions(axis);
   }
-
   populateAxisPartitions(axis) {
     axis.totalSize = 0;
     axis.partitions = [];
@@ -135,16 +117,13 @@ export class AdaptiveClippingController {
         axis.partitions.push(mapIndex);
         nextPartitionPx += CLIPPED_AXIS_PARTITION_SIZE_PX;
       }
-
       axis.sizes[index].pre = axis.totalSize;
       axis.totalSize += axis.sizes[index].size;
     });
   }
-
   resetRowPartitions() {
     this.populateAxisPartitions(this.rows);
   }
-
   finalize() {
     if (this.engine.visualization.showDimensionLabels) {
       const columnDimensionCount = this.engine.dimensionLookup.columnHeaders.length;
@@ -152,7 +131,6 @@ export class AdaptiveClippingController {
       this.engine.dimensionLookup.columnHeaders.forEach((_, columnLevel) => {
         this.engine.dimensionLookup.rowHeaders.forEach((_, rowLevel) => {
           const label = this.engine.getDimensionLabel(rowLevel, columnLevel);
-
           if (label) {
             this.add({
               row: -rowDimensionCount + rowLevel,
@@ -162,7 +140,6 @@ export class AdaptiveClippingController {
         });
       });
     }
-
     this.finalizeAxis(this.columns);
     this.finalizeAxis(this.rows);
     this.columns.headerSize = 0;
@@ -178,7 +155,6 @@ export class AdaptiveClippingController {
       return paddedSize;
     });
   }
-
   reset() {
     this.columns = {
       orientation: 'column',
@@ -197,5 +173,4 @@ export class AdaptiveClippingController {
       headerSizes: []
     };
   }
-
 }