@sis-cc/dotstatsuite-components 14.0.0 → 14.1.0

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

@@ -24,8 +24,12 @@ import {
   getObservationsAdvancedAttributes,
   getSeriesAdvancedAttributes
 } from '../../../../rules2/src/getAdvancedAttributes';
+import { getDimensionsSimpleHierarchies } from '../../../../rules2/src/getDimensionsSimpleHierarchies';
+import { duplicateObservations } from '../../../../rules2/src/duplicateObservations';
+import { hierarchiseDimension } from '../../../../rules2/src/hierarchiseDimension';
+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,8 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
   const _customAttributes = R.assoc('units', unitsDefinitionCodes, customAttributes);
   const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
 
+  const simpleHierarchies = getDimensionsSimpleHierarchies(dimensions);
+  const hierarchies = R.mergeRight(simpleHierarchies, _options.hierarchies || {});
   const dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
 
   const parsedDimensionsIds = parseDimensionsIds(dimensions);
@@ -160,10 +166,21 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     seriesAdvancedAttributesIds
   );
 
+  const hierarchisedDimensions = R.map(
+    dim => hierarchiseDimension(dim, R.propOr({}, 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 +192,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/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/getDimensionsSimpleHierarchies.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+
+const getDimensionSimpleHierarchy = ({ values }) => {
+  const indexed = R.indexBy(R.prop('id'), values);
+  return R.pipe(
+    R.reduce(
+      (acc, value) => {
+        const { id, parent } = value;
+        const _parent = R.isNil(parent) || !R.has(parent, indexed)
+          ? '#ROOT'
+          : parent;
+        return R.over(
+          R.lensProp(_parent),
+          ids => R.isNil(ids) ? [id] : R.append(id, ids)
+        )(acc);
+      },
+      {}
+    ),
+    R.map(R.sortBy(id => R.pathOr(-1, [id, '__indexPosition'], indexed)))
+  )(values);
+};
+
+export const getDimensionsSimpleHierarchies = (dimensions) => R.reduce(
+  (acc, dim) => {
+    const { id, values } = dim;
+    if (R.length(values) < 2) {
+      return acc;
+    }
+    const hierarchy = getDimensionSimpleHierarchy(dim);
+    return R.assoc(id, hierarchy, acc);
+  },
+  {},
+  dimensions
+);

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 || '';
+    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/hierarchiseDimension.js

@@ -0,0 +1,38 @@
+import * as R from 'ramda';
+
+export const hierarchiseDimension = (dimension, hierarchy) => {
+  const indexed = R.indexBy(R.prop('id'), dimension.values);
+  let _hierarchy = hierarchy;
+  if (!R.has('#ROOT', hierarchy)) {
+    const indexes = R.pluck('id', dimension.values);
+    const refinedHierarchy = R.pick(indexes, _hierarchy);
+    const childrenIds = R.pipe(R.values, R.unnest, R.indexBy(R.identity))(refinedHierarchy);
+    const rootIds = R.pipe(
+      R.reject(val => R.has(val.id, childrenIds)),
+      R.sortBy(R.prop('__indexPosition')),
+      R.pluck('id')
+    )(dimension.values);
+    _hierarchy = R.assoc('#ROOT', rootIds, hierarchy);
+  }
+
+  const getChildren = (parents) => R.pipe(
+    ids => 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.last(parents) || '#ROOT', _hierarchy));
+
+  return R.set(
+    R.lensProp('values'),
+    R.flatten(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,14 @@
+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 || []);
+
+  return R.pipe(
+    R.propOr([], 'hierarchicalCodes'),
+    R.reduce((acc, parentCode) => {
+      const children = R.pluck('id', parentCode.hierarchicalCodes || []);
+      return R.assoc(parentCode.id, children, acc);
+    }, {}),
+  )(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' },

package/test/getCells.test.js

@@ -13,6 +13,7 @@ describe('getCells tests', () => {
     expect(getCells({
       observations: {
         a: {
+          key: 'a',
           value: 33,
           formattedValue: '33',
           attributes: {
@@ -26,6 +27,7 @@ describe('getCells tests', () => {
     }, 'label', customAttributes,
     { unitsDefinitionCodes: [], unitsSeries: {}, unitsDisplay: 'cells', unitDimension: {} }, [])).to.deep.equal({
       a: {
+        key: 'a',
         value: '33',
         intValue: 33,
         flags: [
@@ -42,6 +44,7 @@ describe('getCells tests', () => {
     expect(getCells({
       observations: {
         a: {
+          key: 'a',
           value: 33,
           formattedValue: '33',
           attributes: {
@@ -54,6 +57,7 @@ describe('getCells tests', () => {
       }
     }, 'both', customAttributes, {}, [])).to.deep.equal({
       a: {
+        key: 'a',
         value: '33',
         intValue: 33,
         flags: [
@@ -66,15 +70,4 @@ describe('getCells tests', () => {
       }
     })
   });
-  /*it('string observation type display test', () => {
-    expect(getCells({
-      observations: {
-        a: { value: '16.35',  units: {}, decimals: '2', prefscale: '1', indexedDimValIds: {} },
-        b: { value: '155062.56',  units: {}, decimals: '3', indexedDimValIds: {} },
-      }
-    }, 'label', customAttributes, {}, OBS_TYPE_NUMERICAL_STRING)).to.deep.equal({
-      a: { value: '16.35',  intValue: '16.35', flags: [], indexedDimValIds: {} },
-      b: { value: '155062.56',  intValue: '155062.56', flags: [], indexedDimValIds: {} },
-    })
-  });*/
 });

package/test/getDimensionValuesIndexes.test.js

@@ -0,0 +1,33 @@
+import { expect } from 'chai';
+import { getDimensionValuesIndexes } from '../src/rules2/src/getDimensionValuesIndexes';
+
+describe('getDimensionValuesIndexes test', () => {
+  it('basic test', () => {
+    const values = [
+      { id: 'OECD', parent: undefined, parents: [], __index: 2 },
+      { id: 'GER', parent: 'OECD', parents: ['OECD'], __index: 1 },
+      { id: 'FRA', parent: 'OECD', parents: ['OECD'], __index: 0 },
+      { id: 'USA', parent: 'OECD', parents: ['OECD'], __index: 3 },
+      { id: 'A', parent: undefined, parents: [], __index: 4 },
+      { id: 'USA', parent: 'A', parents: ['A'], __index: 3 },
+      { id: 'MEX', parent: 'A', parents: ['A'], __index: 7 },
+      { id: 'EA', parent: undefined, parents: [], __index: 5 },
+      { id: 'FRA', parent: 'EA', parents: ['EA'], __index: 0 },
+      { id: 'GER', parent: 'EA', parents: ['EA'], __index: 1 },
+      { id: 'CHI', parent: undefined, parents: [], __index: 6 }
+    ];
+
+    const indexes = {
+      '0': [2, 8],
+      '1': [1, 9],
+      '2': [0],
+      '3': [3, 5],
+      '4': [4],
+      '5': [7],
+      '6': [10],
+      '7': [6]
+    };
+
+    expect(getDimensionValuesIndexes(values)).to.deep.equal(indexes);
+  });
+});

package/test/getHCodelistsRefs.test.js

@@ -0,0 +1,20 @@
+import { expect } from 'chai';
+import { getHCodelistsRefs } from '../src/rules2/src';
+
+describe('getHCodelistsRefs tests', () => {
+  it('basic case', () => {
+    const annotations = [
+      { type: 'test' },
+      { type: 'HIER_CONTEXT', text: 'C1:A:HCL1(1.0).HIER1' },
+      { type: 'HIER_CONTEXT', text: 'C2:A:HCL2(1.0).HIER1' },
+      { type: 'HIER_CONTEXT', text: 'C1:A:HCL1(1.0).HIER2' },
+    ];
+
+    const expected = {
+      C1: { agencyId: 'A', codelistId: 'C1', code: 'HCL1', hierarchy: 'HIER2', version: '1.0' },
+      C2: { agencyId: 'A', codelistId: 'C2', code: 'HCL2', hierarchy: 'HIER1', version: '1.0' },
+    }
+  
+    expect(getHCodelistsRefs(annotations)).to.deep.equal(expected);
+  });
+});