@sis-cc/dotstatsuite-components 15.0.20 → 16.0.0

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

@@ -1,90 +0,0 @@
-import * as R from 'ramda';
-
-export const getRelevantLength = (attr) => R.pipe(
-  R.propOr([], 'values'),
-  R.filter(R.propOr(true, 'display')),
-  R.length
-)(attr);
-
-export const getUnitsArtefacts = ({ unitsDefinitionCodes=[], data }) => {
-  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], data);
-  const parsedUnitsDimensions = R.addIndex(R.reduce)(
-    (acc, dimension, index) => {
-      if (!R.includes(dimension.id, unitsDefinitionCodes)) {
-        return acc;
-      }
-      const length = R.pipe(R.propOr([], 'values'), R.length)(dimension);
-      if (length === 1) {
-        return R.evolve({ header: R.assoc(dimension.id, { ...dimension, index, header: true }) }, acc);
-      }
-      if (length > 1) {
-        return R.evolve({ series: R.assoc(dimension.id, { ...dimension, index }) }, acc);
-      }
-      return acc;
-    },
-    { header: {}, series: {} },
-    dimensions
-  );
-
-  const keyedDimensions = R.indexBy(R.prop('id'), dimensions);
-
-  const parsedUnitsAttributes = R.pipe(
-    R.pathOr([], ['data', 'structure', 'attributes', 'observation']),
-    R.addIndex(R.reduce)(
-      (acc, attr, index) => {
-        if(!R.includes(attr.id, unitsDefinitionCodes) || R.length(R.propOr([], 'values', attr)) === 0
-          || !R.propOr(true, 'display', attr)) {
-          return acc;
-        }
-        const length = getRelevantLength(attr);
-        if (length === 0) {
-          return acc;
-        }
-        if (R.hasPath(['relationship', 'none'], attr) || R.hasPath(['relationship', 'dataflow'], attr)) {
-          return R.assocPath(['header', attr.id], { ...attr, index, datasetLevel: true }, acc);
-        }
-        if ((R.path(['relationship', 'primaryMeasure'], attr) === 'OBS_VALUE')
-          || (R.hasPath(['relationship', 'observation'], attr))) {
-          return R.assocPath(['series', attr.id], { ...attr, index, observations: true }, acc);
-        }
-        const attachedDimensions = R.path(['relationship', 'dimensions'], attr);
-        if (R.isNil(attachedDimensions)) {
-          return acc;
-        }
-        const filteredAttachedDimensions = R.filter(
-          (id) => {
-            const dimension = R.propOr({}, id, keyedDimensions);
-            const nValues = R.pipe(R.propOr([], 'values'), R.length)(dimension);
-            return nValues > 1;
-          },
-          attachedDimensions
-        );
-        const level = R.isEmpty(filteredAttachedDimensions)
-          ? 'header'
-          : 'series';
-        return R.assocPath(
-          [level, attr.id],
-          { ...attr, index, relationship: { dimensions: filteredAttachedDimensions } },
-          acc
-        );
-      },
-      { header: {}, series: {} }
-    )
-  )(data);
-
-  const hasSeries = R.pipe(
-    R.all(R.isEmpty),
-    R.not
-  )([parsedUnitsDimensions.series, parsedUnitsAttributes.series]);
-
-  return ({
-    dimensions: R.evolve({
-      header: R.when(R.always(hasSeries), R.always({})),
-      series: R.when(R.always(hasSeries), R.merge(parsedUnitsDimensions.header))
-    })(parsedUnitsDimensions),
-    attributes: R.evolve({
-      header: R.when(R.always(hasSeries), R.always({})),
-      series: R.when(R.always(hasSeries), R.merge(parsedUnitsAttributes.header))
-    })(parsedUnitsAttributes)
-  });
-};

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

