@sis-cc/dotstatsuite-components 17.12.5 → 17.13.0

package/lib/rules2/src/table/{refineLayoutSize.js → refineLayoutSize2.js}

@@ -5,17 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.refineLayoutSize = exports.truncateHeader = exports.truncateSectionRows = exports.refineHeader = exports.refineSections = exports.getCuratedCells = undefined;
 
-var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
 
-var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
 
-var _extends4 = require('babel-runtime/helpers/extends');
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
 
-var _extends5 = _interopRequireDefault(_extends4);
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
 
-var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+var _extends3 = require('babel-runtime/helpers/extends');
 
-var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+var _extends4 = _interopRequireDefault(_extends3);
 
 var _ramda = require('ramda');
 
@@ -62,9 +62,9 @@ var getCuratedCells = exports.getCuratedCells = function getCuratedCells(_ref) {
 
 var refineSections = exports.refineSections = function refineSections(sections, extractedKeys, curatedObs) {
   return R.pipe(R.map(function (section) {
-    var sectionKey = toKey(R.head(section) || []);
-    return R.over(R.lensIndex(1), R.filter(function (rowData) {
-      var rowKey = toKey(rowData);
+    var sectionKey = toKey(R.propOr([], 'indexes', R.head(section)));
+    return R.over(R.lensIndex(1), R.filter(function (row) {
+      var rowKey = toKey(R.prop('indexes', row));
       return R.pipe(R.path([sectionKey, rowKey]), R.omit(extractedKeys), R.isEmpty, R.not)(curatedObs);
     }))(section);
   }), R.filter(R.pipe(R.nth(1), R.isEmpty, R.not)))(sections);
@@ -73,7 +73,7 @@ var refineSections = exports.refineSections = function refineSections(sections,
 var refineHeader = exports.refineHeader = function refineHeader(header, extractedKeys, curatedObs) {
   return R.filter( // extracted : { [sectionKey]: [...rowKeys] }
   function (header) {
-    var headerKey = toKey(header);
+    var headerKey = toKey(R.prop('indexes', header));
     return R.pipe(R.prop(headerKey), function (sections) {
       return R.pickBy(function (rows, section) {
         return R.pipe(R.omit(R.propOr([], section, extractedKeys)), R.isEmpty, R.not)(rows);
@@ -82,6 +82,12 @@ var refineHeader = exports.refineHeader = function refineHeader(header, extracte
   })(header);
 };
 
+var getSerieLinesCount = function getSerieLinesCount(serie) {
+  var missingParents = R.propOr([], 'missingParents', serie);
+  var missingParentsRowsCount = R.pipe(R.flatten, R.length)(missingParents);
+  return missingParentsRowsCount + 1;
+};
+
 var truncateSectionRows = exports.truncateSectionRows = function truncateSectionRows(n, sectionsData) {
   var truncated = sectionsData;
   var extractedKeys = {};
@@ -90,33 +96,40 @@ var truncateSectionRows = exports.truncateSectionRows = function truncateSection
     var lastSection = R.last(truncated);
     var rows = lastSection[1];
     var rowsLength = R.length(rows);
-    var sectionKey = toKey(R.head(lastSection));
-    if (rowsLength > _n) {
-      var _R$splitAt = R.splitAt(R.negate(_n), rows),
-          _R$splitAt2 = (0, _slicedToArray3.default)(_R$splitAt, 2),
-          rest = _R$splitAt2[0],
-          extracted = _R$splitAt2[1];
-
-      var updatedSection = R.set(R.lensIndex(1), rest)(lastSection);
-      truncated = R.set(R.lensIndex(-1), updatedSection)(truncated);
-      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(toKey, extracted)));
-      _n = 0;
-    } else {
+    var truncatedRowsCount = 0;
+    while (_n > 0 && truncatedRowsCount !== rowsLength) {
+      var rowsCount = getSerieLinesCount(R.nth(-1 * truncatedRowsCount, rows));
+      _n = _n - rowsCount;
+      truncatedRowsCount++;
+    }
+    var sectionKey = R.pipe(R.head, R.prop('indexes'), toKey)(lastSection);
+    extractedKeys = (0, _extends4.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.pipe(R.takeLast(truncatedRowsCount), R.map(function (r) {
+      return toKey(R.prop('indexes', r));
+    }))(rows)));
+    if (_n > 0) {
       truncated = R.dropLast(1, truncated);
-      extractedKeys = (0, _extends5.default)({}, extractedKeys, (0, _defineProperty3.default)({}, sectionKey, R.map(toKey, rows)));
-      _n = _n - rowsLength;
+    } else {
+      truncated = R.over(R.lensIndex(-1), R.over(R.lensIndex(1), R.dropLast(truncatedRowsCount)))(truncated);
     }
   }
   return { truncated: truncated, extractedKeys: extractedKeys };
 };
 
 var truncateHeader = exports.truncateHeader = function truncateHeader(n, headerData) {
-  var _R$splitAt3 = R.splitAt(R.negate(n))(headerData),
-      _R$splitAt4 = (0, _slicedToArray3.default)(_R$splitAt3, 2),
-      truncated = _R$splitAt4[0],
-      extracted = _R$splitAt4[1];
+  var _truncated$extractedK = { truncated: headerData, extractedKeys: [] },
+      truncated = _truncated$extractedK.truncated,
+      extractedKeys = _truncated$extractedK.extractedKeys;
 
-  return { truncated: truncated, extractedKeys: R.map(toKey, extracted) };
+  var _n = n;
+  while (_n > 0) {
+    var lastHeader = R.last(truncated);
+    var columnsCount = getSerieLinesCount(lastHeader);
+    var extractedKey = toKey(R.prop('indexes', lastHeader));
+    extractedKeys = R.append(extractedKey, extractedKeys);
+    truncated = R.dropLast(1, truncated);
+    _n = _n - columnsCount;
+  }
+  return { truncated: truncated, extractedKeys: extractedKeys };
 };
 
 var truncateLayout = function truncateLayout(isVertical) {
@@ -153,11 +166,14 @@ var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref
 
     //number of dimensions in header
     var headerDimCount = R.pipe(R.head, // first column
-    R.when(R.isNil, R.always([])), R.length // number of dims
+    R.when(R.isNil, R.always({})), R.propOr([], 'indexes'), R.length // number of dims
     )(header);
 
     //number of columns for values
-    var headerValuesCount = R.pipe(R.length, R.when(R.equals(0), R.always(1)))(header);
+    var headerValuesCount = R.pipe(R.reduce(function (acc, header) {
+      var columnsCount = getSerieLinesCount(header);
+      return acc + columnsCount;
+    }, 0), R.when(R.equals(0), R.always(1)))(header);
 
     //total of cells in header
     var headerCellsCount = headerDimCount * (headerValuesCount + 1);
@@ -166,19 +182,22 @@ var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref
     var rowDimCount = R.pipe(R.head, // firstSection
     R.last, // rows,
     R.head, // first row
-    R.length)(sections);
+    R.propOr([], 'indexes'), R.length)(sections);
 
     // number of cells in a row
     var rowCellsCount = rowDimCount + headerValuesCount + 1;
 
     // number of rows
-    var rowsCount = R.pipe(R.map(R.last), R.unnest, R.length, R.add(1))(sections);
+    var rowsCount = R.pipe(R.map(R.last), R.unnest, R.reduce(function (acc, row) {
+      var rowsCount = getSerieLinesCount(row);
+      return acc + rowsCount;
+    }, 1))(sections);
 
     // total of cells in all rows
     var rowsCellsCount = rowCellsCount * rowsCount;
 
     // number of sections cells
-    var sectionsCellsCount = R.ifElse(R.pipe(R.head, R.head, R.length, R.equals(0)), R.always(0), R.length)(sections);
+    var sectionsCellsCount = R.ifElse(R.pipe(R.head, R.head, R.propOr([], 'indexes'), R.length, R.equals(0)), R.always(0), R.length)(sections);
 
     var total = rowsCellsCount + sectionsCellsCount + headerCellsCount;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "17.12.5",
+  "version": "17.13.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

package/src/rules2/src/{hierarchiseDimensionWithAdvancedHierarchy.js → hierarchiseDimensionWithAdvancedHierarchy2.js}

@@ -60,25 +60,27 @@ export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, _hierarchy)
   const indexed = R.indexBy(R.prop('id'), dimension.values);
   const hierarchy = refinePartialHierarchy(_hierarchy, indexed);
 
-  let rest = indexed;
-  const getChildren = (parents, hier) => R.pipe(
-    ids => {
-      rest = R.omit(ids, rest);
-      return R.props(ids, indexed)
-    },
-    R.filter(R.identity),
-    R.map(
-      (val) => {
-        const _val = {
-          ...val,
-          parent: R.last(parents),
-          parents
-        };
-        const children = getChildren(R.append(val.id, parents), hier);
-        return R.prepend(_val, children);
-      },
-    )
-  )(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hier));
+  const rest = R.pipe(
+    R.values,
+    R.unnest,
+    R.flip(R.omit)(indexed),
+    R.values,
+  )(hierarchy);
+  let index = R.length(rest) - 1;
+  const getChildren = ({ parentsIndexes, parentId }) => {
+    const childrenIds = R.propOr([], parentId, hierarchy);
+    const children = R.reduce((acc, childId) => {
+      if (!R.has(childId, indexed)) {
+        return acc;
+      }
+      index = index + 1;
+      const child = { ...R.prop(childId, indexed), __indexPosition: index, parents: parentsIndexes, parent: R.isEmpty(parentsIndexes) ? undefined : R.pipe(R.split('.'), R.last)(parentId) };
+      const descendants = getChildren({ parentsIndexes: R.append(index, parentsIndexes), parentId: R.isEmpty(parentsIndexes) ? child.id : `${parentId}.${child.id}` });
+      return R.append(R.prepend(child, descendants), acc);
+    }, [], childrenIds);
+
+    return children;
+  }
 
   return R.set(
     R.lensProp('values'),
@@ -90,12 +92,11 @@ export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, _hierarchy)
           return values;
         }
         const sortedRest = R.pipe(
-          R.values,
-          R.map(val => ({ ...val, parent: undefined, parents: [] })),
-          R.sortBy(R.prop('__indexPosition'))
+          R.sortBy(R.prop('__indexPosition')),
+          R.addIndex(R.map)((val, ind) => ({ ...val, __indexPosition: ind, parent: undefined, parents: [] })),
         )(rest);
         return R.concat(sortedRest, values);
       }
-    )([], hierarchy)
+    )({ parentsIndexes: [], parentId: '#ROOT' })
   )(dimension);
 };

