@sis-cc/dotstatsuite-components 14.0.0 → 14.2.0

package/src/rules/src/table/factories/getTableData.js

@@ -1,5 +1,4 @@
 import * as R from 'ramda';
-import { withFlatHierarchy, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { getCells } from './getCells';
 import { getConfirmedSeriesAttributesIds } from './getConfirmedSeriesAttributesIds';
 import { getCuratedCells } from './getCuratedCells';
@@ -14,6 +13,7 @@ import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
 import { refineLayoutSize } from './refineLayoutSize';
 import { getLayoutData } from './getLayoutData';
 import { refineMetadataCoordinates } from '../../../../rules2/src/refineMetadataCoordinates';
+import { invertTime } from '../../../../rules2/src/invertTime';
 
 export const getTableProps = ({ data, layoutIds, display, customAttributes, limit, isTimeInverted }) => {
   const seriesAttributes = R.propOr({}, 'seriesAttributes', data);
@@ -56,26 +56,7 @@ export const getTableProps = ({ data, layoutIds, display, customAttributes, limi
     data.observationsType,
   );
 
-  const dimensions = R.mapObjIndexed(
-    R.pipe(
-      R.when( // invert TimeDimension Values
-        R.allPass([isTimePeriodDimension, R.always(isTimeInverted)]),
-        (dim) => R.over(
-          R.lensProp('values'),
-          R.map(R.over(R.lensProp('__indexPosition'), R.negate))
-        )(dim), 
-      ),
-      (dim) => R.over( // sort values
-        R.lensProp('values'),
-        R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.prop('order'))]),
-      )(dim),
-      R.when( // refine hierarchy on rows
-        R.pipe(R.prop('id'), R.flip(R.includes)(R.propOr([], 'rows', layoutIds))),
-        withFlatHierarchy
-      )
-    ),
-    R.pathOr({}, ['dimensions', 'many'], data)
-  );
+  const { dimensions, observations } = invertTime(data, isTimeInverted);
 
   const seriesAttributesValues = R.propOr({}, 'seriesAttributesValues', data);
   const layout = R.pipe(
@@ -99,7 +80,7 @@ export const getTableProps = ({ data, layoutIds, display, customAttributes, limi
     }),
     getLayoutDataWithFlags(seriesAttributesValues, display, customAttributes, refinedMetadataCoordinates, unitDimension.id),
     cleanUnitsInLayoutData({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout }),
-  )(layout, R.propOr({}, 'observations', data));
+  )(layout, observations);
   
   return ({
     cells: getCuratedCells({ layout, observations: cells, shape: ['header', 'sections', 'rows'] }),

package/src/rules/src/table/preparators/prepareData.js

@@ -24,8 +24,12 @@ import {
   getObservationsAdvancedAttributes,
   getSeriesAdvancedAttributes
 } from '../../../../rules2/src/getAdvancedAttributes';
+import { duplicateObservations } from '../../../../rules2/src/duplicateObservations';
+import { hierarchiseDimensionWithAdvancedHierarchy } from '../../../../rules2/src/hierarchiseDimensionWithAdvancedHierarchy';
+import { hierarchiseDimensionWithNativeHierarchy } from '../../../../rules2/src/hierarchiseDimensionWithNativeHierarchy';
+import { getDimensionValuesIndexes } from '../../../../rules2/src/getDimensionValuesIndexes';
 
-export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
+export const prepareData = (sdmxJson, customAttributes, unitsProps={}, _options={}) => {
   const {
     defaultCodes=[],
     annotationsDefinitionCodes={},
@@ -37,6 +41,7 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
   const _customAttributes = R.assoc('units', unitsDefinitionCodes, customAttributes);
   const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
 
+  const hierarchies = _options.hierarchies || {};
   const dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
 
   const parsedDimensionsIds = parseDimensionsIds(dimensions);
@@ -160,10 +165,25 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     seriesAdvancedAttributesIds
   );
 
+  const hierarchisedDimensions = R.map(dim => {
+    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
+      return hierarchiseDimensionWithNativeHierarchy(dim);
+    }
+    return hierarchiseDimensionWithAdvancedHierarchy(dim, R.prop(dim.id, hierarchies));
+  })(manyValuesDimensions);
+
+  const valuesIndexes = R.reduce(
+    (acc, dim) => ({ ...acc, [dim.__index]: getDimensionValuesIndexes(dim.values) }),
+    {},
+    R.values(hierarchisedDimensions)
+  );
+
+  const duplicatedObservations = duplicateObservations(observations, valuesIndexes);
+
   return ({
     dimensions: {
       one: oneValueDimensions,
-      many: manyValuesDimensions,
+      many: hierarchisedDimensions,
       length: R.length(dimensions)
     },
     units: {
@@ -175,7 +195,7 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     },
     metadataCoordinates,
     advancedAttributes: { ...dataflowAdvancedAttributes, ...observationsAdvancedAttributes, ...seriesAdvancedAttributes },
-    observations,
+    observations: duplicatedObservations,
     observationsType: getObservationsType(sdmxJson.data),
     dataflowAttributes,
     dataflowName: R.path(['data', 'structure', 'name'], sdmxJson),

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

@@ -4,17 +4,29 @@ import * as R from 'ramda';
   observations = { [obsKey]: { units: { serieKey: '', [id]: { id, name, value } } } };
 */
 
+const getIndex = R.path(['value', 'index']);
+const getUnits = (keys, acc, units) => R.pick(keys, 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);
+    series = R.over(
+      R.lensProp(obs.units.serieKey),
+      R.ifElse(R.isNil, R.always([obs.units]), R.append(obs.units))
+    )(series);
   }, observations);
 
   return R.map(
     serie => R.reduce(
-      (acc, units) => R.mergeWith((a, b) => R.path(['value', 'index'], a) === R.path(['value', 'index'], b) ? a : null, acc, units),
-      {},
-      serie
-    )
+      (acc, units) => {
+        const unitsKeys = R.keys(units);
+        if (R.isEmpty(acc.unitsKeys)) return { units: getUnits(unitsKeys, acc.units, units), unitsKeys }
+        const communKeys = R.intersection(acc.unitsKeys, unitsKeys);
+        return { 
+          units: getUnits(communKeys, acc.units, units),
+          unitsKeys
+        }
+       ;
+      }, { unitsKeys: [], units: {} }, serie).units
   )(series);
-};
+};