@@ -1,22 +0,0 @@
-import * as R from 'ramda';
-
-export const getUnitsCodes = ({ data, unitsDefinition }) => {
-  const dimensionsCodes = R.pipe(
-    R.pathOr([], ['data', 'structure', 'dimensions', 'observation']),
-    R.indexBy(R.prop('id')),
-    R.props(unitsDefinition),
-    R.pluck('id')
-  )(data);
-
-  const attributesCodes = R.pipe(
-    R.pathOr({}, ['data', 'structure', 'attributes']),
-    R.mapObjIndexed(
-      R.pipe(
-        R.filter(R.pipe(R.prop('id'), R.flip(R.includes)(unitsDefinition))),
-        R.pluck('id')
-      )
-    )
-  )(data);
-
-  return ({ dimensions: dimensionsCodes, attributes: attributesCodes });
-};

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

@@ -1,34 +0,0 @@
-import * as R from 'ramda';
-
-export const getUnitsDefinition = ({
-  data, // sdmxJson
-  defaultCodes, // [...codelistIds] 
-  annotationsDefinitionCodes // { concepts: [] }
-}) => {
-  const conceptsCodes = R.propOr([], 'concepts', annotationsDefinitionCodes);
-  if (R.anyPass([R.isNil, R.isEmpty])(conceptsCodes)) {
-    return defaultCodes;
-  }
-
-  const datasetAnnotations = R.converge(
-    R.props,
-    [
-      R.pathOr([], ['data', 'dataSets', 0, 'annotations']),
-      R.pathOr([], ['data', 'structure', 'annotations'])
-    ]
-  )(data);
-
-  const keyedDatasetAnnotations = R.indexBy(R.prop('type'), datasetAnnotations);
-  
-  const conceptsAnnotation = R.pipe(
-    R.props(conceptsCodes),
-    R.find(ann => !R.isNil(ann)),
-    R.when(R.isNil, R.always({}))
-  )(keyedDatasetAnnotations);
-
-  return R.pipe(
-    R.propOr('', 'title'),
-    R.split(','),
-    R.when(R.equals(['']), R.always(defaultCodes))
-  )(conceptsAnnotation);
-};

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

@@ -1,19 +0,0 @@
-import * as R from 'ramda';
-
-export const getUnitsDisplay = ({ unitsAttachmentSeriesIds, layoutIds }) => {
-  if (R.isEmpty(unitsAttachmentSeriesIds)) {
-    return 'cells';
-  }
-  const headerIntersections = R.intersection(layoutIds.header, unitsAttachmentSeriesIds);
-  if (R.length(headerIntersections) === R.length(unitsAttachmentSeriesIds)) {
-    return 'header';
-  }
-  if (!R.isEmpty(headerIntersections)) {
-    return 'cells';
-  }
-  const sectionsIntersections = R.intersection(layoutIds.sections, unitsAttachmentSeriesIds);
-  if (R.length(sectionsIntersections) === R.length(unitsAttachmentSeriesIds)) {
-    return 'sections';
-  }
-  return 'rows';
-};

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

@@ -1,12 +0,0 @@
-import * as R from 'ramda';
-
-//=> [{ dimension: { __index: 0 }, value: { __index: 0 } }] x { '0:x:x:x': {} }
-export const getUnitsSerieIndexes = ({ unitsIndexes, partialUnitSerieIndexes }) => (layoutDataEntry) => R.reduce(
-  (pUSI, unitIndex) => R.update(
-    R.path([unitIndex, 'dimension', '__index'], layoutDataEntry),
-    R.path([unitIndex, 'value', '__index'], layoutDataEntry),
-    pUSI
-  ),
-  partialUnitSerieIndexes,
-  unitsIndexes
-);

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

