@sis-cc/dotstatsuite-components 9.1.1 → 9.2.1

package/lib/rules/src/table/factories/refineLayoutHierarchy.js

@@ -1,61 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.refineLayoutHierarchy = undefined;
-
-var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
-
-var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
-
-var _ramda = require('ramda');
-
-var R = _interopRequireWildcard(_ramda);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var refineParents = function refineParents(parents, indexed) {
-  return R.pipe(R.converge(R.splitAt, [R.pipe(R.findLastIndex(R.flip(R.has)(indexed)), R.inc), R.identity]), function (_ref) {
-    var _ref2 = (0, _slicedToArray3.default)(_ref, 2),
-        presents = _ref2[0],
-        absents = _ref2[1];
-
-    var lastPresentParentId = R.last(presents);
-    return [R.ifElse(R.isNil, R.always([]), R.converge(R.append, [R.identity, R.pipe(R.flip(R.prop)(indexed), R.path(['value', 'parents']))]))(lastPresentParentId), absents];
-  })(parents);
-};
-
-var pushRow = function pushRow(row, last, acc) {
-  return {
-    refined: R.append(row, acc.refined),
-    indexed: R.assoc(R.path(['value', 'id'], last), last, acc.indexed)
-  };
-};
-
-var refineLayoutHierarchy = exports.refineLayoutHierarchy = function refineLayoutHierarchy(sectionsData, lastDimension) {
-  var lastDimIndexedValues = R.pipe(R.propOr([], 'values'), R.indexBy(R.prop('id')))(lastDimension);
-  return R.map(function (sectionData) {
-    return R.pipe(R.last, R.reduce(function (acc, row) {
-      var last = R.last(row);
-      if (R.anyPass([R.isNil, R.isEmpty])(R.path(['value', 'parents'], last))) {
-        return pushRow(row, last, acc);
-      }
-
-      var _refineParents = refineParents(R.path(['value', 'parents'], last), acc.indexed),
-          _refineParents2 = (0, _slicedToArray3.default)(_refineParents, 2),
-          presents = _refineParents2[0],
-          absents = _refineParents2[1];
-
-      var name = R.pipe(R.map(R.pipe(R.flip(R.prop)(lastDimIndexedValues), R.prop('name'))), R.append(R.path(['value', 'name'], last)), R.join(' > '))(absents);
-      var refinedLast = R.over(R.lensProp('value'), R.pipe(R.assoc('name', name), R.assoc('parents', presents)), last);
-      var refinedRow = R.pipe(R.dropLast(1), R.append(refinedLast))(row);
-      return pushRow(refinedRow, refinedLast, acc);
-    }, { refined: [], indexed: {} }), function (_ref3) {
-      var refined = _ref3.refined;
-      return [R.head(sectionData), refined];
-    })(sectionData);
-  }, sectionsData);
-};

package/lib/rules/src/table/preparators/parseObservations.js

