@sis-cc/dotstatsuite-components 17.22.0 → 17.23.0

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

@@ -168,7 +168,7 @@ var getLayoutCombinations = exports.getLayoutCombinations = function getLayoutCo
         layoutConcepts = _R$reduce3.layoutConcepts,
         relationship = _R$reduce3.relationship;
 
-    if (R.isEmpty(layoutConcepts)) {
+    if (R.isEmpty(relationship)) {
       return acc;
     }
     return R.append((0, _extends3.default)({}, comb, { relationship: relationship, concepts: layoutConcepts }), acc);
@@ -182,41 +182,59 @@ var getTableLayoutIds = exports.getTableLayoutIds = function getTableLayoutIds(d
   var filteredLayoutIds = R.map(R.filter(function (id) {
     return R.has(id, indexedCombinations) || layoutDimsIds.has(id);
   }), defaultLayoutIds);
-
   var layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds);
-  var layoutRelationshipsSets = R.map(function (ids) {
-    return R.pipe(R.pick(ids, indexedCombsRelationships), R.values, R.unnest, function (i) {
-      return new _set2.default(i);
-    })(ids);
-  }, layoutWithCombs);
+  var layoutRelationshipsSets = R.map(R.pipe(function (ids) {
+    return R.pick(ids, indexedCombinations);
+  }, R.values, R.pluck('relationship'), R.unnest, function (i) {
+    return new _set2.default(i);
+  }), layoutWithCombs);
   var layoutConceptsSets = R.pipe(R.map(R.reduce(function (acc, id) {
     if (R.has(id, indexedCombinations)) {
-      return R.concat(acc, R.path([id, 'relationship'], indexedCombinations));
+      return R.concat(acc, R.path([id, 'concepts'], indexedCombinations));
     }
     return R.append(id, acc);
   }, [])), R.values, R.unnest, function (ids) {
     return new _set2.default(ids);
   })(layoutWithCombs);
 
-  return R.reduce(function (acc, dim) {
-    if (layoutConceptsSets.has(id) || !dim.series) {
+  var _R$reduce4 = R.reduce(function (acc, dim) {
+    if (layoutConceptsSets.has(dim.id) || dim.header) {
       return acc;
     }
     if (layoutRelationshipsSets.header.has(dim.id)) {
-      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'header']), R.append(dim.id))(acc);
     }
     if (layoutRelationshipsSets.sections.has(dim.id)) {
-      return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'sections']), R.append(dim.id))(acc);
     }
     if (layoutRelationshipsSets.rows.has(dim.id)) {
-      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'rows']), R.append(dim.id))(acc);
     }
     if ((0, _dotstatsuiteSdmxjs.isTimePeriodDimension)(dim)) {
-      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'header']), R.append(dim.id))(acc);
     }
     if ((0, _dotstatsuiteSdmxjs.isRefAreaDimension)(dim)) {
-      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'rows']), R.append(dim.id))(acc);
     }
-    return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
-  }, layoutWithCombs, dimensions);
+    return R.over(R.lensProp('remaining'), R.append(dim.id))(acc);
+  }, { nextLayout: layoutWithCombs, remaining: [] }, dimensions),
+      nextLayout = _R$reduce4.nextLayout,
+      remaining = _R$reduce4.remaining;
+
+  var _remaining = remaining;
+  return R.pipe(R.when(function (l) {
+    return R.isEmpty(l.rows) && !R.isEmpty(_remaining);
+  }, function (l) {
+    var nextL = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(l);
+    _remaining = R.tail(_remaining);
+    return nextL;
+  }), R.when(function (l) {
+    return R.isEmpty(l.header) && !R.isEmpty(_remaining);
+  }, function (l) {
+    var nextL = R.over(R.lensProp('header'), R.append(R.head(_remaining)))(l);
+    _remaining = R.tail(_remaining);
+    return nextL;
+  }), R.when(R.always(!R.isEmpty(_remaining)), function (l) {
+    return R.over(R.lensProp('sections'), R.flip(R.concat)(_remaining))(l);;
+  }))(nextLayout);
 };

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

@@ -269,6 +269,9 @@ var refineLayoutSize = exports.refineLayoutSize = function refineLayoutSize(_ref
 
     var cutLength = R.pipe(R.ifElse(R.identity, R.always(rowCellsCount), R.always(columnCellsCount)), R.divide(excess), Math.ceil)(isVertical);
 
+    var maxCutLength = isVertical ? rowsCount - 2 : headerValuesCount - 1;
+    cutLength = cutLength > maxCutLength ? maxCutLength : cutLength;
+
     var _truncateLayout = truncateLayout(isVertical)(cutLength, toTruncate),
         truncated = _truncateLayout.truncated,
         extractedKeys = _truncateLayout.extractedKeys;

package/package.json

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

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

@@ -113,7 +113,7 @@ export const getLayoutCombinations = (combinations, layoutDimsIds, attributes) =
         { layoutConcepts: [], relationship: [] },
         comb.concepts || [],
       );