@@ -1,41 +0,0 @@
-import * as R from 'ramda';
-
-/*
-  observations = { [obsKey]: { units: { serieKey: '', [id]: { id, name, value } } } };
-*/
-
-const getIndex = R.path(['value', 'index']);
-const getUnits = (acc, units) => R.mergeWith((a, b) => getIndex(a) === getIndex(b) ? a : null, acc, units)
-
-export const getUnitsSeries = (observations) => {
-  let series = {};
-  R.map(obs => {
-    series = R.over(
-      R.lensProp(obs.units.serieKey),
-      R.ifElse(R.isNil, R.always([obs.units]), R.append(obs.units))
-    )(series);
-  }, observations);
-  return R.reduce(
-    (_acc, key) => {
-      const serie = series[key];
-      const { units } = R.reduce(
-        (acc, units) => {
-          const unitsKeys = R.keys(units);
-          if (R.isEmpty(acc.unitsKeys)) return { units, unitsKeys }
-          const communKeys = R.intersection(acc.unitsKeys, unitsKeys);
-          return {
-            units: getUnits(R.pick(communKeys, acc.units), R.pick(communKeys, units)),
-            unitsKeys: communKeys,
-          };
-        },
-        { unitsKeys: [], units: {} },
-        serie
-      );
-      if (R.isEmpty(R.dissoc('serieKey', units))) {
-        return _acc;
-      }
-      return R.assoc(key, units, _acc);
-    },
-    {}  
-  )(R.keys(series));
-};

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

@@ -1,71 +0,0 @@
-import * as R from 'ramda';
-
-const getUnitsIndexesInLayoutEntry = (unitsIds) => R.addIndex(R.reduce)(
-  (indexes, id, index) => {
-    if (R.has(id, unitsIds)) {
-      return R.append(index, indexes);
-    }
-    return indexes;
-  },
-  [],
-);
-
-export const getUnitsInLayout = ({
-  layoutIds, // { header: [], sections: [], rows: [] }
-  unitsAttachmentSeriesIds=[], // [ ...DIM_IDS ]
-  unitsDefinitionCodes=[],
-  unitsSeries={}
-}) => {
-  const defaultIndexes = { header: [], sections: [], rows: [] };
-  if (R.isEmpty(unitsAttachmentSeriesIds) || R.isEmpty(unitsSeries)) {
-    return {
-      unitsLevelDisplay: 'cells',
-      unitsAttachmentIndexesInLayout: defaultIndexes,
-      unitsIndexesInLayout: defaultIndexes
-    };
-  }
-  const unitsLength = R.length(unitsAttachmentSeriesIds);
-  const keyedAttUnitsIds = R.indexBy(R.identity, unitsAttachmentSeriesIds);
-  const keyedUnitsIds = R.indexBy(R.identity, unitsDefinitionCodes);
-  const headerUnitsIndexes = getUnitsIndexesInLayoutEntry(keyedAttUnitsIds)(R.propOr([], 'header', layoutIds));
-  if (R.length(headerUnitsIndexes) === unitsLength) {
-    return {
-      unitsLevelDisplay: 'header',
-      unitsAttachmentIndexesInLayout: R.assoc('header', headerUnitsIndexes, defaultIndexes),
-      unitsIndexesInLayout: R.assoc(
-        'header',
-        getUnitsIndexesInLayoutEntry(keyedUnitsIds)(R.propOr([], 'header', layoutIds)),
-        defaultIndexes
-      )
-    };
-  }
-  if (!R.isEmpty(headerUnitsIndexes)) {
-    return {
-      unitsLevelDisplay: 'cells',
-      unitsAttachmentIndexesInLayout: defaultIndexes,
-      unitsIndexesInLayout: defaultIndexes
-    };
-  }
-  const sectionsAttUnitsIndexes = getUnitsIndexesInLayoutEntry(keyedAttUnitsIds)(R.propOr([], 'sections', layoutIds));
-  const sectionsUnitsIndexes = getUnitsIndexesInLayoutEntry(keyedUnitsIds)(R.propOr([], 'sections', layoutIds));
-  if (R.length(sectionsAttUnitsIndexes) === unitsLength) {
-    return {
-      unitsLevelDisplay: 'sections',
-      unitsAttachmentIndexesInLayout: R.assoc('sections', sectionsAttUnitsIndexes, defaultIndexes),
-      unitsIndexesInLayout: R.assoc('sections', sectionsUnitsIndexes, defaultIndexes)
-    }
-  }
-  const rowsAttUnitsIndexes = getUnitsIndexesInLayoutEntry(keyedAttUnitsIds)(R.propOr([], 'rows', layoutIds));
-  const rowsUnitsIndexes = getUnitsIndexesInLayoutEntry(keyedUnitsIds)(R.propOr([], 'rows', layoutIds));
-  return ({
-    unitsLevelDisplay: 'rows',
-    unitsAttachmentIndexesInLayout: R.pipe(
-      R.assoc('sections', sectionsAttUnitsIndexes),
-      R.assoc('rows', rowsAttUnitsIndexes)
-    )(defaultIndexes),
-    unitsIndexesInLayout: R.pipe(
-      R.assoc('sections', sectionsUnitsIndexes),
-      R.assoc('rows', rowsUnitsIndexes)
-    )(defaultIndexes)
-  });
-};

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