package/src/rules/src/v8-transformer.js

@@ -81,7 +81,9 @@ export const dataTransformer = (dataNew, options = {}) => {
       R.ascend(R.prop('__indexPosition')),
       R.ascend(R.propOr(-1, 'order'))
     ]),
-    R.addIndex(R.map)((val, index) => R.assoc('__indexPosition', index, val))
+    R.addIndex(R.map)((val, index) => R.assoc('__indexPosition', index, val)),
+    /* NEW */
+    R.sortBy(R.prop('__index'))
   );
 
 //--------------------------------------------------------------------------------------------Header
@@ -147,30 +149,6 @@ export const dataTransformer = (dataNew, options = {}) => {
     const isHidden = R.has(id, hiddenIds) || getIsHidden(dimAnnotations);
     const isTime = observation.id === timePeriodId;
     const values = getValuesEnhanced(locale, annotations, isTime, id)(R.propOr([],'values', observation));
-    const ids = R.pipe(R.pluck('id'), R.indexBy(R.identity))(values);
-    const groupedByParentsValues = R.groupBy(val => {
-      const parentId = R.propOr('##ROOT', 'parent', val);
-      if (parentId !== '##ROOT' && !R.has(parentId, ids)) {
-        return '##ROOT';
-      }
-      return parentId;
-    }, values);
-    const sortedGroupedValues = R.mapObjIndexed(
-      R.sortWith([R.ascend(R.prop('__indexPosition')), R.ascend(R.prop('__index'))]),
-      groupedByParentsValues
-    );
-
-    const getReccursiveChildren = (parent) => {
-      const children = R.propOr([], parent, sortedGroupedValues);
-      return R.map(child => R.prepend(child, getReccursiveChildren(child.id)), children);
-    };
-
-    const sortedValues = R.pipe(
-      getReccursiveChildren,
-      R.flatten,
-      R.addIndex(R.map)((value, index) => R.assoc('__indexPosition', index, value)),
-      R.sortBy(R.prop('__index'))
-    )('##ROOT');
 
     return ({
       observation: R.append({
@@ -178,7 +156,7 @@ export const dataTransformer = (dataNew, options = {}) => {
         display: !isHidden,
         __index: obsIndex,
         name: getRefinedName(observation),
-        values: sortedValues,
+        values,
         role: isTime ? TIME_PERIOD_ID : R.head(R.propOr([], 'roles', observation)),
       })(acc.observation),
       dimensionsLayout: setAnnotationsLayout(id, acc.dimensionsLayout)(dimAnnotations),

package/src/rules2/src/duplicateObservations.js

@@ -0,0 +1,45 @@
+import * as R from 'ramda';
+
+export const duplicateObservations = (observations, indexes) => {
+  return R.addIndex(R.reduce)(
+    (acc, obs, i) => {
+
+      const orderedIndexes = R.addIndex(R.map)(
+        (valueIndex, dimIndex) => R.pathOr([Number(valueIndex)], [dimIndex, valueIndex], indexes),
+        R.propOr([], 'dimValuesIndexes', obs)
+      );
+
+      let cartesian;
+
+      if (R.any(is => R.length(is) > 1)(orderedIndexes)) {
+        cartesian = R.reduce(
+          (acc, oInds) => {
+            const r = R.map(
+              i => R.map(is => R.append(i, is), acc),
+              oInds
+            );
+            return R.unnest(r);
+          },
+          R.pipe(R.head, R.map(R.of))(orderedIndexes),
+          R.tail(orderedIndexes)
+        );
+      }
+      else {
+        cartesian = [R.unnest(orderedIndexes)];
+      }
+
+      const duplicatedObs = R.reduce(
+        (acc, orderedDimIndexes) => {
+          const key = R.join(':', orderedDimIndexes);
+          return R.assoc(key, { ...obs, orderedDimIndexes }, acc);
+        },
+        {},
+        cartesian
+      );
+
+      return R.mergeRight(acc, duplicatedObs);
+    },
+    {},
+    R.values(observations)
+  )
+};

package/src/rules2/src/getDimensionValuesIndexes.js

@@ -0,0 +1,13 @@
+import * as R from 'ramda';
+
+export const getDimensionValuesIndexes = (values) => R.addIndex(R.reduce)(
+  (acc, value, position) => {
+    const sdmxIndex = value.__index;
+    return R.over(
+      R.lensProp(String(sdmxIndex)),
+      R.ifElse(R.isNil, R.always([position]), R.append(position))
+    )(acc);
+  },
+  {},
+  values
+);

package/src/rules2/src/getHCodelistsRefsInData.js

@@ -0,0 +1,23 @@
+import * as R from 'ramda';
+
+export const getHCodelistsRefs = annotations => R.reduce(
+  (acc, annotation) => {
+    if (annotation.type !== 'HIER_CONTEXT') {
+      return acc;
+    }
+    const reference = annotation.text || annotation.title || '';
+    const match = reference.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
+    if (R.isNil(match)) {
+      return acc;
+    }
+    const [codelistId, agencyId, code, version, hierarchy] = R.tail(match);
+    return R.assoc(codelistId, { agencyId, code, version, hierarchy, codelistId }, acc);
+  },
+  {},
+  annotations,
+);
+
+export const getHCodelistsRefsInData = sdmxJson => {
+  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  return getHCodelistsRefs(annotations);
+};

package/src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy.js

@@ -0,0 +1,44 @@
+import * as R from 'ramda';
+
+export const hierarchiseDimensionWithAdvancedHierarchy = (dimension, hierarchy) => {
+  const indexed = R.indexBy(R.prop('id'), dimension.values);
+
+  let rest = indexed;
+  const getChildren = (parents) => 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));
+        return R.prepend(_val, children);
+      },
+    )
+  )(R.propOr([], R.isEmpty(parents) ? '#ROOT' : R.join('.', parents), hierarchy));
+
+  return R.set(
+    R.lensProp('values'),
+    R.pipe(
+      getChildren,
+      R.flatten,
+      values => {
+        if (R.isEmpty(rest)) {
+          return values;
+        }
+        const sortedRest = R.pipe(
+          R.values,
+          R.map(val => ({ ...val, parent: undefined, parents: [] })),
+          R.sortBy(R.prop('__indexPosition'))
+        )(rest);
+        return R.concat(sortedRest, values);
+      }
+    )([])
+  )(dimension);
+};

