@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/src/rules2/src/table/refineLayoutSize2.js

@@ -1,321 +0,0 @@
-import * as R from 'ramda';
-
-const toKey = indexes => R.reduce(
-  (acc, _ind) => {
-    const ind = R.is(Array, _ind) ? toKey(_ind) : String(Math.abs(_ind));
-    if (R.isEmpty(ind)) {
-      return acc;
-    }
-    return R.isEmpty(acc) ? ind : `${acc}:${ind}`
-  },
-  '',
-  indexes
-);
-
-const getPivotKey = indexes => R.pipe(
-  R.props(indexes),
-  R.join(':')
-);
-
-const getPivots = (layout, shape) => R.pipe(
-  R.props(shape),
-  R.map(
-    R.pipe(
-      R.map(entry => R.has('dimensions', entry) ? R.pluck('__index', entry.dimensions || []) : entry.__index),
-      R.unnest,
-      getPivotKey
-    )
-  )
-)(layout);
-
-const indexWithPivots = (pivots, observations) => R.pipe(
-  R.values,
-  R.reduce(
-    (acc, obs) => {
-      const path = R.map(
-        pivot => pivot(obs.orderedDimIndexes),
-        pivots
-      );
-      return R.over(
-        R.lensPath(path),
-        R.ifElse(R.isNil, R.always([obs]), R.append(obs))
-      )(acc);
-    },
-    {}
-  )
-)(observations);
-
-export const getCuratedCells = ({ layout, observations, shape }) => {
-  const pivots = getPivots(layout, shape);
-  return indexWithPivots(pivots, observations);
-};
-
-const filterSeries = (series, getHasStillData) => {
-  let removedMissingIndexes = [];
-  return R.reduce((acc, serie) => {
-    const hasStillData = getHasStillData(serie);
-    const serieParentsSets = R.map(p => new Set(p), R.propOr([], 'parentsIndexes', serie));
-    if (!hasStillData) {
-      removedMissingIndexes = R.addIndex(R.map)((mIs, ind) => {
-        const filtered = R.filter(i => serieParentsSets[ind].has(i), R.nth(ind, removedMissingIndexes) || []);
-        return R.concat(filtered, mIs);
-      }, serie.missingIndexes || []);
-      return acc;
-    }
-    const _serie = R.pipe(
-      R.over(
-        R.lensProp('missingIndexes'),
-        (missingIndexes = []) => R.addIndex(R.map)((mIs, ind) => {
-          const removed = R.nth(ind, removedMissingIndexes) || [];
-          if (R.isEmpty(removed)) {
-            return mIs;
-          }
-          const filteredRemoved = R.filter(i => serieParentsSets[ind].has(i), removed);
-          return R.concat(filteredRemoved, mIs || []);
-        }, missingIndexes)
-      ),
-      R.over(
-        R.lensProp('parentsIndexes'),
-        (parentsIndexes = []) => R.addIndex(R.map)((p, ind) => {
-          return R.reject(i => R.includes(i, R.nth(ind, removedMissingIndexes) || []), p || []);
-        }, parentsIndexes)
-      )
-    )(serie);
-    removedMissingIndexes = [];
-    return R.append(_serie, acc);
-  }, [], series);
-};
-
-export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
-  R.map(
-    (section) => {
-      const sectionKey = toKey(R.propOr([], 'indexes', R.head(section)));
-      const getHasRowStillData = (row) => {
-        const rowKey = toKey(R.prop('indexes', row));
-        return R.pipe(
-          R.path([sectionKey, rowKey]),
-          R.omit(extractedKeys),
-          R.isEmpty,
-          R.not
-        )(curatedObs);
-      };
-      return R.over(
-        R.lensIndex(1),
-        rows => filterSeries(rows, getHasRowStillData)
-      )(section);
-    }
-  ),
-  R.filter(
-    R.pipe(R.nth(1), R.isEmpty, R.not)
-  )
-)(sections);
-
-export const refineHeader = (headers, extractedKeys, curatedObs) => {
-  const getHasHeaderStillData = (header) => {
-    const headerKey = toKey(R.prop('indexes', header));
-    return R.pipe(
-      R.prop(headerKey),
-      (sections) => {
-        return R.pickBy(
-          (rows, section) => R.pipe(
-            R.omit(R.propOr([], section, extractedKeys)),
-            R.isEmpty,
-            R.not
-          )(rows),
-          sections
-        );
-      },
-      R.isEmpty,
-      R.not
-    )(curatedObs);
-  };
-  return filterSeries(headers, getHasHeaderStillData);
-};
-
-const getSerieLinesCount = serie => {
-  const missingParents = R.propOr([], 'missingParents', serie);
-  const missingParentsRowsCount = R.pipe(R.flatten, R.length)(missingParents);
-  return missingParentsRowsCount + 1;
-}
-
-export const truncateSectionRows = (n, sectionsData) => {
-  let truncated = sectionsData;
-  let extractedKeys = {};
-  let _n = n;
-  while (_n > 0) {
-    const lastSection = R.last(truncated);
-    const rows = lastSection[1];
-    const rowsLength = R.length(rows);
-    let truncatedRowsCount = 0;
-    while (_n > 0 && truncatedRowsCount !== rowsLength) {
-      const rowsCount = getSerieLinesCount(R.nth(-1 * truncatedRowsCount, rows));
-      _n = _n - rowsCount;
-      truncatedRowsCount++;
-    }
-    const sectionKey = R.pipe(R.head, R.prop('indexes'), toKey)(lastSection);
-    extractedKeys = {
-      ...extractedKeys,
-      [sectionKey]: R.pipe(
-        R.takeLast(truncatedRowsCount),
-        R.map(r => toKey(R.prop('indexes', r)))
-      )(rows)
-    };
-    if (_n > 0) {
-      truncated = R.dropLast(1, truncated);
-    }
-    else {
-      truncated = R.over(R.lensIndex(-1), R.over(R.lensIndex(1), R.dropLast(truncatedRowsCount)))(truncated);
-    }
-  }
-  return ({ truncated, extractedKeys });
-};
-
-export const truncateHeader = (n, headerData) => {
-  let { truncated, extractedKeys } = { truncated: headerData, extractedKeys: [] };
-  let _n = n;
-  while (_n > 0) {
-    const lastHeader = R.last(truncated);
-    const columnsCount = getSerieLinesCount(lastHeader);
-    const extractedKey = toKey(R.prop('indexes', lastHeader));
-    extractedKeys = R.append(extractedKey, extractedKeys);
-    truncated = R.dropLast(1, truncated);
-    _n = _n - columnsCount;
-  }
-  return ({ truncated, extractedKeys });
-};
-
-const truncateLayout = (isVertical) => R.ifElse(
-  R.always(isVertical),
-  truncateSectionRows,
-  truncateHeader,
-);
-
-const refineLayout = (isVertical) => R.ifElse(
-  R.always(isVertical),
-  refineHeader,
-  refineSections
-)
-
-const getShape = isVertical => isVertical ? ['header', 'sections', 'rows'] : ['sections', 'rows', 'header'];
-
-const getRefinedLayout = (isVertical, truncated, refined) => R.ifElse(
-  R.always(isVertical),
-  R.pipe(R.assoc('sections', truncated), R.assoc('header', refined)),
-  R.pipe(R.assoc('header', truncated), R.assoc('sections', refined)),
-)({});
-
-const segregateLayout = (isVertical) => R.ifElse(
-  R.always(isVertical),
-  R.props(['sections', 'header']),
-  R.props(['header', 'sections'])
-);
-
-export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndexes => {
-  const { header, sections } = layoutIndexes;
-  if (R.isNil(limit) || limit === 0 || R.all(R.isEmpty, [header, sections])) {
-    return R.pipe(
-      R.set(R.lensProp('truncated'), false), 
-      R.set(R.lensProp('totalCells'), null), 
-    )(layoutIndexes);
-  }
-
-  //number of dimensions in header
-  const headerDimCount = R.pipe(
-    R.head, // first column
-    R.when(R.isNil, R.always({})),
-    R.propOr([], 'indexes'),
-    R.length // number of dims
-  )(header);
-
-  //number of columns for values
-  const headerValuesCount = R.pipe(
-    R.reduce((acc, header) => {
-      const columnsCount = getSerieLinesCount(header);
-      return acc + columnsCount;
-    }, 0),
-    R.when(R.equals(0), R.always(1))
-  )(header);
-
-  //total of cells in header
-  const headerCellsCount = headerDimCount * (headerValuesCount + 1);
-
-  // number of dimensions in a row
-  const rowDimCount = R.pipe(
-    R.head, // firstSection
-    R.last, // rows,
-    R.head, // first row
-    R.propOr([], 'indexes'),
-    R.length
-  )(sections);
-
-  // number of cells in a row
-  const rowCellsCount = rowDimCount + headerValuesCount + 1;
-
-  // number of rows
-  const rowsCount = R.pipe(
-    R.map(R.last),
-    R.unnest,
-    R.reduce((acc, row) => {
-      const rowsCount = getSerieLinesCount(row);
-      return acc + rowsCount;
-    }, 1)
-  )(sections);
-
-  // total of cells in all rows
-  const rowsCellsCount = rowCellsCount * rowsCount;
-
-  // number of sections cells
-  const sectionsCellsCount = R.ifElse(
-    R.pipe(R.head, R.head, R.propOr([], 'indexes'), R.length, R.equals(0)),
-    R.always(0),
-    R.length
-  )(sections);
-
-  const total = rowsCellsCount + sectionsCellsCount + headerCellsCount;
-
-  const excess = total - limit;
-  if (excess <= 0) {
-    return R.pipe(
-      R.set(R.lensProp('truncated'), false), 
-      R.set(R.lensProp('totalCells'), total), 
-    )(layoutIndexes);
-  }
-
-  // total of cells in one column
-  const columnCellsCount = headerDimCount + rowsCount;
-
-  const isVertical = columnCellsCount > rowCellsCount;
-
-  const [toTruncate, toRefine] = segregateLayout(isVertical)(layoutIndexes);
-
-  let cutLength = R.pipe(
-    R.ifElse(R.identity, R.always(rowCellsCount), R.always(columnCellsCount)),
-    R.divide(excess),
-    Math.ceil
-  )(isVertical);
-
-  const maxCutLength = isVertical ? rowsCount - 2 : headerValuesCount - 1;
-  cutLength = cutLength > maxCutLength ? maxCutLength : cutLength;
-
-  const { truncated, extractedKeys } = truncateLayout(isVertical)(cutLength, toTruncate);
-
-  const dimsLength = R.pipe(R.values, R.head, R.propOr([], 'orderedDimIndexes'), R.length)(observations);
-  const _layout = R.map( 
-    R.map(entry => entry.id === 'OBS_ATTRIBUTES' ? R.assoc('__index', dimsLength - 1, entry) : entry),
-    layout
-  );
-  const curatedObs = R.pipe(
-    getShape,
-    (shape) => getCuratedCells({ layout: _layout, observations, shape })
-  )(isVertical);
-
-
-  const refined = refineLayout(isVertical)(toRefine, extractedKeys, curatedObs);
-
-  const result = getRefinedLayout(isVertical, truncated, refined);
-
-  return R.pipe(
-    R.set(R.lensProp('truncated'), true), 
-    R.set(R.lensProp('totalCells'), total), 
-  )(result);
-};