@@ -1,26 +0,0 @@
-import * as R from 'ramda';
-
-export const refineDimSeriesUnits = ({
-  unitsArtefacts, // careful, here dimensions and attributes are merged,
-  rejectedValueIds=[]
-}) => R.pipe(
-  R.mapObjIndexed(
-    ({ observations, ...unitsIndexes }) => R.pipe(
-      R.filter(R.allPass([
-        occurences => R.length(occurences) === observations,
-        occurences => R.pipe(R.uniq, R.length, R.equals(1))(occurences)
-      ])),
-      R.mapObjIndexed(
-        (indexes, artefactId) => {
-          const artefact = R.propOr({}, artefactId, unitsArtefacts);
-          const value = R.pathOr({}, ['values', R.head(indexes)], artefact);
-          return ({ ...R.pick(['id', 'name'], artefact), value });
-        }
-      ),
-      R.reject(
-        R.pipe(R.prop('value'), R.anyPass([R.isEmpty, val => R.includes(val.id, rejectedValueIds)]))
-      )
-    )(unitsIndexes)
-  ),
-  R.reject(R.isEmpty)
-);

package/src/rules2/src/getAdvancedAttributes.js

@@ -1,111 +0,0 @@
-import * as R from 'ramda';
-
-export const getObservationsAdvancedAttributes = (observations, advancedAttributesIds) => R.pipe(
-  R.map(obs => ({ attributes: R.pick(advancedAttributesIds, obs.attributes || {}), coordinates: obs.indexedDimValIds || {} })),
-  R.filter(entry => !R.isEmpty(entry.attributes))
-)(observations);
-
-export const getDataflowAdvancedAttributes = (attributes, dimensions, advancedAttributesIds, dimLength) => {
-  const advancedAttributes = R.pick(advancedAttributesIds, attributes);
-  const keyTemplate = R.times(R.always(''), dimLength);
-  return R.reduce(
-    (acc, attribute) => {
-      const value = R.head(attribute.values || []);
-      const attr = { ...R.pick(['id', 'name'], attribute), value };
-      let coordinates = {};
-      let key = keyTemplate;
-
-      if (!R.isEmpty(R.pathOr([], ['relationship', 'dimensions'], attribute))) {
-        const attrDimensionsIds = R.pathOr([], ['relationship', 'dimensions'], attribute);
-        const attrDimensions = R.props(attrDimensionsIds, dimensions);
-        R.forEach(
-          dim => {
-            const dId = dim.id;
-            const dIndex = dim.__index;
-            const vId = R.path(['values', 0, 'id'], dim);
-            coordinates = { ...coordinates, [dId]: vId };
-            key = R.set(R.lensIndex(dIndex), 0)(key);
-          },
-          R.reject(R.isNil, attrDimensions)
-        );
-      }
-
-      key = R.join(':', key);
-      return R.over(
-        R.lensProp(key),
-        entry => R.isNil(entry)
-          ? ({ attributes: { [attribute.id]: attr }, coordinates })
-          : R.over(R.lensProp('attributes'), R.assoc(attribute.id, attr))(entry)
-      )(acc);
-    },
-    {},
-    R.values(advancedAttributes)
-  )
-};
-
-/*
-{
-  series: {
-    '0:0:x:x:x': { attributes: { a2: { id, value } } }
-  },
-  dimensions: {
-    '3:0': { attributes: { a1: { id, value } } },
-  }
-}
-
-*/
-
-export const getSeriesAdvancedAttributes = (seriesAttributes, dimensions, advancedAttributesIds) => {
-  const seriesAdvancedAttributes = R.pipe(
-    R.propOr({}, 'series'),
-    series => R.reduce(
-      (acc, key) => {
-        const serie = series[key];
-        const advancedAttributes = R.pick(advancedAttributesIds, serie.attributes);
-        if (R.isEmpty(advancedAttributes)) {
-          return acc;
-        }
-        const splitKey = R.split(':', key); 
-        const { coordinates, refinedKey } = R.addIndex(R.reduce)(
-          (acc, vInd, dInd) => {
-            if (vInd === 'x') {
-              return ({ ...acc, refinedKey: R.append('', acc.refinedKey) });
-            }
-            const _refined = R.append(vInd, acc.refinedKey);
-            const dim = R.nth(dInd, dimensions);
-            const valId = R.path(['values', Number(vInd), 'id'], dim);
-            const _coordinates = R.assoc(dim.id, valId, acc.coordinates);
-            return ({ coordinates: _coordinates, refinedKey: _refined });
-          },
-          { coordinates: {}, refinedKey: [] },
-          splitKey
-        );
-        return R.assoc(R.join(':', refinedKey), { attributes: advancedAttributes, coordinates }, acc);
-      },
-      {},
-      R.keys(series)
-    )
-  )(seriesAttributes);
-  const keyTemplate = R.map(R.always(''), dimensions);
-  const dimensionsAdvancedAttributes = R.pipe(
-    R.propOr({}, 'dimensions'),
-    series => R.reduce(
-      (acc, key) => {
-        const serie = series[key];
-        const advancedAttributes = R.pick(advancedAttributesIds, serie.attributes);
-        if (R.isEmpty(advancedAttributes)) {
-          return acc;
-        }
-        const [dInd, vInd] = R.split(':', key);
-        const dim = R.nth(Number(dInd), dimensions);
-        const valId = R.path(['values', Number(vInd), 'id'], dim);
-        const coordinates = { [dim.id]: valId };
-        const refinedKey = R.set(R.lensIndex(Number(dInd)), vInd)(keyTemplate);
-        return R.assoc(R.join(':', refinedKey), { attributes: advancedAttributes, coordinates }, acc);
-      },
-      {},
-      R.keys(series)
-    )
-  )(seriesAttributes);
-  return R.merge(seriesAdvancedAttributes, dimensionsAdvancedAttributes);
-};