package/src/rules2/src/{hierarchiseDimensionWithNativeHierarchy.js → hierarchiseDimensionWithNativeHierarchy2.js}

@@ -1,28 +1,31 @@
-import * as R from 'ramda';
-
-export const hierarchiseDimensionWithNativeHierarchy = (dimension) => {
-  const values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
-  const indexed = R.indexBy(R.prop('id'), values);
-  const grouped = R.groupBy(val => val.parent && R.has(val.parent, indexed) ? val.parent : '#ROOT', values);
-
-  const getChildren = (parents) => {
-    const childs = R.propOr([], R.defaultTo('#ROOT', R.last(parents)), grouped);
-    return R.reduce(
-      (acc, child) => {
-        const refined = R.pipe(
-          R.assoc('parents', parents),
-          R.assoc('parent', R.last(parents)),
-        )(child);
-        const children = getChildren(R.append(child.id, parents));
-        return R.concat(acc, R.prepend(refined, children));
-      },
-      [],
-      childs
-    );
-  }
-
-  return R.set(
-    R.lensProp('values'),
-    getChildren([])
-  )(dimension);
-};
+import * as R from 'ramda';
+
+export const hierarchiseDimensionWithNativeHierarchy = (dimension) => {
+  const values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
+  const indexed = R.indexBy(R.prop('id'), values);
+  const grouped = R.groupBy(val => val.parent && R.has(val.parent, indexed) ? val.parent : '#ROOT', values);
+
+  let index = -1;
+  const getChildren = ({ parentsIndexes, parentId }) => {
+    const childs = R.propOr([], parentId, grouped);
+    return R.reduce(
+      (acc, child) => {
+        index = index + 1;
+        const refined = R.pipe(
+          R.assoc('__indexPosition', index),
+          R.assoc('parents', parentsIndexes),
+          R.assoc('parent', R.isEmpty(parentsIndexes) ? undefined : parentId),
+        )(child);
+        const children = getChildren({ parentsIndexes: R.append(index, parentsIndexes), parentId: child.id });
+        return R.concat(acc, R.prepend(refined, children));
+      },
+      [],
+      childs
+    );
+  }
+
+  return R.set(
+    R.lensProp('values'),
+    getChildren({ parentsIndexes: [], parentId: '#ROOT' })
+  )(dimension);
+};