package/src/rules2/src/utils.js

@@ -1,37 +0,0 @@
-import * as R from 'ramda';
-
-export const trimedProps = (properties, obj) => R.reduce(
-  (acc, prop) => {
-    if (R.isNil(R.prop(prop, obj))) {
-      return acc;
-    }
-    return R.append(obj[prop], acc);
-  },
-  [],
-  properties,
-);
-
-export const getLayoutCoordinatesValidator = (layoutCoordinates, topCoordinates={}) => (coordinates) => {
-  if (R.isEmpty(coordinates)) {
-    return false;
-  }
-  if (R.has('OBS_ATTRIBUTES', layoutCoordinates) || R.has('OBS_ATTRIBUTES', topCoordinates)) {
-    const obsAttrCoord = R.prop('OBS_ATTRIBUTES', layoutCoordinates)
-    || R.prop('OBS_ATTRIBUTES', topCoordinates);
-    if (obsAttrCoord !== 'OBS_VALUE') {
-      return false;
-    }
-  }
-  const keys = R.keys(coordinates);
-  let res = true;
-  let notInTop = {};
-  R.forEach(key => {
-    if (R.prop(key, layoutCoordinates) !== R.prop(key, coordinates)) {
-      res = false;
-    }
-    if (!R.has(key, topCoordinates)) {
-      notInTop[key] = key;
-    }
-  }, keys);
-  return res && !R.isEmpty(notInTop);
-};