package/src/rules2/src/hasLayoutEntryMetadata.js

@@ -1,9 +0,0 @@
-import * as R from 'ramda';
-
-/*
-const layoutData = [{ dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } }];
-*/
-
-export const getLayoutEntryMetadataCoordinates = (layoutData, metadataSeries) => {
-  
-};

package/src/rules2/src/invertTime.js

@@ -1,22 +0,0 @@
-import * as R from 'ramda';
-import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-
-export const invertTime = (data, isTimeInverted) => {
-  const dimensions = R.pathOr([], ['dimensions', 'many'], data);
-  const observations = R.propOr({}, 'observations', data);
-  if (!isTimeInverted) {
-    return ({ dimensions, observations });
-  }
-  const timeD = R.find(isTimePeriodDimension, R.values(dimensions));
-  if (!timeD) {
-    return ({ dimensions, observations });
-  }
-  const timeLength = R.length(timeD.values);
-  const timeIndex = timeD.__index;
-  const invertTimeInObs = R.map(
-    R.over(R.lensProp('orderedDimIndexes'), R.over(R.lensIndex(timeIndex), i => timeLength - i - 1)),
-    observations
-  );
-  const invertedTimeInDims = R.over(R.lensProp(timeD.id), R.over(R.lensProp('values'), R.reverse))(dimensions);
-  return ({ dimensions: invertedTimeInDims, observations: invertTimeInObs });
-};

package/test/advanced-attributes-parsing-perf.test.js