@@ -1,76 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parseObservations = undefined;
-
-var _extends2 = require('babel-runtime/helpers/extends');
-
-var _extends3 = _interopRequireDefault(_extends2);
-
-var _ramda = require('ramda');
-
-var R = _interopRequireWildcard(_ramda);
-
-var _getAttributeValue = require('./getAttributeValue');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/*
-  unitsArtefacts = { dimensions: { series: {} }, attributes: { series: {} } }; 
-*/
-var getUnitsValues = function getUnitsValues(indexes, getDisplay) {
-  return R.mapObjIndexed(function (codelist) {
-    var valueIndex = R.prop(codelist.index, indexes);
-    if (R.isNil(valueIndex) || !getDisplay(codelist)) {
-      return null;
-    }
-    var value = R.path(['values', Number(valueIndex)], codelist);
-    if (R.isNil(value) || !getDisplay((0, _extends3.default)({}, value, { parent: codelist.id }))) {
-      return null;
-    }
-    return (0, _extends3.default)({}, R.pick(['id', 'name'], codelist), {
-      value: R.when(R.complement(R.isNil), R.assoc('index', Number(valueIndex)))(value)
-    });
-  });
-};
-var getObservationUnits = function getObservationUnits(_ref) {
-  var dimValuesIndexes = _ref.dimValuesIndexes,
-      attrValuesIndexes = _ref.attrValuesIndexes,
-      getDisplay = _ref.getDisplay;
-  return R.converge(R.merge, [R.pipe(R.pathOr({}, ['dimensions', 'series']), getUnitsValues(dimValuesIndexes, getDisplay)), R.pipe(R.pathOr({}, ['attributes', 'series']), getUnitsValues(attrValuesIndexes, getDisplay))]);
-};
-
-var parseObservations = exports.parseObservations = function parseObservations(observations, dimensions, obsAttributes, formatAttributes, unitsArtefacts, getDisplay) {
-  return R.mapObjIndexed(function (obs, key) {
-    var dimValuesIndexes = R.split(':', key);
-    var indexedDimValIds = R.addIndex(R.reduce)(function (acc, dimValIndex, dimIndex) {
-      var dimension = R.nth(dimIndex, dimensions) || {};
-      var value = R.pipe(R.propOr([], 'values'), R.find(R.propEq('__index', Number(dimValIndex))), R.when(R.isNil, R.always({})))(dimension);
-      return R.assoc(dimension.id, value.id, acc);
-    }, {}, dimValuesIndexes);
-    var value = R.head(obs);
-    var attrValuesIndexes = R.tail(obs);
-    var units = getObservationUnits({ dimValuesIndexes: dimValuesIndexes, attrValuesIndexes: attrValuesIndexes, getDisplay: getDisplay })(unitsArtefacts);
-    var attributes = R.mapObjIndexed(function (attribute) {
-      return (0, _getAttributeValue.getAttributeValue)(attribute, R.nth(attribute.index, attrValuesIndexes));
-    }, obsAttributes);
-
-    var format = R.mapObjIndexed(function (attribute) {
-      var attributeValue = (0, _getAttributeValue.getAttributeValue)(attribute, R.nth(attribute.index, attrValuesIndexes));
-      return R.when(R.complement(R.isNil), R.path(['value', 'id']))(attributeValue);
-    }, formatAttributes);
-    return (0, _extends3.default)({}, format, {
-      value: value,
-      key: key,
-      indexedDimValIds: indexedDimValIds,
-      dimValuesIndexes: dimValuesIndexes,
-      attrValuesIndexes: attrValuesIndexes,
-      attributes: R.filter(R.complement(R.isNil), attributes),
-      units: units
-    });
-  }, observations);
-};

package/lib/rules/src/table/units/getUnitsSeriesOccurences.js

@@ -1,39 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getUnitsSeriesOccurences = undefined;
-
-var _ramda = require('ramda');
-
-var R = _interopRequireWildcard(_ramda);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-var getUnitsSeriesOccurences = exports.getUnitsSeriesOccurences = function getUnitsSeriesOccurences(_ref) {
-  var attachmentSeriesIndexes = _ref.attachmentSeriesIndexes;
-  return R.pipe(R.values, R.reduce(function (acc, observation) {
-    var serieKey = R.pipe(R.addIndex(R.map)(function (valueIndex, dimIndex) {
-      if (R.includes(dimIndex, attachmentSeriesIndexes)) {
-        return valueIndex;
-      }
-      return 'x';
-    }), R.join(':'))(observation.dimValuesIndexes);
-
-    var serie = R.pathOr({}, ['rawUnitsSeries', serieKey], acc);
-
-    var unitsOccurences = R.mapObjIndexed(R.ifElse(R.isNil, R.identity, R.path(['value', 'index'])), observation.units);
-
-    var updatedSerie = serie;
-    R.forEachObjIndexed(function (valueIndex, unitId) {
-      updatedSerie = R.over(R.lensProp(unitId), R.ifElse(R.isNil, R.always([valueIndex]), R.append(valueIndex)))(updatedSerie);
-    }, unitsOccurences);
-    updatedSerie = R.over(R.lensProp('observations'), R.ifElse(R.isNil, R.always(1), R.inc))(updatedSerie);
-
-    return R.evolve({
-      rawUnitsSeries: R.assoc(serieKey, updatedSerie),
-      obs: R.assoc(observation.key, R.assocPath(['units', 'serieKey'], serieKey, observation))
-    })(acc);
-  }, { rawUnitsSeries: {}, obs: {} }));
-};

