@sis-cc/dotstatsuite-components 17.28.0 → 17.30.0

package/lib/rules2/src/hasCellMetadata.js

@@ -12,6 +12,9 @@ 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 hasCellMetadata = exports.hasCellMetadata = function hasCellMetadata(metadataCoordinates, cellCoordinates) {
+  if (R.propOr('OBS_VALUE', 'OBS_ATTRIBUTES', cellCoordinates) !== 'OBS_VALUE') {
+    return false;
+  }
   return R.pipe(R.find(function (coordinates) {
     var mergedCoord = R.mergeLeft(coordinates, cellCoordinates);
     return !R.isEmpty(coordinates) && R.equals(mergedCoord, cellCoordinates);

package/lib/rules2/src/parseAttributes.js

@@ -23,7 +23,8 @@ var parseAttributes = exports.parseAttributes = function parseAttributes(attribu
   var indexedDimensions = R.indexBy(R.prop('id'), dimensions);
   return R.addIndex(R.map)(function (attr, index) {
     var res = R.assoc('index', index, attr);
-    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr) || attr.id === _constants.REPORTING_YEAR_START_DAY || attr.id === _constants.REPYEARSTART) {
+    var displayableValuesCount = R.pipe(R.filter(R.propOr(true, 'display')), R.length)(attr);
+    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr) || displayableValuesCount < 1 || attr.id === _constants.REPORTING_YEAR_START_DAY || attr.id === _constants.REPYEARSTART) {
       return R.assoc('display', false, res);
     }
     if (R.propEq('id', customAttributes.prefscale, attr)) {

package/lib/rules2/src/table/getLayoutData2.js

@@ -241,7 +241,6 @@ var getLayoutData = function getLayoutData(layoutIndexes, layout, _ref) {
 	    sections = layoutIndexes.sections,
 	    rest = (0, _objectWithoutProperties3.default)(layoutIndexes, ['header', 'sections']);
 
-
 	var headerData = R.reduce(function (acc, serie) {
 		var datas = getSerieDataWithMissingLines(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
 		return R.concat(acc, datas);

package/lib/rules2/src/table/getTableLayoutIds.js

@@ -123,10 +123,9 @@ var injectCombinationsInLayout = exports.injectCombinationsInLayout = function i
       if (idsInRowsSet.has(id)) return R.over(R.lensIndex(1), R.append(id), _acc);
       return R.over(R.lensIndex(2), R.append(id), _acc);
     }, [[], [], []], rest),
-        _R$reduce2 = (0, _slicedToArray3.default)(_R$reduce, 3),
+        _R$reduce2 = (0, _slicedToArray3.default)(_R$reduce, 2),
         idsInSections = _R$reduce2[0],
-        idsInRows = _R$reduce2[1],
-        nowhere = _R$reduce2[2];
+        idsInRows = _R$reduce2[1];
 
     if (!R.isEmpty(idsInHeader) && R.isEmpty(idsInSections) && R.isEmpty(idsInRows)) {
       layoutRelationships.header = R.concat(layoutRelationships.header, relationship);
@@ -178,7 +177,17 @@ var getLayoutCombinations = exports.getLayoutCombinations = function getLayoutCo
   }, [], combinations);
 };
 
-var extractConcepts = function extractConcepts(ids, indexedCombinations) {
+var extractConcepts = function extractConcepts(ids, indexedCombinations, layoutDimsIds) {
+  var entry = R.find(function (id) {
+    if (R.has(id, indexedCombinations)) {
+      var dimId = R.find(function (i) {
+        return layoutDimsIds.has(i);
+      }, R.pathOr([], [id, 'concepts'], indexedCombinations));
+      return !R.isNil(dimId);
+    }
+    return true;
+  }, ids);
+
   var getRelationship = function getRelationship(id) {
     if (R.has(id, indexedCombinations)) {
       return R.append(id, R.path([id, 'relationship'], indexedCombinations));
@@ -189,7 +198,7 @@ var extractConcepts = function extractConcepts(ids, indexedCombinations) {
     return R.assoc(id, getRelationship(id), acc);
   }, {}, ids);
 
-  var relationship = [R.head(ids)];
+  var relationship = [entry];
   while (!R.isEmpty(indexedRels)) {
     var related = R.pickBy(function (rels) {
       return !R.isEmpty(R.intersection(relationship, rels));
@@ -206,20 +215,30 @@ var extractConcepts = function extractConcepts(ids, indexedCombinations) {
   }, ids);
 };
 
-var injectRemainingDimensionsInLayout = exports.injectRemainingDimensionsInLayout = function injectRemainingDimensionsInLayout(layoutIds, remainingDims, indexedCombinations) {
+var injectRemainingDimensionsInLayout = exports.injectRemainingDimensionsInLayout = function injectRemainingDimensionsInLayout(layoutIds, remainingDims, indexedCombinations, layoutDimsIds) {
   var _layout = layoutIds;
   var _remaining = remainingDims;
 
-  if (R.isEmpty(_layout.rows)) {
+  var dimInRows = R.find(function (id) {
+    if (layoutDimsIds.has(id)) {
+      return true;
+    }
+    var dimId = R.find(function (i) {
+      return layoutDimsIds.has(i);
+    }, R.pathOr([], [id, 'concepts'], indexedCombinations));
+    return !R.isNil(dimId);
+  }, _layout.rows);
+
+  if (R.isNil(dimInRows)) {
     if (R.isEmpty(_remaining)) {
       var toTakeIn = R.isEmpty(_layout.sections) ? 'header' : 'sections';
 
-      var _extractConcepts = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations),
+      var _extractConcepts = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations, layoutDimsIds),
           _extractConcepts2 = (0, _slicedToArray3.default)(_extractConcepts, 2),
           extracted = _extractConcepts2[0],
           remains = _extractConcepts2[1];
 
-      _layout = (0, _extends4.default)({}, _layout, (0, _defineProperty3.default)({ rows: extracted }, toTakeIn, remains));
+      _layout = (0, _extends4.default)({}, _layout, (0, _defineProperty3.default)({ rows: R.concat(_layout.rows, extracted) }, toTakeIn, remains));
     } else {
       _layout = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(_layout);
       _remaining = R.tail(_remaining);
@@ -240,6 +259,7 @@ var injectRemainingDimensionsInLayout = exports.injectRemainingDimensionsInLayou
 var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(defaultLayoutIds, dimensions, attributes, combinations) {
   var layoutDimsIds = getLayoutDimsIds(dimensions);
   var layoutCombinations = getLayoutCombinations(combinations, layoutDimsIds, attributes);
+
   var combinationsConcepts = R.pipe(R.pluck('_concepts'), R.unnest, function (ids) {
     return new _set2.default(ids);
   })(combinations);
@@ -292,5 +312,5 @@ var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(d
       nextLayout = _R$reduce4.nextLayout,
       remaining = _R$reduce4.remaining;
 
-  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations);
+  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations, layoutDimsIds);
 };

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

@@ -276,8 +276,12 @@ var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref
         truncated = _truncateLayout.truncated,
         extractedKeys = _truncateLayout.extractedKeys;
 
+    var dimsLength = R.pipe(R.values, R.head, R.propOr([], 'orderedDimIndexes'), R.length)(observations);
+    var _layout = R.map(R.map(function (entry) {
+      return entry.id === 'OBS_ATTRIBUTES' ? R.assoc('__index', dimsLength - 1, entry) : entry;
+    }), layout);
     var curatedObs = R.pipe(getShape, function (shape) {
-      return getCuratedCells({ layout: layout, observations: observations, shape: shape });
+      return getCuratedCells({ layout: _layout, observations: observations, shape: shape });
     })(isVertical);
 
     var refined = refineLayout(isVertical)(toRefine, extractedKeys, curatedObs);

package/package.json

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

package/src/rules2/src/hasCellMetadata.js

@@ -1,6 +1,9 @@
 import * as R from 'ramda';
 
 export const hasCellMetadata = (metadataCoordinates, cellCoordinates) => {
+  if (R.propOr('OBS_VALUE', 'OBS_ATTRIBUTES', cellCoordinates) !== 'OBS_VALUE') {
+    return false;
+  }
   return R.pipe(
     R.find(coordinates => {
       const mergedCoord = R.mergeLeft(coordinates, cellCoordinates);

package/src/rules2/src/parseAttributes.js

@@ -5,8 +5,13 @@ export const parseAttributes = (attributes, dimensions, customAttributes) => {
   const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
   return R.addIndex(R.map)((attr, index) => {
     let res = R.assoc('index', index, attr);
+    const displayableValuesCount = R.pipe(
+      R.filter(R.propOr(true, 'display')),
+      R.length,
+    )(attr);
     if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr)
-      || attr.id === REPORTING_YEAR_START_DAY || attr.id === REPYEARSTART) {
+      || displayableValuesCount < 1 || attr.id === REPORTING_YEAR_START_DAY
+      || attr.id === REPYEARSTART) {
       return R.assoc('display', false, res);
     }
     if (R.propEq('id', customAttributes.prefscale, attr)) {

package/src/rules2/src/table/getLayoutData2.js

@@ -167,7 +167,6 @@ export const getSerieDataWithoutMissingLines = (serie, definition, topCoordinate
 
 export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes, topCoordinates={} }) => {
   const { header, sections, ...rest } = layoutIndexes;
-
   const headerData = R.reduce((acc, serie) => {
   	const datas = getSerieDataWithMissingLines(serie, layout.header, topCoordinates, attributesSeries, customAttributes, metadataCoordinates);
   	return R.concat(acc, datas);

package/src/rules2/src/table/getTableLayoutIds.js

@@ -57,7 +57,7 @@ export const injectCombinationsInLayout = (combinations, layoutIds) => {
       i => idsInHeaderSet.has(i),
       relationship
     );
-    const [idsInSections, idsInRows, nowhere] = R.reduce((_acc, id) => {
+    const [idsInSections, idsInRows] = R.reduce((_acc, id) => {
       if (idsInSectionsSet.has(id))
         return R.over(R.lensIndex(0), R.append(id), _acc);
       if (idsInRowsSet.has(id))
@@ -122,7 +122,15 @@ export const getLayoutCombinations = (combinations, layoutDimsIds, attributes) =
   );
 };
 
-const extractConcepts = (ids, indexedCombinations) => {
+const extractConcepts = (ids, indexedCombinations, layoutDimsIds) => {
+  const entry = R.find(id => {
+    if (R.has(id, indexedCombinations)) {
+      const dimId = R.find(i => layoutDimsIds.has(i), R.pathOr([], [id, 'concepts'], indexedCombinations));
+      return !R.isNil(dimId);
+    }
+    return true;
+  }, ids);
+
   const getRelationship = id => {
     if (R.has(id, indexedCombinations)) {
       return R.append(id, R.path([id, 'relationship'], indexedCombinations));
@@ -133,7 +141,7 @@ const extractConcepts = (ids, indexedCombinations) => {
     R.assoc(id, getRelationship(id), acc)
   , {}, ids);
   
-  let relationship = [R.head(ids)];
+  let relationship = [entry];
   while (!R.isEmpty(indexedRels)) {
     const related = R.pickBy(rels => !R.isEmpty(R.intersection(relationship, rels)), indexedRels);
     if (R.isEmpty(related)) {
@@ -146,15 +154,23 @@ const extractConcepts = (ids, indexedCombinations) => {
   return R.partition(id => set.has(id), ids);
 }
 
-export const injectRemainingDimensionsInLayout = (layoutIds, remainingDims, indexedCombinations) => {
+export const injectRemainingDimensionsInLayout = (layoutIds, remainingDims, indexedCombinations, layoutDimsIds) => {
   let _layout = layoutIds;
   let _remaining = remainingDims;
 
-  if (R.isEmpty(_layout.rows)) {
+  const dimInRows = R.find(id => {
+    if (layoutDimsIds.has(id)) {
+      return true;
+    }
+    const dimId = R.find(i => layoutDimsIds.has(i), R.pathOr([], [id, 'concepts'], indexedCombinations));
+    return !R.isNil(dimId);
+  }, _layout.rows);
+
+  if (R.isNil(dimInRows)) {
     if (R.isEmpty(_remaining)) {
       const toTakeIn = R.isEmpty(_layout.sections) ? 'header' : 'sections';
-      const [extracted, remains] = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations);
-      _layout = ({ ..._layout, rows: extracted, [toTakeIn]: remains });
+      const [extracted, remains] = extractConcepts(R.prop(toTakeIn, _layout), indexedCombinations, layoutDimsIds);
+      _layout = ({ ..._layout, rows: R.concat(_layout.rows, extracted), [toTakeIn]: remains });
     }
     else {
       _layout = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(_layout);
@@ -186,6 +202,7 @@ export const getTableLayoutIds = (
     layoutDimsIds,
     attributes,
   );
+
   const combinationsConcepts = R.pipe(R.pluck('_concepts'), R.unnest, ids => new Set(ids))(combinations);
   const obsAttributes = R.filter(a => 
     a.series && R.isEmpty(a.relationship || []) && a.display && !combinationsConcepts.has(a)
@@ -244,5 +261,5 @@ export const getTableLayoutIds = (
     return R.over(R.lensProp('remaining'), R.append(dim.id))(acc);
   }, { nextLayout: layoutWithCombs, remaining: [] }, dimensions);
 
-  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations);
+  return injectRemainingDimensionsInLayout(nextLayout, remaining, indexedCombinations, layoutDimsIds);
 };

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

@@ -299,9 +299,14 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
 
   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, observations, shape })
+    (shape) => getCuratedCells({ layout: _layout, observations, shape })
   )(isVertical);
 
 

package/test/getCells.test.js

@@ -115,4 +115,47 @@ describe('getCells tests', () => {
       }
     });
   });
+  it('metadata and OBS_ATTRIBUTES', () => {
+    const _customAttributes = {
+      flags: [],
+      notes: []
+    };
+
+    const combinations = {
+      cells: [],
+      layout: []
+    };
+
+    const observations = {
+      'a': {
+        value: 'val',
+        formattedValue: 'val',
+        attributes: {},
+        indexedDimValIds: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' }
+      },
+      'b': {
+        value: 'attr val',
+        formattedValue: 'attr val',
+        attributes: {},
+        indexedDimValIds: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'A' }
+      }
+    };
+    const metadataCoordinates = [{ d0: 'v0', d1: 'v0' }];
+    expect(getCells(_customAttributes, {}, combinations, {}, metadataCoordinates)(observations)).to.deep.equal({
+      'a': {
+        value: 'val',
+        intValue: null,
+        indexedDimValIds: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' },
+        sideProps: { hasAdvancedAttributes: false, hasMetadata: true, coordinates: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' } },
+        flags: []
+      },
+      'b': {
+        value: 'attr val',
+        intValue: null,
+        indexedDimValIds: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'A' },
+        sideProps: null,
+        flags: []
+      }
+    });
+  });
 });

package/test/getTableLayoutIds.test.js

@@ -224,4 +224,28 @@ describe('getTableLayoutIds tests', () => {
       rows: ['D4']
     });
   });
+  it('nothing in rows with combination without dimensions', () => {
+    const combinations = [{
+      id: 'COMB',
+      concepts: ['A1', 'A2']
+    }];
+    const attributes = [
+      { id: 'A1', series: true, relationship: ['D1'] },
+      { id: 'A2', series: true, relationship: ['D1'] },
+    ]
+    const dimensions = [
+      { id: 'D1' },
+      { id: 'D2' },
+    ];
+    const layoutIds = {
+      header: ['D2'],
+      sections: ['COMB', 'D1'],
+      rows: ['D3']
+    };
+    expect(getTableLayoutIds(layoutIds, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['D2'],
+      sections: [],
+      rows: ['COMB', 'D1']
+    });
+  });
 });

package/test/refineLayoutSize2.test.js

@@ -403,6 +403,109 @@ describe('refineLayoutSize 2 tests', () => {
       })(layoutIndexes)
     ).to.deep.equal(expected);
   });
+  it('truncation with OBS_ATTRIBUTES in layout', () => {
+    const layout = {
+      header: [{ __index: 1 }, { id: 'OBS_ATTRIBUTES' }],
+      rows: [{ __index: 0 }],
+      sections: [],
+    };
+
+    const layoutIndexes = {
+      header: [
+        { indexes: [0, 0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [0, 1], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1, 0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1, 1], parentsIndexes: [[]], missingIndexes: [[]] },
+      ],
+      sections: [
+        [
+          { indexes: [] },
+          [
+            { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [2], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [3], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [4], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [5], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [6], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [7], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [8], parentsIndexes: [[]], missingIndexes: [[]] },
+          ]
+        ]
+      ]
+    };
+
+    const observations = {
+      '0:0:0': { orderedDimIndexes: [0, 0, 0] },
+      '0:0:1': { orderedDimIndexes: [0, 0, 1] },
+      '0:1:0': { orderedDimIndexes: [0, 1, 0] },
+      '0:1:1': { orderedDimIndexes: [0, 1, 1] },    
+      '1:0:0': { orderedDimIndexes: [1, 0, 0] },
+      '1:0:1': { orderedDimIndexes: [1, 0, 1] },
+      '1:1:0': { orderedDimIndexes: [1, 1, 0] },
+      '1:1:1': { orderedDimIndexes: [1, 1, 1] },
+      '2:0:0': { orderedDimIndexes: [2, 0, 0] },
+      '2:0:1': { orderedDimIndexes: [2, 0, 1] },
+      '2:1:0': { orderedDimIndexes: [2, 1, 0] },
+      '2:1:1': { orderedDimIndexes: [2, 1, 1] },
+      '3:0:0': { orderedDimIndexes: [3, 0, 0] },
+      '3:0:1': { orderedDimIndexes: [3, 0, 1] },
+      '3:1:0': { orderedDimIndexes: [3, 1, 0] },
+      '3:1:1': { orderedDimIndexes: [3, 1, 1] },
+      '4:0:0': { orderedDimIndexes: [4, 0, 0] },
+      '4:0:1': { orderedDimIndexes: [4, 0, 1] },
+      '4:1:0': { orderedDimIndexes: [4, 1, 0] },
+      '4:1:1': { orderedDimIndexes: [4, 1, 1] },
+      '5:0:0': { orderedDimIndexes: [5, 0, 0] },
+      '5:0:1': { orderedDimIndexes: [5, 0, 1] },
+      '5:1:0': { orderedDimIndexes: [5, 1, 0] },
+      '5:1:1': { orderedDimIndexes: [5, 1, 1] },
+      '6:0:0': { orderedDimIndexes: [6, 0, 0] },
+      '6:0:1': { orderedDimIndexes: [6, 0, 1] },
+      '6:1:0': { orderedDimIndexes: [6, 1, 0] },
+      '6:1:1': { orderedDimIndexes: [6, 1, 1] },
+      '7:0:0': { orderedDimIndexes: [7, 0, 0] },
+      '7:0:1': { orderedDimIndexes: [7, 0, 1] },
+      '7:1:0': { orderedDimIndexes: [7, 1, 0] },
+      '7:1:1': { orderedDimIndexes: [7, 1, 1] },
+      '8:0:0': { orderedDimIndexes: [8, 0, 0] },
+      '8:0:1': { orderedDimIndexes: [8, 0, 1] },
+      '8:1:0': { orderedDimIndexes: [8, 1, 0] },
+      '8:1:1': { orderedDimIndexes: [8, 1, 1] },
+    };
+
+    const expected = {
+      header: [
+        { indexes: [0, 0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [0, 1], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1, 0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1, 1], parentsIndexes: [[]], missingIndexes: [[]] },
+      ],
+      sections: [
+        [
+          { indexes: [] },
+          [
+            { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [2], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [3], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [4], parentsIndexes: [[]], missingIndexes: [[]] },
+            { indexes: [5], parentsIndexes: [[]], missingIndexes: [[]] },
+          ]
+        ]
+      ],
+      truncated: true,
+      totalCells: 70
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations,
+        limit: 52
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
+  });
   /*it('no rows', () => {
 
     const layout = {