@@ -1,16 +0,0 @@
-import { expect } from 'chai';
-import {
-  getDataflowAdvancedAttributes,
-  getObservationsAdvancedAttributes,
-  getSeriesAdvancedAttributes
-} from '../src/rules2/src/getAdvancedAttributes';
-
-import obsMock from './mocks/table-prep-units--observations.json';
-import obsAdvancedAttributes from './mocks/observations-advanced-attributes.json';
-
-describe('advanced attributes parsing performance tests', () => {
-  it('1800 observations test', function() {
-    this.timeout(1500);
-    expect(getObservationsAdvancedAttributes(obsMock, ['CURRENCY', 'OBS_STATUS'])).to.deep.equal(obsAdvancedAttributes);
-  });
-});

package/test/appendUnitsInLayoutDataEntry.test.js

@@ -1,65 +0,0 @@
-import { expect } from 'chai';
-import { appendUnitsInLayoutDataEntry } from '../src/rules/src/table/units/appendUnitsInLayoutDataEntry';
-
-const layoutData = [
-  { dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } },
-  { dimension: { id: 'D2', __index: 0 }, value: { id: 'V', __index: 0 } },
-  { dimension: { id: 'D3', __index: 4 }, value: { id: 'V', __index: 0 } }
-];
-
-const unitsSeries = {
-  '0:x:0:x:x': {
-    U1: { id: 'U1', value: { id: 'U1V' } },
-    U2: { id: 'U2', value: { id: 'U2V' } },
-    U3: { id: 'U3', value: { id: 'U3V' } }
-  },
-  '1:x:1:x:x': {
-    U1: { id: 'U1', value: { id: 'U1V' } },
-    U3: { id: 'U3', value: { id: 'U3V' } },
-    U4: { id: 'U4', value: { id: 'U4V' } },
-  },
-};
-
-describe('appendUnitsInLayoutDataEntry tests', () => {
-  it('blank test', () => {
-    expect(appendUnitsInLayoutDataEntry({
-      display: 'label',
-      unitDimension: {},
-      unitsSeries: {},
-      unitsDefinitionCodes: [],
-      unitsIndexes: [],
-      partialUnitSerieIndexes: []
-    })([])).to.deep.equal([{ dimension: {}, value: { id: '', unitsLabel: '' } }]);
-  });
-  it('complete test', () => {
-    expect(appendUnitsInLayoutDataEntry({
-      display: 'code',
-      unitDimension: { id: 'U' },
-      unitsSeries,
-      unitsDefinitionCodes: ['U3', 'U1', 'U4'],
-      unitsIndexes: [1, 0],
-      partialUnitSerieIndexes: ['x', 'x', 'x', 'x', 'x']
-    })(layoutData)).to.deep.equal([
-      { dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } },
-      { dimension: { id: 'D2', __index: 0 }, value: { id: 'V', __index: 0 } },
-      { dimension: { id: 'D3', __index: 4 }, value: { id: 'V', __index: 0 } },
-      { dimension: { id: 'U' }, value: { id: 'U3V - U1V', unitsLabel: 'U3V, U1V' } }
-    ]);
-  });
-  it('rejectedValues test', () => {
-    expect(appendUnitsInLayoutDataEntry({
-      display: 'code',
-      rejectedValueIds: ['U3V'],
-      unitDimension: { id: 'U' },
-      unitsSeries,
-      unitsDefinitionCodes: ['U3', 'U1', 'U4'],
-      unitsIndexes: [1, 0],
-      partialUnitSerieIndexes: ['x', 'x', 'x', 'x', 'x']
-    })(layoutData)).to.deep.equal([
-        { dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } },
-        { dimension: { id: 'D2', __index: 0 }, value: { id: 'V', __index: 0 } },
-        { dimension: { id: 'D3', __index: 4 }, value: { id: 'V', __index: 0 } },
-        { dimension: { id: 'U' }, value: { id: 'U1V', unitsLabel: 'U1V' } }
-    ]);
-  })
-});

package/test/cleanUnitsInLayoutData.test.js

