@aibsweb/faceted-search/es/components/pivot-table/utils.js

A generalized faceted search application.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.computeBodyData = computeBodyData;
exports.computeDiameter = exports.getLongestRowLabelLength = exports.computeTableBodyData = exports.computeLeftSideData = exports.computeGridData = exports.maxValueByKey = void 0;

var _isArray = _interopRequireDefault(require("lodash/isArray"));

var _stringHelper = require("../../helpers/string-helper");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

/**
 * Computes the maximum value of a list of datum objects
 *
 * @param {Array} data list of data
 * @param {string} key to access value
 */
var maxValueByKey = function maxValueByKey(data, valueKey) {
  if (!(0, _isArray["default"])(data) || !data.length) {
    return undefined;
  } else {
    return data.reduce(function (acc, datum) {
      return Math.max(acc, Number(datum[valueKey]));
    }, // reducer
    data[0][valueKey] // initial value is first value in the data
    );
  }
};
/**
 * Compute a 2d matrix corresponding to cell entries to be displayed
 *
 * @param {Array} data datum objects from transform
 * @param {Array} rowLabels list of label strings
 * @param {Array} columnLabels list of label strings
 */


exports.maxValueByKey = maxValueByKey;

var computeGridData = function computeGridData(data, maxDataValue, rowLabels, columnLabels, friendlyName) {
  var dataHash = data.reduce(function (acc, datum) {
    acc["".concat(datum.rowValue, ":").concat(datum.columnValue)] = datum;
    return acc;
  }, {});
  return rowLabels.map(function (row) {
    return columnLabels.map(function (column) {
      if (dataHash["".concat(row, ":").concat(column)]) {
        var cellData = dataHash["".concat(row, ":").concat(column)];
        cellData.maxDataValue = maxDataValue;
        cellData.friendlyName = friendlyName;
        return cellData;
      }

      return {
        count: 0,
        columnValue: column,
        maxDataValue: 0,
        rowValue: row,
        friendlyName: friendlyName
      };
    });
  });
};
/**
 * Compute a list of data for the left side grid
 * @param {array} tableBodyData an object with properties used to populate left side grid
 */


exports.computeGridData = computeGridData;

var computeLeftSideData = function computeLeftSideData(tableBodyData) {
  var data = tableBodyData.reduce(function (acc, _ref) {
    var friendlyName = _ref.friendlyName,
        rowLabels = _ref.rowLabels,
        maxDataValue = _ref.maxDataValue,
        maxDiameter = _ref.maxDiameter;

    if (!rowLabels) {
      return acc;
    }

    var title = {
      type: 'title',
      value: friendlyName,
      maxDataValue: maxDataValue,
      maxDiameter: maxDiameter
    };
    var labels = rowLabels.map(function (label) {
      return {
        type: 'label',
        value: label
      };
    });
    return [].concat(_toConsumableArray(acc), [title], _toConsumableArray(labels));
  }, []);
  return data;
};
/**
 * Compute a matrix of data for the main body of the pivot table
 * @param {array} tableBodyData an object with properties used to populate left side grid
 */


exports.computeLeftSideData = computeLeftSideData;

function computeBodyData(tableBodyData) {
  var data = tableBodyData.reduce(function (acc, _ref2) {
    var gridData = _ref2.gridData;

    if (!gridData) {
      return acc;
    }

    var blankRow = gridData[0].map(function () {
      return null;
    });
    return [].concat(_toConsumableArray(acc), [blankRow], _toConsumableArray(gridData));
  }, []);
  return data;
}
/**
 * Compute the data to be used by the left side grid and the main body grid
 * @param {array} data from transform
 * @param {array} tableMetadataList metadata from config
 * @param {array} columnLabels list of objects used for the column header grid
 * @param {number} cellHeight
 * @param {number} cellWidth
 */


var computeTableBodyData = function computeTableBodyData(data, tableMetadataList, columnLabels, cellHeight, cellWidth) {
  var tableBodyData = tableMetadataList.map(function (_ref3) {
    var rowDimension = _ref3.rowDimension,
        friendlyName = _ref3.friendlyName,
        labelAccessorKey = _ref3.labelAccessorKey;
    var rowLabels = data["label_".concat(rowDimension)].map(function (label) {
      return label[labelAccessorKey];
    });
    var tableData = data["data_".concat(rowDimension)];
    var maxDataValue = maxValueByKey(tableData, 'count');
    var gridData = computeGridData(tableData, maxDataValue, rowLabels, columnLabels, friendlyName);
    return {
      friendlyName: friendlyName,
      rowLabels: rowLabels,
      gridData: gridData,
      maxDataValue: maxDataValue,
      maxDiameter: Math.min(cellHeight, cellWidth)
    };
  });
  return {
    leftSideData: computeLeftSideData(tableBodyData),
    bodyData: computeBodyData(tableBodyData)
  };
};

exports.computeTableBodyData = computeTableBodyData;

var getLongestRowLabelLength = function getLongestRowLabelLength(leftSideData) {
  // if type is title, provide extra space for info icon
  var values = leftSideData.map(function (d) {
    return d.type === 'title' ? "".concat(d.value, "MMMM") : d.value;
  });
  return (0, _stringHelper.calculateLongestStringWidth)(values);
};
/**
 * Memoized computation for getting a bubble size
 * @param {number} count value for bubble
 * @param {number} maxDataValue max value for bubble
 * @param {number} maxDiameter largest diameter for bubble
 * @param {number} SCALED_MAX_DIAMETER number used to scale size
 * @param {number} MIN_NONZERO_DIAMETER smallest diameter for nonzero value bubble
 */


exports.getLongestRowLabelLength = getLongestRowLabelLength;
var computeDiameterCache = {};

var computeDiameter = function computeDiameter(count, maxDataValue, maxDiameter, SCALED_MAX_DIAMETER, MIN_NONZERO_DIAMETER) {
  var cacheKey = "".concat(count, ":").concat(maxDataValue);

  if (!computeDiameterCache[cacheKey]) {
    computeDiameterCache[cacheKey] = count > 0 ? Math.max(Math.sqrt(count / maxDataValue) * SCALED_MAX_DIAMETER * maxDiameter, MIN_NONZERO_DIAMETER) : 0;
  }

  return computeDiameterCache[cacheKey];
};

exports.computeDiameter = computeDiameter;