package/src/rules/src/table/factories/getSortedLayoutData.js

@@ -1,133 +0,0 @@
-import * as R from 'ramda';
-
-const getSublayoutIndexToPositionPivots = dimensions => R.map(
-  (dimension) => {
-    const indexedPositions = R.reduce( // => [(entryIndex) : { ...val, __index }] => { [__index]: entryIndex }
-      (acc, value) => ({
-        ...acc,
-        [R.prop('__index', value)]: R.prop('__indexPosition', value)
-      }),
-      {},
-      R.prop('values', dimension)
-    );
-
-    return (splitKey) => R.pipe(
-      R.nth(R.prop('__index', dimension)),
-      index => R.prop(index, indexedPositions)
-    )(splitKey);
-  },
-  dimensions
-);
-
-const coordinatesToSublayoutData = (sublayout, coordinates) => R.addIndex(R.map)(
-  (valueIndex, dimensionIndex) => {
-    const sublayoutDimension = R.nth(dimensionIndex, sublayout);
-    const value = R.find(R.propEq('__indexPosition', valueIndex), R.prop('values', sublayoutDimension));
-    return ({
-      dimension: R.pick(['id', 'name', '__index'], sublayoutDimension),
-      value,
-    });
-  },
-  coordinates
-);
-
-export const getSortedLayoutData = (layout, observations) => {
-  const headersPivots = getSublayoutIndexToPositionPivots(R.prop('header', layout));
-  const rowsPivots = getSublayoutIndexToPositionPivots(R.prop('rows', layout));
-  const sectionsPivots = getSublayoutIndexToPositionPivots(R.prop('sections', layout));
-
-  const rowsSize = R.length(R.prop('rows', layout));
-  const sectionsSize = R.length(R.prop('sections', layout));
-
-  const sortedLayoutPositions = R.pipe(
-    R.keys,
-    R.map(
-      key => {
-        const splitKey = R.split(':', key);
-        return R.converge((...rest) => rest, [...sectionsPivots, ...rowsPivots, ...headersPivots])(splitKey);
-      }
-    ), 
-    R.map(
-      (coordinates) => {
-        const [sections, tail] = R.splitAt(sectionsSize, coordinates);
-        const [rows, headers] = R.splitAt(rowsSize, tail);
-        return { headers, rows, sections };
-      }
-    )
-  )(observations);
-
-  const headerData = R.pipe(
-    R.pluck('headers'),
-    R.uniq,
-    R.map(
-      (coordinates) => coordinatesToSublayoutData(R.prop('header', layout), coordinates)
-    ),
-    (headerData) => {
-      if (R.isEmpty(headerData)) {
-        return headerData;
-      }
-      const comparators = R.pipe(
-        R.head,
-        R.length,
-        (length) => R.times(R.identity, length),
-        R.map(index => R.ascend(R.pathOr(0, [index, 'value', '__indexPosition']))) 
-      )(headerData);
-
-      return R.sortWith(comparators)(headerData);
-    }
-  )(sortedLayoutPositions);
-
-  const sectionsData = R.pipe(
-    R.reduce((acc, layout) => {
-      const sections = layout.sections;
-
-      const index = R.findIndex(R.pathEq([0, 'sections'], sections))(acc);
-      if (index === -1) {
-        return R.append([layout], acc);
-      }
-      return R.over(R.lensIndex(index), R.append(layout))(acc);
-    },
-    []),
-    R.map(
-      (entries) => {
-        const sectionData = coordinatesToSublayoutData(R.prop('sections', layout), R.prop('sections', R.head(entries)));
-        const rowsData = R.map(
-          (coordinates) => coordinatesToSublayoutData(R.prop('rows', layout), coordinates),
-          R.uniq(R.pluck('rows', entries))
-        );
-        return [sectionData, rowsData];
-      }
-    ),
-    sData => { //sort sections
-      if (R.isEmpty(sData) || R.isEmpty(R.head(R.head(sData)))) {
-        return sData;
-      }
-      const comparators = R.pipe(
-        R.head,
-        R.head,
-        R.length,
-        (length) => R.times(R.identity, length),
-        R.map(index => R.ascend(R.pathOr(0, [0, index, 'value', '__indexPosition']))) 
-      )(sData);
-
-     return R.sortWith(comparators)(sData); 
-    },
-    sData => { //sort rows
-      if (R.isEmpty(sData) || R.isEmpty(R.last(R.head(sData)))) {
-        return sData;
-      }
-      const comparators = R.pipe(
-        R.head,
-        R.last,
-        R.head,
-        R.length,
-        (length) => R.times(R.identity, length),
-        R.map(index => R.ascend(R.pathOr(0, [index, 'value', '__indexPosition'])))
-      )(sData);
-
-      return R.map(R.over(R.lensIndex(1), R.sortWith(comparators)))(sData);
-    }
-  )(sortedLayoutPositions);
-
-  return { headerData, sectionsData };
-};