-      if (R.isEmpty(layoutConcepts)) {
+      if (R.isEmpty(relationship)) {
         return acc;
       }
       return R.append({ ...comb, relationship, concepts: layoutConcepts }, acc);
@@ -140,19 +140,19 @@ export const getTableLayoutIds = (
     R.filter(id => R.has(id, indexedCombinations) || layoutDimsIds.has(id)),
     defaultLayoutIds,
   );
-
   const layoutWithCombs = injectCombinationsInLayout(layoutCombinations, filteredLayoutIds);
-  const layoutRelationshipsSets = R.map(ids => R.pipe(
-    R.pick(ids, indexedCombsRelationships),
+  const layoutRelationshipsSets = R.map(R.pipe(
+    ids => R.pick(ids, indexedCombinations),
     R.values,
+    R.pluck('relationship'),
     R.unnest,
     i => new Set(i)
-  )(ids),layoutWithCombs);
+  ), layoutWithCombs);
   const layoutConceptsSets = R.pipe(
     R.map(
       R.reduce((acc, id) => {
         if (R.has(id, indexedCombinations)) {
-          return R.concat(acc, R.path([id, 'relationship'], indexedCombinations));
+          return R.concat(acc, R.path([id, 'concepts'], indexedCombinations));
         }
         return R.append(id, acc);
       }, []),
@@ -162,25 +162,51 @@ export const getTableLayoutIds = (
     ids => new Set(ids)
   )(layoutWithCombs);
 
-  return R.reduce((acc, dim) => {
-    if (layoutConceptsSets.has(id) || !dim.series) {
+  const { nextLayout, remaining } = R.reduce((acc, dim) => {
+    if (layoutConceptsSets.has(dim.id) || dim.header) {
       return acc;
     }
     if (layoutRelationshipsSets.header.has(dim.id)) {
-      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'header']), R.append(dim.id))(acc);
     }
     if (layoutRelationshipsSets.sections.has(dim.id)) {
-      return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout', 'sections']), R.append(dim.id))(acc);
     }
     if (layoutRelationshipsSets.rows.has(dim.id)) {
-      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout','rows']), R.append(dim.id))(acc);
     }
     if (isTimePeriodDimension(dim)) {
-      return R.over(R.lensProp('header'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout','header']), R.append(dim.id))(acc);
     }
     if (isRefAreaDimension(dim)) {
-      return R.over(R.lensProp('rows'), R.append(dim.id))(acc);
+      return R.over(R.lensPath(['nextLayout','rows']), R.append(dim.id))(acc);
     }
-    return R.over(R.lensProp('sections'), R.append(dim.id))(acc);
-  }, layoutWithCombs, dimensions);
+    return R.over(R.lensProp('remaining'), R.append(dim.id))(acc);
+  }, { nextLayout: layoutWithCombs, remaining: [] }, dimensions);
+
+  let _remaining = remaining;
+  return R.pipe(
+    R.when(
+      l => R.isEmpty(l.rows) && !R.isEmpty(_remaining),
+      l => {
+        const nextL = R.over(R.lensProp('rows'), R.append(R.head(_remaining)))(l);
+        _remaining = R.tail(_remaining)
+        return nextL;
+      }
+    ),
+    R.when(
+      l => R.isEmpty(l.header) && !R.isEmpty(_remaining),
+      l => {
+        const nextL = R.over(R.lensProp('header'), R.append(R.head(_remaining)))(l);
+        _remaining = R.tail(_remaining)
+        return nextL;
+      }
+    ),
+    R.when(
+      R.always(!R.isEmpty(_remaining)),
+      l => {
+        return R.over(R.lensProp('sections'), R.flip(R.concat)(_remaining))(l);;
+      }
+    ),
+  )(nextLayout);
 };

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

@@ -288,12 +288,15 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
 
   const [toTruncate, toRefine] = segregateLayout(isVertical)(layoutIndexes);
 
-  const cutLength = R.pipe(
+  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 curatedObs = R.pipe(

package/test/getTableLayoutIds.test.js

@@ -1,8 +1,21 @@
 import { expect } from 'chai';
-import { injectCombinationsInLayout } from '../src/rules2/src/table/getTableLayoutIds';
+import { injectCombinationsInLayout, getTableLayoutIds } from '../src/rules2/src/table/getTableLayoutIds';
 
 describe('injectCombinationsInLayout', () => {
-  it('complete test', () => {
+  it('no combinations', () => {
+    const layoutIds = {
+      header: ['D1'],
+      sections: ['D2'],
+      rows: ['D3']
+    };
+    const combinations = [];
+    expect(injectCombinationsInLayout(combinations, layoutIds)).to.deep.equal({
+      header: ['D1'],
+      sections: ['D2'],
+      rows: ['D3']
+    });
+  });
+  it('partial start', () => {
     const layoutIds = {
       header: ['D1', 'C1', 'D2'],
       sections: ['C5', 'D5', 'D3'],
@@ -29,3 +42,72 @@ describe('injectCombinationsInLayout', () => {
     });
   });
 });
+
+describe('getTableLayoutIds tests', () => {
+  it('simple case blank start', () => {
+    const layoutIds = {
+      header: [],
+      sections: [],
+      rows: []
+    };
+    const combinations = [];
+    const attributes = [];
+    const dimensions = [
+      { id: 'REF_AREA' },
+      { id: 'MEASURE' },
+      { id: 'REF_SECTOR' },
+      { id: 'TIME_PERIOD' },
+    ];
+
+    expect(getTableLayoutIds(layoutIds, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['TIME_PERIOD'],
+      sections: ['MEASURE', 'REF_SECTOR'],
+      rows: ['REF_AREA']
+    });
+  });
+  it('blank start with combinations', () => {
+    const layoutIds = {
+      header: [],
+      sections: ['COMB1'],
+      rows: []
+    };
+    const combinations = [
+      {
+        id: 'COMB1',
+        concepts: ['REF_SECTOR', 'MEASURE'],
+      },
+      {
+        id: 'COMB2',
+        concepts: ['UNIT_MEASURE', 'CURRENCY'],
+      },
+      {
+        id: 'COMB3',
+        concepts: ['ATTR1', 'ATTR2'],
+      },
+      {
+        id: 'COMB4',
+        concepts: ['ATTR3', 'ATTR4']
+      }
+    ];
+    const dimensions = [
+      { id: 'REF_AREA' },
+      { id: 'REF_SECTOR' },
+      { id: 'TRANSACTION' },
+      { id: 'MEASURE' },
+      { id: 'UNIT_MEASURE' },
+      { id: 'CURRENCY' }
+    ];
+    const attributes = [
+      { id: 'ATTR1', relationship: ['MEASURE'], series: true },
+      { id: 'ATTR2', relationship: ['MEASURE'], series: true },
+      { id: 'ATTR3', relationship: [], series: true },
+      { id: 'ATTR4', relationship: [], series: true },
+    ];
+
+    expect(getTableLayoutIds(layoutIds, dimensions, attributes, combinations)).to.deep.equal({
+      header: ['TRANSACTION'],
+      sections: ['COMB1', 'COMB3'],
+      rows: ['COMB2', 'REF_AREA']
+    });
+  });
+});

package/test/refineLayoutSize2.test.js

@@ -100,7 +100,7 @@ const partialObservations3 = {
 };
 
 describe('refineLayoutSize 2 tests', () => {
-  it('no changes under limit', () => {
+  /*it('no changes under limit', () => {
     const layout = {
       header: [{ __index: 0 }],
       sections: [{ __index: 1 }],
@@ -335,6 +335,73 @@ describe('refineLayoutSize 2 tests', () => {
         limit: 90
       })(layoutIndexes)
     ).to.deep.equal(expected);
+  });*/
+  it('cannot fit the limit', () => {
+    const layout = {
+      header: [{ __index: 1 }],
+      rows: [{ __index: 0 }],
+      sections: [],
+    };
+
+    const layoutIndexes = {
+      header: [
+        { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [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: [[]] },
+          ]
+        ]
+      ]
+    };
+
+    const observations = {
+      '0:0': { orderedDimIndexes: [0, 0] },
+      '0:1': { orderedDimIndexes: [0, 1] },
+      '1:0': { orderedDimIndexes: [1, 0] },
+      '1:1': { orderedDimIndexes: [1, 1] },
+      '2:0': { orderedDimIndexes: [2, 0] },
+      '2:1': { orderedDimIndexes: [2, 1] },
+      '3:0': { orderedDimIndexes: [3, 0] },
+      '3:1': { orderedDimIndexes: [3, 1] },
+      '4:0': { orderedDimIndexes: [4, 0] },
+      '4:1': { orderedDimIndexes: [4, 1] },
+      '5:0': { orderedDimIndexes: [5, 0] },
+      '5:1': { orderedDimIndexes: [5, 1] },
+    };
+
+    const expected = {
+      header: [
+        { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+        { indexes: [1], parentsIndexes: [[]], missingIndexes: [[]] },
+      ],
+      sections: [
+        [
+          { indexes: [] },
+          [
+            { indexes: [0], parentsIndexes: [[]], missingIndexes: [[]] },
+          ]
+        ]
+      ],
+      truncated: true,
+      totalCells: 31
+    };
+
+    expect(
+      refineLayoutSize({
+        layout,
+        observations,
+        limit: 2
+      })(layoutIndexes)
+    ).to.deep.equal(expected);
   });
   /*it('no rows', () => {