package/src/rules2/src/hierarchiseDimensionWithNativeHierarchy.js

@@ -0,0 +1,24 @@
+import * as R from 'ramda';
+
+export const hierarchiseDimensionWithNativeHierarchy = (dimension) => {
+  const values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
+  const grouped = R.groupBy(R.propOr('#ROOT', 'parent'), values);
+
+  const getChildren = (parents) => {
+    const childs = R.propOr([], R.last(parents) || '#ROOT', grouped);
+    return R.reduce(
+      (acc, child) => {
+        const refined = R.assoc('parents', 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);
+};

package/src/rules2/src/index.js

@@ -9,3 +9,5 @@ export { sdmx_3_0_DataFormatPatch } from './sdmx3.0DataFormatPatch';
 export { getDataflowTooltipAttributesIds } from './getDataflowTooltipAttributesIds';
 export { getMSDInformations } from './getMSDInformations';
 export { getNotDisplayedIds } from './getNotDisplayedIds';
+export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsInData';
+export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';

package/src/rules2/src/invertTime.js

@@ -0,0 +1,22 @@
+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/src/rules2/src/parseHierarchicalCodelist.js

@@ -0,0 +1,48 @@
+import * as R from 'ramda';
+
+export const parseHierarchicalCodelist = (sdmxJson, hierarchyId) => {
+  const hCodelist = R.pathOr({}, ['data', 'hierarchicalCodelists', 0], sdmxJson);
+  const hierarchy = R.find(R.propEq('id', hierarchyId), hCodelist.hierarchies || []);
+
+  const getParentedCodes = (codes, parent) => {
+    const ids = R.pluck('codeID', codes);
+
+    const siblings = R.reduce(
+      (acc, code) => {
+        if (R.isEmpty(code.hierarchicalCodes || [])) {
+          return acc;
+        }
+        return R.mergeRight(acc, getParentedCodes(code.hierarchicalCodes, code.id));
+      },
+      {},
+      codes
+    );
+
+    return ({ ...siblings, [parent]: ids });
+  };
+
+  const getChildren = (codes, parents) => {
+    const ids = R.pluck('codeID', codes);
+
+    const children = R.reduce(
+      (acc, code) => {
+        if (R.isEmpty(code.hierarchicalCodes || [])) {
+          return acc;
+        }
+        return ({
+          ...acc,
+          ...getChildren(code.hierarchicalCodes, R.append(code.codeID, parents))
+        });
+      },
+      {},
+      codes
+    );
+    const key = R.isEmpty(parents) ? '#ROOT' : R.join('.', parents);
+    return ({ ...children, [key]: ids });
+  }
+
+  return R.pipe(
+    R.propOr([], 'hierarchicalCodes'),
+    codes => getChildren(codes, []),
+  )(hierarchy);
+};

package/test/duplicateObservations.test.js

@@ -0,0 +1,108 @@
+import { expect } from 'chai';
+import { duplicateObservations } from '../src/rules2/src/duplicateObservations';
+
+describe('duplicateObservations tests', () => {
+  it('simple case', () => {
+    const observations = {
+      '0:0:0': { dimValuesIndexes: [0, 0, 0] },
+      '0:0:1': { dimValuesIndexes: [0, 0, 1] },
+      '0:0:2': { dimValuesIndexes: [0, 0, 2] },
+      '1:0:0': { dimValuesIndexes: [1, 0, 0] },
+      '1:0:1': { dimValuesIndexes: [1, 0, 1] },
+      '1:0:2': { dimValuesIndexes: [1, 0, 2] },
+    };
+
+    const indexes = { 
+      '0': {
+        '0': [0],
+        '1': [1]
+      },
+      '2': {
+        '0': [4],
+        '1': [0, 2],
+        '2': [1, 3]
+      }
+    };
+
+    const expected = {
+      '0:0:0': { dimValuesIndexes: [0, 0, 1], orderedDimIndexes: [0, 0, 0] },
+      '0:0:1': { dimValuesIndexes: [0, 0, 2], orderedDimIndexes: [0, 0, 1] },
+      '0:0:2': { dimValuesIndexes: [0, 0, 1], orderedDimIndexes: [0, 0, 2] },
+      '0:0:3': { dimValuesIndexes: [0, 0, 2], orderedDimIndexes: [0, 0, 3] },
+      '0:0:4': { dimValuesIndexes: [0, 0, 0], orderedDimIndexes: [0, 0, 4] },
+      '1:0:0': { dimValuesIndexes: [1, 0, 1], orderedDimIndexes: [1, 0, 0] },
+      '1:0:1': { dimValuesIndexes: [1, 0, 2], orderedDimIndexes: [1, 0, 1] },
+      '1:0:2': { dimValuesIndexes: [1, 0, 1], orderedDimIndexes: [1, 0, 2] },
+      '1:0:3': { dimValuesIndexes: [1, 0, 2], orderedDimIndexes: [1, 0, 3] },
+      '1:0:4': { dimValuesIndexes: [1, 0, 0], orderedDimIndexes: [1, 0, 4] },
+    };
+
+    expect(duplicateObservations(observations, indexes)).to.deep.equal(expected);
+  });
+  it('complex cartesian duplicate test', () => {
+    const observations = {
+      '0:0:0:0': { dimValuesIndexes: [0, 0, 0, 0] },
+      '0:0:0:1': { dimValuesIndexes: [0, 0, 0, 1] },
+    };
+
+    const indexes = {
+      '0': { '0': [1, 5] },
+      '1': { '0': [0, 4, 6] },
+      '2': { '0': [8, 9] },
+      '3': { '0': [3, 7], '1': [0, 13] },
+    };
+
+    const expected = {
+      '1:0:8:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 0, 8, 3] },
+      '1:0:8:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 0, 8, 7] },
+      '1:0:9:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 0, 9, 3] },
+      '1:0:9:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 0, 9, 7] },
+      '1:4:8:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 4, 8, 3] },
+      '1:4:8:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 4, 8, 7] },
+      '1:4:9:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 4, 9, 3] },
+      '1:4:9:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 4, 9, 7] },
+      '1:6:8:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 6, 8, 3] },
+      '1:6:8:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 6, 8, 7] },
+      '1:6:9:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 6, 9, 3] },
+      '1:6:9:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [1, 6, 9, 7] },
+      '5:0:8:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 0, 8, 3] },
+      '5:0:8:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 0, 8, 7] },
+      '5:0:9:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 0, 9, 3] },
+      '5:0:9:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 0, 9, 7] },
+      '5:4:8:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 4, 8, 3] },
+      '5:4:8:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 4, 8, 7] },
+      '5:4:9:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 4, 9, 3] },
+      '5:4:9:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 4, 9, 7] },
+      '5:6:8:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 6, 8, 3] },
+      '5:6:8:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 6, 8, 7] },
+      '5:6:9:3': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 6, 9, 3] },
+      '5:6:9:7': { dimValuesIndexes: [0, 0, 0, 0], orderedDimIndexes: [5, 6, 9, 7] },
+      '1:0:8:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 0, 8, 0] },
+      '1:0:8:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 0, 8, 13] },
+      '1:0:9:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 0, 9, 0] },
+      '1:0:9:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 0, 9, 13] },
+      '1:4:8:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 4, 8, 0] },
+      '1:4:8:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 4, 8, 13] },
+      '1:4:9:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 4, 9, 0] },
+      '1:4:9:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 4, 9, 13] },
+      '1:6:8:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 6, 8, 0] },
+      '1:6:8:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 6, 8, 13] },
+      '1:6:9:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 6, 9, 0] },
+      '1:6:9:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [1, 6, 9, 13] },
+      '5:0:8:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 0, 8, 0] },
+      '5:0:8:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 0, 8, 13] },
+      '5:0:9:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 0, 9, 0] },
+      '5:0:9:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 0, 9, 13] },
+      '5:4:8:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 4, 8, 0] },
+      '5:4:8:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 4, 8, 13] },
+      '5:4:9:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 4, 9, 0] },
+      '5:4:9:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 4, 9, 13] },
+      '5:6:8:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 6, 8, 0] },
+      '5:6:8:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 6, 8, 13] },
+      '5:6:9:0': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 6, 9, 0] },
+      '5:6:9:13': { dimValuesIndexes: [0, 0, 0, 1], orderedDimIndexes: [5, 6, 9, 13] }
+    };
+
+    expect(duplicateObservations(observations, indexes)).to.deep.equal(expected);
+  });
+});