package/src/viewer/mocks/bar.js

@@ -1,33 +0,0 @@
-export default () => ({
-  chartData: {
-    series: [
-      { datapoints: [
-          {x: 'Hungary', y: 5.5},
-          {x: 'Sweden', y: 5.6},
-          {x: 'Estonia', y: 5.7},
-          {x: 'Finland', y: 5.8},
-          {x: 'Belgium', y: 5.9},
-          {x: 'Turkey', y: 6},
-          {x: 'France', y: 6.5},
-          {x: 'Poland', y: 6.6},
-          {x: 'Slovenia', y: 6.8},
-          {x: 'European Union', y: 7.4, baselineIndex: 0},
-          {x: 'Euro area (18 countries)', y: 8.2},
-          {x: 'Ireland', y: 8.7, highlightIndex: 0},
-          {x: 'Italy', y: 8.9},
-          {x: 'Slovak Republic', y: 9.9},
-          {x: 'Portugal', y: 10.9},
-          {x: 'South Africa', y: 12.3, highlightIndex: 1},
-          {x: 'Spain (2 digits)', y: 16.86 }
-        ]
-      }
-    ]
-  },
-  headerProps: {
-    title: { label: 'Science performance (PISA)' },
-    subtitle: [{ label: 'Mean score 2015, Annual incl. OECD, all countries' }],
-  },
-  footerProps: {
-    source: { label: 'data.oecd.org', link: 'http://data.oecd.org/' }
-  }
-});

