covutils/lib/transform.js

Utilities for creating, transforming, and handling Coverage Data objects.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.toCoverage = toCoverage;

var _constants = require('./constants.js');

var _validate = require('./validate.js');

var _subset = require('./subset.js');

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

/**
 * Wraps a Domain into a Coverage object by adding dummy parameter and range data.
 * 
 * @param {Domain} domain the Domain object
 * @return {Coverage}
 */
function toCoverage(domain) {
  (0, _validate.checkDomain)(domain);

  var dummyKey = 'domain';
  var dummyLabel = 'Domain';

  var assumeGrid = domain.axes.has('x') && domain.axes.has('y') && (domain.axes.get('x').values.length > 1 || domain.axes.get('y').values.length > 1);
  var categories = void 0;
  var categoryEncoding = void 0;
  var a = 'a';
  var av = 0;
  var b = 'b';
  var bv = 1;
  if (assumeGrid) {
    categories = [{
      id: a,
      label: { en: 'A' }
    }, {
      id: b,
      label: { en: 'B' }
    }];
    categoryEncoding = new Map([[a, [av]], [b, [bv]]]);
  } else {
    categories = [{
      id: a,
      label: { en: 'X' }
    }];
    categoryEncoding = new Map([[a, [av]]]);
  }

  var parameters = new Map();
  parameters.set(dummyKey, {
    key: dummyKey,
    observedProperty: {
      label: { en: dummyLabel },
      categories: categories
    },
    categoryEncoding: categoryEncoding
  });

  var shape = new Map([].concat(_toConsumableArray(domain.axes)).map(function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2);

    var name = _ref2[0];
    var axis = _ref2[1];
    return [name, axis.values.length];
  }));

  var get = void 0;
  if (assumeGrid) {
    (function () {
      // checkerboard pattern to see grid cells
      var isOdd = function isOdd(n) {
        return n % 2;
      };
      get = function get(_ref3) {
        var _ref3$x = _ref3.x;
        var x = _ref3$x === undefined ? 0 : _ref3$x;
        var _ref3$y = _ref3.y;
        var y = _ref3$y === undefined ? 0 : _ref3$y;
        return isOdd(x + y) ? av : bv;
      };
    })();
  } else {
    get = function get() {
      return av;
    };
  }

  var loadRange = function loadRange() {
    return Promise.resolve({
      shape: shape,
      dataType: 'integer',
      get: get
    });
  };

  var cov = {
    type: _constants.COVERAGE,
    // TODO remove domainProfiles in favour of domainType at some point
    domainProfiles: domain.profiles,
    domainType: domain.domainType,
    parameters: parameters,
    loadDomain: function loadDomain() {
      return Promise.resolve(domain);
    },
    loadRange: loadRange
  };
  addLoadRangesFunction(cov);
  addSubsetFunctions(cov);
  return cov;
}

function addSubsetFunctions(cov) {
  (0, _validate.checkCoverage)(cov);
  cov.subsetByIndex = _subset.subsetCoverageByIndex.bind(null, cov);
  cov.subsetByValue = _subset.subsetCoverageByValue.bind(null, cov);
}

function addLoadRangesFunction(cov) {
  (0, _validate.checkCoverage)(cov);
  function loadRanges(keys) {
    if (!keys) {
      keys = cov.parameters.keys();
    }
    return Promise.all([].concat(_toConsumableArray(keys)).map(cov.loadRange)).then(function (ranges) {
      return new Map(keys.map(function (key, i) {
        return [key, ranges[i]];
      }));
    });
  }
  cov.loadRanges = loadRanges;
}