package/test/enhanceObservations.test.js

@@ -7,36 +7,6 @@ describe('enhanceObservations tests', () => {
   it('blank test', () => {
     expect(enhanceObservations([], {}, [], {})).to.deep.equal({});
   });
-  it('orderedDimIndexes test', () => {
-    const dimensions = [
-      { id: 'D1', values: [{ id: 'v1', __indexPosition: 2 }, { id: 'v2', __indexPosition: 0 }, { id: 'v3', __indexPosition: 1 }] },
-      { id: 'D2', values: [{ id: 'v1', __indexPosition: 1 }, { id: 'v2', __indexPosition: 2 }, { id: 'v3', __indexPosition: 0 }] },
-      { id: 'D3', values: [{ id: 'v1', __indexPosition: 0 }] }
-    ];
-    const observations = {
-      a: { dimValuesIndexes: [0, 0, 0], value: '1' },
-      b: { dimValuesIndexes: [0, 1, 0], value: '2' },
-      c: { dimValuesIndexes: [0, 2, 0], value: '3' },
-      d: { dimValuesIndexes: [1, 0, 0], value: '4' },
-      e: { dimValuesIndexes: [1, 1, 0], value: '5' },
-      f: { dimValuesIndexes: [1, 2, 0], value: '6' },
-      g: { dimValuesIndexes: [2, 0, 0], value: '7' },
-      h: { dimValuesIndexes: [2, 1, 0], value: '8' },
-      i: { dimValuesIndexes: [2, 2, 0], value: '9' }
-    };
-    expect(enhanceObservations(dimensions, observations, [], {})).to.deep.equal({
-      a: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [0, 0, 0], orderedDimIndexes: [2, 1, 0], value: '1', formattedValue: '1', indexedDimValIds: { D1: 'v1', D2: 'v1', D3: 'v1' } },
-      b: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [0, 1, 0], orderedDimIndexes: [2, 2, 0], value: '2', formattedValue: '2', indexedDimValIds: { D1: 'v1', D2: 'v2', D3: 'v1' } },
-      c: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [0, 2, 0], orderedDimIndexes: [2, 0, 0], value: '3', formattedValue: '3', indexedDimValIds: { D1: 'v1', D2: 'v3', D3: 'v1' } },
-      d: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [1, 0, 0], orderedDimIndexes: [0, 1, 0], value: '4', formattedValue: '4', indexedDimValIds: { D1: 'v2', D2: 'v1', D3: 'v1' } },
-      e: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [1, 1, 0], orderedDimIndexes: [0, 2, 0], value: '5', formattedValue: '5', indexedDimValIds: { D1: 'v2', D2: 'v2', D3: 'v1' } },
-      f: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [1, 2, 0], orderedDimIndexes: [0, 0, 0], value: '6', formattedValue: '6', indexedDimValIds: { D1: 'v2', D2: 'v3', D3: 'v1' } },
-      g: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [2, 0, 0], orderedDimIndexes: [1, 1, 0], value: '7', formattedValue: '7', indexedDimValIds: { D1: 'v3', D2: 'v1', D3: 'v1' } },
-      h: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [2, 1, 0], orderedDimIndexes: [1, 2, 0], value: '8', formattedValue: '8', indexedDimValIds: { D1: 'v3', D2: 'v2', D3: 'v1' } },
-      i: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [2, 2, 0], orderedDimIndexes: [1, 0, 0], value: '9', formattedValue: '9', indexedDimValIds: { D1: 'v3', D2: 'v3', D3: 'v1' } }
-    });
-  });
-
   it('formatValue test', () => {
     numeral.locale('eObs');
     const attributes = [
@@ -64,19 +34,19 @@ describe('enhanceObservations tests', () => {
     };
 
     expect(enhanceObservations([], observations, attributes, { customAttributes })).to.deep.equal({
-      a: { attributes: {}, units: { serieKey: '' }, value: 2, formattedValue: '2', attrValuesIndexes: [null, null, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      c: { attributes: {}, units: { serieKey: '' }, value: 10, formattedValue: '10', attrValuesIndexes: [null, 4, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      d: { attributes: {}, units: { serieKey: '' }, value: 5, formattedValue: '5', attrValuesIndexes: [null, 1, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      e: { attributes: {}, units: { serieKey: '' }, value: 8.3, formattedValue: '83', attrValuesIndexes: [null, 0, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      f: { attributes: {}, units: { serieKey: '' }, value: 25.62, formattedValue: '0.02562', attrValuesIndexes: [null, 3, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      g: { attributes: {}, units: { serieKey: '' }, value: 3.7, formattedValue: '3.7', attrValuesIndexes: [null, null, 4], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      h: { attributes: {}, units: { serieKey: '' }, value: 21.1234567, formattedValue: '21.123', attrValuesIndexes: [null, null, 2], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      i: { attributes: {}, units: { serieKey: '' }, value: 20.1, formattedValue: '20.10000', attrValuesIndexes: [null, null, 3], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      j: { attributes: {}, units: { serieKey: '' }, value: 19.9, formattedValue: '20', attrValuesIndexes: [null, null, 0], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      k: { attributes: {}, units: { serieKey: '' }, value: 16.35, formattedValue: '1.64', attrValuesIndexes: [null, 2, 1], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      l: { attributes: {}, units: { serieKey: '' }, value: 155062.56, formattedValue: '155,062.560', attrValuesIndexes: [null, null, 2], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      m: { attributes: {}, units: { serieKey: '' }, value: 155062.56, formattedValue: '155,063', attrValuesIndexes: [null, null, 0], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
-      n: { attributes: {}, units: { serieKey: '' }, value: null, formattedValue: '..', attrValuesIndexes: [null, null, 1], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      a: { attributes: {}, units: { serieKey: '' }, value: 2, formattedValue: '2', attrValuesIndexes: [null, null, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      c: { attributes: {}, units: { serieKey: '' }, value: 10, formattedValue: '10', attrValuesIndexes: [null, 4, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      d: { attributes: {}, units: { serieKey: '' }, value: 5, formattedValue: '5', attrValuesIndexes: [null, 1, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      e: { attributes: {}, units: { serieKey: '' }, value: 8.3, formattedValue: '83', attrValuesIndexes: [null, 0, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      f: { attributes: {}, units: { serieKey: '' }, value: 25.62, formattedValue: '0.02562', attrValuesIndexes: [null, 3, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      g: { attributes: {}, units: { serieKey: '' }, value: 3.7, formattedValue: '3.7', attrValuesIndexes: [null, null, 4], dimValuesIndexes: [], indexedDimValIds: {} },
+      h: { attributes: {}, units: { serieKey: '' }, value: 21.1234567, formattedValue: '21.123', attrValuesIndexes: [null, null, 2], dimValuesIndexes: [], indexedDimValIds: {} },
+      i: { attributes: {}, units: { serieKey: '' }, value: 20.1, formattedValue: '20.10000', attrValuesIndexes: [null, null, 3], dimValuesIndexes: [], indexedDimValIds: {} },
+      j: { attributes: {}, units: { serieKey: '' }, value: 19.9, formattedValue: '20', attrValuesIndexes: [null, null, 0], dimValuesIndexes: [], indexedDimValIds: {} },
+      k: { attributes: {}, units: { serieKey: '' }, value: 16.35, formattedValue: '1.64', attrValuesIndexes: [null, 2, 1], dimValuesIndexes: [], indexedDimValIds: {} },
+      l: { attributes: {}, units: { serieKey: '' }, value: 155062.56, formattedValue: '155,062.560', attrValuesIndexes: [null, null, 2], dimValuesIndexes: [], indexedDimValIds: {} },
+      m: { attributes: {}, units: { serieKey: '' }, value: 155062.56, formattedValue: '155,063', attrValuesIndexes: [null, null, 0], dimValuesIndexes: [], indexedDimValIds: {} },
+      n: { attributes: {}, units: { serieKey: '' }, value: null, formattedValue: '..', attrValuesIndexes: [null, null, 1], dimValuesIndexes: [], indexedDimValIds: {} },
     });
   });
 
@@ -189,7 +159,6 @@ describe('enhanceObservations tests', () => {
       a: {
         attrValuesIndexes: [0, 0, 0, 0, 0],
         dimValuesIndexes: [0, 0, 0, 0, 0],
-        orderedDimIndexes: [0, 0, 0, 0, 0],
         value: 22,
         formattedValue: '22',
         units: {
@@ -206,7 +175,6 @@ describe('enhanceObservations tests', () => {
       b: {
         attrValuesIndexes: [1, 0, 1, 1, 0],
         dimValuesIndexes: [0, 0, 0, 1, 0],
-        orderedDimIndexes: [0, 0, 0, 1, 0],
         value: 17,
         formattedValue: '17',
         units: {
@@ -223,7 +191,6 @@ describe('enhanceObservations tests', () => {
       c: {
         attrValuesIndexes: [2, 0, null, null, 0],
         dimValuesIndexes: [1, 0, 0, 0, 0],
-        orderedDimIndexes: [1, 0, 0, 0, 0],
         value: 55,
         formattedValue: '55',
         units: {
@@ -240,7 +207,6 @@ describe('enhanceObservations tests', () => {
       d: {
         attrValuesIndexes: [2, 0, null, null, 1],
         dimValuesIndexes: [2, 0, 0, 0, 0],
-        orderedDimIndexes: [2, 0, 0, 0, 0],
         value: 35,
         formattedValue: '35',
         units: {
@@ -256,7 +222,6 @@ describe('enhanceObservations tests', () => {
       e: {
         attrValuesIndexes: [2, null, null, null, null],
         dimValuesIndexes: [3, 0, 0, 0, 0],
-        orderedDimIndexes: [3, 0, 0, 0, 0],
         value: 35,
         formattedValue: '35',
         units: { serieKey: 'x:x:x:x:x' },