package/src/viewer/mocks/gpp-symbol.js

@@ -1,93 +0,0 @@
-export default () => ({
-  headerProps: {
-    "title": { label: "Growth previous period - Annual - 2015" },
-  },
-  footerProps: {
-    soure: { label: 'source', link: 'http://dotstat.oecd.org/' }
-  },
-  chartData: {
-  "series": [
-    {
-      "datapoints": [
-        {
-          "category": "Finland",
-          "values": [
-            -0.958831808585503,
-            -0.938640709195226
-          ],
-          highlightIndex: 0
-        },
-        {
-          "category": "Canada",
-          "values": [
-            -0.734931326089172,
-            0.178223109790082
-          ]
-        },
-        {
-          "category": "Belgium",
-          "values": [
-            -0.0160655474335108,
-            0.177647331428157
-          ],
-          highlightIndex: 1
-        },
-        {
-          "category": "Chile",
-          "values": [
-            0.230172987500003,
-            0.286348587500551
-          ]
-        },
-        {
-          "category": "Estonia",
-          "values": [
-            0.292360493199452,
-            1.4055978394304
-          ]
-        },
-        {
-          "category": "Australia",
-          "values": [
-            1.18005263064255,
-            -1.70548071959404
-          ],
-          baselineIndex: 0
-        },
-        {
-          "category": "Denmark",
-          "values": [
-            1.18634492777014,
-            2.47915590644139
-          ]
-        },
-        {
-          "category": "France",
-          "values": [
-            1.96360436882936,
-            1.92806480043649
-          ]
-        },
-        {
-          "category": "Austria",
-          "values": [
-            2.11995066296641,
-            2.36545969532268
-          ]
-        },
-        {
-          "category": "Czech Republic",
-          "values": [
-            4.62318401937048,
-            6.01902272562258
-          ]
-        }
-      ],
-      "symbolValues": [
-        "Industrial production, s.a.",
-        "Total manufacturing, s.a."
-      ]
-    }
-  ],
-  }
-})