@@ -1,85 +0,0 @@
-import { expect } from 'chai';
-import { cleanUnitsInLayoutData } from '../src/rules/src/table/units/cleanUnitsInLayoutData';
-
-const headerData = [
-  { data: [{ id: 0 }, { id: 1 }, { dimension: { label: 'U' }, value: { label: null, unitsLabel: 'U1' } }] },
-  { data: [{ id: 0 }, { id: 1 }, { dimension: { label: 'U' }, value: { label: 'toto', unitsLabel: 'U2' } }] },
-  { data: [{ id: 0 }, { id: 1 }, { dimension: { label: 'U' }, value: { unitsLabel: 'U3' } }] },
-];
-
-const sectionsData1 = [
-  [
-    { data: [{ id: 0 }, { id: 1 }, { value: { unitsLabel: 'Units S1' } }] },
-    [{ data: [{ id: 'r1' }, { id: 'r2' }] }]
-  ],
-  [
-    { data: [{ id: 2 }, { id: 3 }, { value: { unitsLabel: 'Units S2' } }] },
-    [{ data: [{ id: 'r1' }, { id: 'r2' }] }]
-  ]
-];
-
-const sectionsData2 = [
-  [
-    { data: [{ id: 0 }, { id: 1 }] },
-    [
-      { data: [{ id: 'r1' }, { id: 'r2' }, { value: { unitsLabel: 'Units R1' } }] },
-      { data: [{ id: 'r1' }, { id: 'r2' }, { value: { unitsLabel: 'Units R2' } }] },
-    ]
-  ],
-  [
-    { data: [{ id: 2 }, { id: 3 }] },
-    [
-      { data: [{ id: 'r1' }, { id: 'r2' }, { value: { unitsLabel: 'Units R3' } }] },
-      { data: [{ id: 'r1' }, { id: 'r2' }, { value: { unitsLabel: 'Units R4' } }] },
-    ]
-  ]
-];
-
-describe('cleanUnitsInLayoutData tests', () => {
-  it('header test', () => {
-    expect(cleanUnitsInLayoutData({ unitsDisplay: 'header', unitsLayoutIndexes: { header: [1] } })({ headerData }))
-      .to.deep.equal({
-        headerData: [
-          { data: [{ id: 0 }, { dimension: { label: 'U' }, value: { label: 'U1', unitsLabel: 'U1' } }] },
-          { data: [{ id: 0 }, { dimension: { label: 'U' }, value: { label: 'U2', unitsLabel: 'U2' } }] },
-          { data: [{ id: 0 }, { dimension: { label: 'U' }, value: { label: 'U3', unitsLabel: 'U3' } }] },
-        ]
-      })
-  });
-  it('sections test', () => {
-    expect(cleanUnitsInLayoutData({ unitsDisplay: 'sections', unitsLayoutIndexes: { sections: [0] } })({ sectionsData: sectionsData1 }))
-      .to.deep.equal({
-        sectionsData: [
-          [
-            { data: [{ id: 1 }, { value: { label: 'Units S1', unitsLabel: 'Units S1' } }] },
-            [{ data: [{ id: 'r1' }, { id: 'r2' }] }]
-          ],
-          [
-            { data: [{ id: 3 }, { value: { label: 'Units S2', unitsLabel: 'Units S2' } }] },
-            [{ data: [{ id: 'r1' }, { id: 'r2' }] }]
-          ]
-        ]
-      })
-  });
-  it('rows test', () => {
-    expect(cleanUnitsInLayoutData({ unitsDisplay: 'rows', unitsLayoutIndexes: { rows: [0] } })({ sectionsData: sectionsData2 }))
-      .to.deep.equal({
-        sectionsData: [
-          [
-            { data: [{ id: 0 }, { id: 1 }] },
-            [
-              { data: [{ id: 'r2' }, { value: { label: 'Units R1', unitsLabel: 'Units R1' } }] },
-              { data: [{ id: 'r2' }, { value: { label: 'Units R2', unitsLabel: 'Units R2' } }] },
-            ]
-          ],
-          [
-            { data: [{ id: 2 }, { id: 3 }] },
-            [
-              { data: [{ id: 'r2' }, { value: { label: 'Units R3', unitsLabel: 'Units R3' } }] },
-              { data: [{ id: 'r2' }, { value: { label: 'Units R4', unitsLabel: 'Units R4' } }] },
-            ]
-          ]
-        ]
-      })
-  });
-});