package/src/rules2/src/index.js

@@ -11,11 +11,10 @@ export { getMSDInformations } from './getMSDInformations';
 export { getNotDisplayedIds } from './getNotDisplayedIds';
 export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsInData';
 export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';
-export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
 export { getMetadataCoordinates } from './getMetadataCoordinates';
 export { duplicateObs } from './duplicateObservations';
-export { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
-export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
+export { refinePartialHierarchy, hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
+export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
 export { getCombinationDefinitions } from './getCombinationDefinitions';
 export { refineDimensions } from './refineDimensions';
@@ -34,9 +33,9 @@ export { getHeaderCombinations } from './getHeaderCombinations';
 export { getHeaderCoordinates } from './getHeaderCoordinates';
 export { getLayout } from './table/getLayout';
 export { getSortedLayoutIndexes } from './table/getSortedLayoutIndexes';
-export { refineLayoutSize } from './table/refineLayoutSize';
+export { refineLayoutSize } from './table/refineLayoutSize2';
 export { getFlagsAndNotes } from './table/getFlagsAndNotes';
-export { getLayoutData } from './table/getLayoutData';
+export { getLayoutData } from './table/getLayoutData2';
 export { getCellsAttributesIds } from './table/getCellsAttributesIds';
 export { getCellsMetadataCoordinates } from './table/getCellsMetadataCoordinates';
 export { getIndexedCombinationsByDisplay } from './table/getIndexedCombinationsByDisplay';
@@ -46,3 +45,4 @@ export { prepareData } from './prepareData';
 export { getTableProps } from './table/getTableProps';
 export { getTableLabelAccessor } from './table/getTableLabelAccessor';
 export { parseValueHierarchy } from './table/parseValueHierarchy';
+export { parseLayoutIndexesHierarchies } from './table/parseSeriesIndexesHierarchies';

package/src/rules2/src/parseCombinations.js

@@ -1,58 +1,100 @@
 import * as R from 'ramda';
 import { REJECTED_VALUE_IDS } from './constants';
 
-const getDisplayableValues = values => R.filter(
-  val => !R.includes(R.prop('id', val), REJECTED_VALUE_IDS) && R.propOr(true, 'display', val),
-  values
+const getDisplayableValues = (values) =>
+  R.filter(
+    (val) =>
+      !R.includes(R.prop('id', val), REJECTED_VALUE_IDS) &&
+      R.propOr(true, 'display', val),
+    values,
+  );
+
+// invalid concepts:
+// - empty/null/undefined/!array values (so far)
+const hasInvalidValues = R.pipe(
+  R.prop('values'),
+  R.anyPass([R.isNil, R.complement(R.is(Array)), R.isEmpty]),
 );
+const isConceptInvalid = R.anyPass([hasInvalidValues /* add more... */]);
+const filterInvalidConcepts = R.filter(isConceptInvalid);
+// concepts is an array of ids... (misnamed!)
+const conceptIdsLens = R.lensProp('concepts');
+const rejectInvalidConceptIds =
+  (concepts = []) =>
+  (combinations = []) => {
+    const invalidConceptIds = R.pluck('id', filterInvalidConcepts(concepts));
+    return R.map(
+      R.over(conceptIdsLens, R.without(invalidConceptIds)),
+      combinations,
+    );
+  };
+
+export const parseCombinations = (
+  combinations,
+  parsedAttributes,
+  dimensions,
+) => {
+  const concepts = R.concat(dimensions, parsedAttributes);
 
-export const parseCombinations = (combinations, parsedAttributes, dimensions) => {
   const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
   const indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
 
-  return R.reduce(
-    (acc, comb) => {
+  return R.pipe(
+    rejectInvalidConceptIds(concepts),
+    R.reduce((acc, comb) => {
       let relationship = [];
       let ids = {};
       let displayable_values_count = 0;
-      const seriesConcepts = R.filter(
-        concept => {
-          if (R.has(concept, ids)) {
-            return false;
-          }
-          if (R.has(concept, indexedDimensions)) {
-            const dimension = R.prop(concept, indexedDimensions);
-            relationship = !dimension.header ? R.append(concept, relationship) : relationship;
-            ids = { ...ids, [concept]: concept };
-            displayable_values_count += R.length(dimension.values || []);
-            return !dimension.header;
-          }
-          else if (!R.has(concept, indexedAttributes)) {
-            return false;
-          }
-          const attribute = R.prop(concept, indexedAttributes);
-          const displayableValues = getDisplayableValues(attribute.values || []);
-          const isDisplayable = R.length(displayableValues) !== 0 && R.propOr(true, 'display', attribute);
-          relationship = attribute.series && isDisplayable
-              ? R.pipe(
-                R.reject(id => R.has(id, ids)),
+      const seriesConcepts = R.filter((concept) => {
+        if (R.has(concept, ids)) {
+          return false;
+        }
+        if (R.has(concept, indexedDimensions)) {
+          const dimension = R.prop(concept, indexedDimensions);
+          relationship = !dimension.header
+            ? R.append(concept, relationship)
+            : relationship;
+          ids = { ...ids, [concept]: concept };
+          displayable_values_count += R.length(dimension.values || []);
+          return !dimension.header;
+        } else if (!R.has(concept, indexedAttributes)) {
+          return false;
+        }
+        const attribute = R.prop(concept, indexedAttributes);
+        const displayableValues = getDisplayableValues(attribute.values || []);
+        const isDisplayable =
+          R.length(displayableValues) !== 0 &&
+          R.propOr(true, 'display', attribute);
+        relationship =
+          attribute.series && isDisplayable
+            ? R.pipe(
+                R.reject((id) => R.has(id, ids)),
                 R.concat(relationship),
               )(attribute.relationship)
-              : relationship;
-          ids = attribute.series ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) } : ids;
-          displayable_values_count = isDisplayable
-              ? displayable_values_count + R.length(displayableValues)
-              : displayable_values_count;
-          return attribute.series && isDisplayable;
-        },
-        comb.concepts
-      );
+            : relationship;
+        ids = attribute.series
+          ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) }
+          : ids;
+        displayable_values_count = isDisplayable
+          ? displayable_values_count + R.length(displayableValues)
+          : displayable_values_count;
+        return attribute.series && isDisplayable;
+      }, comb.concepts);
       if (R.isEmpty(seriesConcepts)) {
-        return R.append({ ...comb, header: true, display: displayable_values_count > 0 }, acc);
+        return R.append(
+          { ...comb, header: true, display: displayable_values_count > 0 },
+          acc,
+        );
       }
-      return R.append({ ...comb, series: true, relationship, display: displayable_values_count > 0 }, acc);
-    },
-    [],
-    combinations
-  );
+      return R.append(
+        {
+          ...comb,
+          series: true,
+          relationship,
+          display: displayable_values_count > 0,
+        },
+        acc,
+      );
+    }, []),
+  )(combinations);
 };

package/src/rules2/src/prepareData.js

@@ -11,8 +11,8 @@ import { getMetadataCoordinates } from './getMetadataCoordinates';
 import { getAttributesSeries } from './getAttributesSeries';
 import { getManyValuesDimensions } from './getManyValuesDimensions';
 import { getOneValueDimensions } from './getOneValueDimensions';
-import { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
-import { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
+import { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
+import { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
 import { getDataflowAttributes } from './getDataflowAttributes';
 import { getHeaderTitle } from './getHeaderTitle';
 import { getHeaderSubtitle } from './getHeaderSubtitle';

package/src/rules2/src/refineDimensions.js

@@ -5,15 +5,12 @@ export const refineDimensions = (dimensions=[], dataquery='') => {
 
   return R.addIndex(R.map)((dim, index) => {
     const selection = R.nth(index, selectionIds);
-    if (R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
-      return { ...dim, header: R.length(dim.values || []) <= 1 };
-    }
     const values = R.map(val => {
-      if (R.includes(val.id, selection)) {
-        return val;
+      if (R.includes(val.id, selection || []) || R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
+        return R.assoc('isSelected', true, val);
       }
       return R.assoc('empty', true, val);
     }, dim.values || []);
-    return { ...dim, values, header: R.length(values) <= 1 || R.length(selection) === 1 };
+    return { ...dim, values, header: R.length(values) <= 1 || (R.length(selection) === 1 && !R.isEmpty(R.head(selection))) };
   }, dimensions);
 };