package/src/rules/src/table/factories/refineLayoutHierarchy.js

@@ -1,64 +0,0 @@
-import * as R from 'ramda';
-
-const refineParents = (parents, indexed) => R.pipe(
-  R.converge(
-    R.splitAt,
-    [
-      R.pipe(R.findLastIndex(R.flip(R.has)(indexed)), R.inc),
-      R.identity
-    ]
-  ),
-  ([presents, absents]) => {
-    const lastPresentParentId = R.last(presents);
-    return [
-      R.ifElse(
-        R.isNil,
-        R.always([]),
-        R.converge(R.append, [R.identity, R.pipe(R.flip(R.prop)(indexed), R.path(['value', 'parents']))])
-      )(lastPresentParentId),
-      absents
-    ];
-  }
-)(parents);
-
-const pushRow = (row, last, acc) => ({
-  refined: R.append(row, acc.refined),
-  indexed: R.assoc(R.path(['value', 'id'], last), last, acc.indexed)
-});
-
-export const refineLayoutHierarchy = (sectionsData, lastDimension) => {
-  const lastDimIndexedValues = R.pipe(
-    R.propOr([], 'values'),
-    R.indexBy(R.prop('id'))
-  )(lastDimension);
-  return R.map(
-    (sectionData) => R.pipe(
-      R.last,
-      R.reduce(
-        (acc, row) => {
-          const last = R.last(row);
-          if (R.anyPass([R.isNil, R.isEmpty])(R.path(['value', 'parents'], last))) {
-            return pushRow(row, last, acc);
-          }
-          const [presents, absents] = refineParents(R.path(['value', 'parents'], last), acc.indexed);
-          const name = R.pipe(
-            R.map(
-              R.pipe(R.flip(R.prop)(lastDimIndexedValues), R.prop('name'))),
-            R.append(R.path(['value', 'name'], last)),
-            R.join(' > ')
-          )(absents);
-          const refinedLast = R.over(
-            R.lensProp('value'),
-            R.pipe(R.assoc('name', name), R.assoc('parents', presents)),
-            last
-          );
-          const refinedRow = R.pipe(R.dropLast(1), R.append(refinedLast))(row);
-          return pushRow(refinedRow, refinedLast, acc);
-        },
-        { refined: [], indexed: {} }
-      ),
-      ({ refined }) => ([R.head(sectionData), refined])
-    )(sectionData),
-    sectionsData
-  );
-};

package/src/rules/src/table/preparators/parseObservations.js

@@ -1,81 +0,0 @@
-import * as R from 'ramda';
-import { getAttributeValue } from './getAttributeValue';
-/*
-  unitsArtefacts = { dimensions: { series: {} }, attributes: { series: {} } }; 
-*/
-const getUnitsValues = (indexes, getDisplay) => R.mapObjIndexed(
-  (codelist) => {
-    const valueIndex = R.prop(codelist.index, indexes);
-    if (R.isNil(valueIndex) || !getDisplay(codelist)) {
-      return null;
-    }
-    const value = R.path(['values', Number(valueIndex)], codelist);
-    if (R.isNil(value) || !getDisplay({ ...value, parent: codelist.id })) {
-      return null;
-    }
-    return ({
-      ...R.pick(['id', 'name'], codelist),
-      value: R.when(R.complement(R.isNil), R.assoc('index', Number(valueIndex)))(value)
-    });
-  }
-);
-const getObservationUnits = ({ dimValuesIndexes, attrValuesIndexes, getDisplay }) => R.converge(
-  R.merge,
-  [
-    R.pipe(
-      R.pathOr({}, ['dimensions', 'series']),
-      getUnitsValues(dimValuesIndexes, getDisplay)
-    ),
-    R.pipe(
-      R.pathOr({}, ['attributes', 'series']),
-      getUnitsValues(attrValuesIndexes, getDisplay)
-    ),
-  ]
-);
-
-export const parseObservations = (observations, dimensions, obsAttributes, formatAttributes, unitsArtefacts, getDisplay) => R.mapObjIndexed(
-  (obs, key) => {
-    const dimValuesIndexes = R.split(':', key);
-    const indexedDimValIds = R.addIndex(R.reduce)(
-      (acc, dimValIndex, dimIndex) => {
-        const dimension = R.nth(dimIndex, dimensions) || {};
-        const value = R.pipe(
-          R.propOr([], 'values'),
-          R.find(R.propEq('__index', Number(dimValIndex))),
-          R.when(R.isNil, R.always({}))
-        )(dimension);
-        return R.assoc(dimension.id, value.id, acc);
-      },
-      {},
-      dimValuesIndexes
-    );
-    const value = R.head(obs);
-    const attrValuesIndexes = R.tail(obs);
-    const units = getObservationUnits({ dimValuesIndexes, attrValuesIndexes, getDisplay })(unitsArtefacts);
-    const attributes = R.mapObjIndexed(
-      (attribute) => {
-        return getAttributeValue(attribute, R.nth(attribute.index, attrValuesIndexes));
-      },
-      obsAttributes
-    );
-
-    const format = R.mapObjIndexed(
-      (attribute) => {
-        const attributeValue = getAttributeValue(attribute, R.nth(attribute.index, attrValuesIndexes));
-        return R.when(R.complement(R.isNil), R.path(['value', 'id']))(attributeValue);
-      },
-      formatAttributes
-    );
-    return ({
-      ...format,
-      value,
-      key,
-      indexedDimValIds,
-      dimValuesIndexes,
-      attrValuesIndexes,
-      attributes: R.filter(R.complement(R.isNil), attributes),
-      units
-    });
-  },
-  observations
-);

package/src/rules/src/table/units/getUnitsSeriesOccurences.js

@@ -1,51 +0,0 @@
-import * as R from 'ramda';
-
-export const getUnitsSeriesOccurences = ({ attachmentSeriesIndexes }) => R.pipe(
-  R.values,
-  R.reduce(
-    (acc, observation) => {
-      const serieKey = R.pipe(
-        R.addIndex(R.map)(
-          (valueIndex, dimIndex) => {
-            if (R.includes(dimIndex, attachmentSeriesIndexes)) {
-              return valueIndex;
-            }
-            return 'x';
-          }
-        ),
-        R.join(':')
-      )(observation.dimValuesIndexes);
-
-      const serie = R.pathOr({}, ['rawUnitsSeries', serieKey], acc);
-
-      const unitsOccurences = R.mapObjIndexed(
-        R.ifElse(R.isNil, R.identity, R.path(['value', 'index'])),
-        observation.units
-      );
-
-      let updatedSerie = serie;
-      R.forEachObjIndexed(
-        (valueIndex, unitId) => {
-          updatedSerie = R.over(
-            R.lensProp(unitId),
-            R.ifElse(R.isNil, R.always([valueIndex]), R.append(valueIndex))
-          )(updatedSerie)
-        },
-        unitsOccurences
-      );
-      updatedSerie = R.over(
-        R.lensProp('observations'),
-        R.ifElse(R.isNil, R.always(1), R.inc)
-      )(updatedSerie);
-
-      return R.evolve({
-        rawUnitsSeries: R.assoc(serieKey, updatedSerie),
-        obs: R.assoc(
-          observation.key,
-          R.assocPath(['units', 'serieKey'], serieKey, observation)
-        )
-      })(acc);
-    },
-    { rawUnitsSeries: {}, obs: {} }
-  )
-);