@sis-cc/dotstatsuite-components 22.6.0 → 23.0.0

package/src/rules/src/properties/focus.js

@@ -1,12 +1,61 @@
 import * as R from 'ramda';
-import { extractSdmxArtefacts, focus } from '../';
+import getSeries from '../factories/series';
 import { BAR, ROW, TIMELINE } from '../constants';
 import { hasFocus } from './utils';
+import { dimensionValueDisplay, parseDisplay } from '../dimension-utils';
 
 const sampleFocusTypes = { [BAR]: BAR, [ROW]: ROW, [TIMELINE]: TIMELINE };
 
 const focusComparator = (op1, op2) => op1.value === op2.value;
 
+const focus = (data, type, dimension, _display) => {
+  const display = parseDisplay(_display);
+  switch(type) {
+    case 'RowChart': case 'BarChart':
+    case 'HorizontalSymbolChart': case 'VerticalSymbolChart':
+    case 'StackedBarChart': case 'StackedRowChart':
+      return R.pipe(
+        getSeries,
+        R.pathOr([], [0, 'datapoints']),
+        R.map(dp => ({ label: dp.category, value: dp.key })),
+      )({ data, type, options: { display }, singularity: dimension });
+    case 'TimelineChart':
+      return R.pipe(
+        getSeries,
+        R.map(serie => ({ label: serie.category, value: serie.key })),
+      )({ data, type, options: { display }, singularity: dimension });
+    case 'ScatterChart':
+      const id = R.prop('id', dimension);
+      if (R.isNil(id))
+        return [];
+      return R.pipe(
+        R.propOr([], 'dimensions'),
+        R.reduce((acc, dim) => {
+          if (dim.header || dim.id === id) {
+            return acc;
+          }
+          const dimOptions = R.map(val => ({
+            label: `${dimensionValueDisplay(display)(dim)} - ${dimensionValueDisplay(display)(val)}`,
+            options: { dimensionId: dim.id, dimensionValueId: val.id },
+            value: `${dim.id}-${val.id}`
+          }), R.propOr([], 'values', dim));
+          return R.concat(acc, dimOptions);
+        }, []),
+      )(data);
+    default:
+      return [];
+  }
+};
+
+export const parseFocus = (data, type, dimension, display, { baseline, highlight }) => {
+  const options = focus(data, type, dimension, display);
+  const optionsSet = new Set(R.pluck('value', options));
+
+  const parseSelection = R.reject(({ value }) => !optionsSet.has(value));
+
+  return ({ baseline: parseSelection(baseline), highlight: parseSelection(highlight) });
+};
+
 export const focusOptions = (props, state, otherFocus, singularity) => {
   if (!hasFocus(props.type)) {
     return [];
@@ -44,7 +93,6 @@ const filterFocus = (focus, keyedOptions, type) => R.reduce(
 )
 
 export const focusStateFromNewProps = ({ data, display, type }, singularity, state) => {
-  const { id } = extractSdmxArtefacts(data);
   const highlightState = R.propOr([], 'highlight', state);
   const baselineState = R.propOr([], 'baseline', state);
   const options = focus(data, type, singularity, display);

package/src/rules/src/properties/getHeaderProps.js

@@ -1,11 +1,5 @@
 import * as R from 'ramda';
-import {
-  getDefaultSubtitle,
-  getHeaderUnits,
-  getSubtitleFlags,
-  getTitleFlags
-} from '../header';
-import { dimensionValueDisplay, parseDisplay } from '../';
+import { dimensionValueDisplay, parseDisplay } from '../dimension-utils';
 import { isChart } from './utils';
 
 const isCustomInvalid = ({ type }) => (value) => R.isNil(value) || !isChart(type);
@@ -16,57 +10,11 @@ const getDataflowName = (props) => {
   return dimensionValueDisplay(display)(dataflow);
 };
 
-export const getTitleLabel = (props, state) => R.when(
-  isCustomInvalid({ type: props.type }),
-  R.always(getDataflowName(props))
-)(state.title);
-
-export const getSubtitle = (props, state) => R.ifElse(
-  isCustomInvalid({type: props.type }),
-  R.always(getDefaultSubtitle({
-    customAttributes: props.customAttributes,
-    dimensions: state.dimensions,
-    display: props.display,
-    units: state.units
-  })),
-  (label) => {
-    const flags = getSubtitleFlags({
-      customAttributes: props.customAttributes,
-      dimensions: state.dimensions,
-      display: props.display,
-      units: state.units
-    });
-    return ([{ label, flags }]);
-  }
-)(state.subtitle);
-
 export const getSourceLabel = (props, state) => R.when(
   isCustomInvalid({ type: props.type }),
   R.always(getDataflowName(props))
 )(state.sourceLabel);
 
-export const getHeaderProps = (props, state) => {
-  const title = {
-    label: getTitleLabel(props, state),
-    flags: getTitleFlags({
-      customAttributes: props.customAttributes,
-      dataflowAttributes: state.dataflowAttributes,
-      display: props.display,
-    })
-  };
-
-  const subtitle = getSubtitle(props, state);
-
-  const uprs = getHeaderUnits({
-    display: props.display,
-    units: R.assoc(
-      'values',
-      R.pathOr([], ['units', 'headerUnits'], state)
-    )(R.pathOr({}, ['units', 'unitDimension'], props))
-  });
-  return ({ subtitle, title, uprs });
-};
-
 export const getFooterProps = (props, state) => ({
   withCopyright: isChart(props.type) ? state.withCopyright : true,
   withLogo: isChart(props.type) ? state.withLogo : true,

package/src/rules/src/properties/index.js

@@ -1,6 +1,4 @@
 import * as R from 'ramda';
-import { getDataFrequency } from '@sis-cc/dotstatsuite-sdmxjs';
-import { series } from '../';
 import {
   H_SYMBOL,
   SCATTER,
@@ -49,12 +47,11 @@ import {
   hasFocus,
   isChart,
   isNaturalInt,
-  isNumber,
   optionParser,
 } from './utils';
-import { getTitleLabel, getSubtitle, getSourceLabel } from './getHeaderProps';
+import { getSourceLabel } from './getHeaderProps';
 import { stringifySubtitle } from './getStringifiedSubtitle';
-import { getHasNoTimePeriodError } from './errors';
+
 /*
  - width/height -> initial undefined, if undefined or blank, replaced by options.base
 */
@@ -72,32 +69,6 @@ export const toSingularity = ({ data, type }, state) => {
   }
 };
 
-export const toChartData = (props, state) => {
-  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], props);
-  const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], props);
-  const frequency = props.type === TIMELINE ? getDataFrequency({ dimensions, attributes }) : null;
-  return ({
-    frequency,
-    series: series(
-      props.data,
-      props.type,
-      R.pick(['highlight', 'baseline'], state),
-      toSingularity(props, state),
-      props.map,
-      props.display,
-      props.formaterIds
-    ),
-    share: {
-      focused: R.pick(['highlight', 'baseline'], state),
-      chartDimension: toSingularity(props, state),
-    }
-  });
-};
-
-export const getErrors = (props, state) => ({
-  noTime: getHasNoTimePeriodError(props),
-});
-
 const toFloat = (value) => {
   const float = parseFloat(value);
   return isNaN(float) ? undefined : float;
@@ -171,25 +142,6 @@ export const toChartOptions = (props, state) => {
   });
 };
 
-export const initialState = {
-  highlight: [],
-  baseline: [],
-  fixedWidth: undefined,
-  fixedHeight: undefined,
-  freqStep: undefined,
-  responsiveWidth: undefined,
-  responsiveHeight: undefined,
-  scatterDimension: undefined,
-  scatterX: undefined,
-  scatterY: undefined,
-  symbolDimension: undefined,
-  stackedDimension: undefined,
-  stackedMode: undefined,
-  id: undefined,
-  type: undefined,
-  ...linearInitialState,
-};
-
 export const stateFromNewProps = (props, state) => {
   const focusState = sampleFocusStateFromNewProps(props, state);
   const scatterState = scatterStateFromNewProps(props, state);
@@ -212,49 +164,6 @@ export const stateFromNewProps = (props, state) => {
   });
 };
 
-const propertiesParsers = {
-  highlight: onChangeFocusSelection,
-  baseline: onChangeFocusSelection,
-  fixedWidth: (value) => isNaturalInt(value) ? value : undefined,
-  fixedHeight: (value) => isNaturalInt(value) ? value : undefined,
-  responsiveWidth: (value) => isNumber(value) ? value : undefined,
-  responsiveHeight: (value) => isNumber(value) ? value : undefined,
-  freqStep: (value) => isNaturalInt(value) ? value : undefined,
-  title: R.identity,
-  subtitle: R.identity,
-  sourceLabel: R.identity,
-  scatterDimension: optionParser,
-  scatterX: optionParser,
-  scatterY: optionParser,
-  symbolDimension: optionParser,
-  stackedDimension: optionParser,
-  stackedMode: optionParser,
-  maxX: (value) => isNumber(value) ? value : undefined,
-  maxY: (value) => isNumber(value) ? value : undefined,
-  minX: (value) => isNumber(value) ? value : undefined,
-  minY: (value) => isNumber(value) ? value : undefined,
-  pivotX: (value) => isNumber(value) ? value : undefined,
-  pivotY: (value) => isNumber(value) ? value : undefined,
-  stepX: (value) => isNaturalInt(value) ? value : undefined,
-  stepY: (value) => isNaturalInt(value) ? value : undefined,
-};
-
-export const onChangeProperties = (state, onChange) => (newProperties) => {
-  const apply = R.is(Function, onChange) ? onChange : R.identity;
-  const refined = R.pipe(
-    R.mapObjIndexed((value, key) => {
-      const _parser = R.prop(key, propertiesParsers);
-      const parser = R.is(Function, _parser) ? _parser : R.identity;
-      return parser(value); 
-    }),
-    R.pickBy((value, key) => value !== R.prop(key, state))
-  )(newProperties);
-  if (R.isEmpty(refined)) {
-    return ;
-  }
-  apply(refined);
-};
-
 export const toProperties = (props, state, onChange) => ({
   ...toLinearProperties(props, state, onChange),
   highlight: {

package/src/rules/src/properties/linear.js

@@ -95,7 +95,7 @@ export const toProperties = (props, state, onChange) => ({
       pivotX: isNumber(value) ? value : undefined
     }),
     value: R.when(
-      v => R.isNil(v) && (R.propEq('type', ROW)(props) || R.propEq('type', STACKED_ROW)(props)),
+      v => R.isNil(v) && (R.propEq(ROW, 'type')(props) || R.propEq(STACKED_ROW, 'type')(props)),
       R.always(0)
     )(R.isNil(state.pivotX) ? String(state.computedPivotX) : state.pivotX)
   },
@@ -106,7 +106,7 @@ export const toProperties = (props, state, onChange) => ({
       pivotY: isNumber(value) ? value : undefined
     }),
     value: R.when(
-      v => R.isNil(v) && (R.propEq('type', BAR)(props) || R.propEq('type', STACKED_BAR)(props)),
+      v => R.isNil(v) && (R.propEq(BAR, 'type')(props) || R.propEq(STACKED_BAR, 'type')(props)),
       R.always(0)
     )(R.isNil(state.pivotY) ? String(state.computedPivotY) : state.pivotY)
   },

package/src/rules/src/properties/scatter.js

@@ -66,7 +66,7 @@ export const scatterStateValueToOption = (property, props, state) => {
     return undefined;
   }
   const value = R.find(
-    R.propEq('id', R.prop(property, state)),
+    R.propEq(R.prop(property, state), 'id'),
     R.prop('values', dimension)
   );
   return artefactToOption(props.display)(value);
@@ -74,7 +74,7 @@ export const scatterStateValueToOption = (property, props, state) => {
 
 export const onChangeScatterVal = ({ data, type }, state, valKey, otherValKey) => (value) => {
   const options = scatterValueOptions({ data, type }, state);
-  const [matching, otherOptions] = R.partition(R.propEq('value', value), options);
+  const [matching, otherOptions] = R.partition(R.propEq(value, 'value'), options);
   if (R.isEmpty(matching)) {
     return ({});
   }
@@ -135,10 +135,10 @@ export const scatterStateFromNewProps = (props, state) => {
 
   //dirty as f
   const scatterX = R.isNil(_scatterX)
-    ? R.head(R.reject(R.propEq('id', R.prop('id', _scatterY)), values))
+    ? R.head(R.reject(R.propEq(R.prop('id', _scatterY), 'id'), values))
     : _scatterX;
   const scatterY = R.isNil(_scatterY)
-    ? R.head(R.reject(R.propEq('id', R.prop('id', scatterX)), values))
+    ? R.head(R.reject(R.propEq(R.prop('id', scatterX),'id'), values))
     : _scatterY;
 
   const scatterState = toScatterState(

package/src/rules/src/properties/stacked.js

@@ -6,7 +6,6 @@ import {
   getPropertyDimension,
   toState
 } from './utils';
-import { splitDimensions } from '../';
 import { focusStateFromNewProps } from './focus';
 
 const getStackedDimension = getPropertyDimension('stackedDimension');
@@ -41,8 +40,8 @@ export const onChangeStackedDimension = ({ data }, state) => (value) => {
 export const stackedModeOptions = [{ value: VALUES }, { value: PERCENT }];
 
 export const isStackedDimActive = ({ data, type }) => {
-  const { values } = splitDimensions(data);
-  if (R.length(values) < 2) {
+  const dimensions = getDimensionsWithValues(data);
+  if (R.length(dimensions) < 2) {
     return false;
   }
   return isStacked(type);
@@ -67,9 +66,8 @@ export const stackedStateFromNewProps = (props, state) => {
 
   let dimension = getStackedDimension(data, state);
   if (R.isNil(dimension)) {
-    const { value, values } = splitDimensions(data);
-    if (R.length(values) === 1) {
-      dimension = R.head(value);
+    if (R.length(dimensions) === 1) {
+      dimension = R.find(R.prop('header'), data.dimensions);
     }
     else {
       const { area, time, other } = getGroupedDimensions(data);

package/src/rules/src/properties/symbol.js

@@ -1,5 +1,4 @@
 import * as R from 'ramda';
-import { extractSdmxArtefacts } from '../';
 import { H_SYMBOL, V_SYMBOL } from '../constants';
 import {
   getDimensionsWithValues,

package/src/rules/src/properties/utils.js

@@ -3,8 +3,7 @@ import {
   find,
   groupBy,
   has,
-  head,
-  is,
+  isEmpty,
   isNil,
   length,
   map,
@@ -13,9 +12,11 @@ import {
   pipe,
   prop,
   propEq,
+  propOr,
+  reject
 } from 'ramda';
 import { isRefAreaDimension, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-import { extractSdmxArtefacts, parseDisplay, splitDimensions } from '../';
+import { parseDisplay } from '../dimension-utils';
 import { CHORO, STACKED_BAR, STACKED_ROW, TYPES } from '../constants';
 import { dimensionValueDisplay } from '../dimension-utils';
 
@@ -30,26 +31,23 @@ export const isPositiveNumber = (input) => {
 
 export const isNaturalInt = value => isNil(value) || /^\d+$/.test(String(value));
 
-export const isInt = value => isNil(value) || /^-?\d+$/.test(String(value));
 
 export const isChart = (type) => has(type, TYPES);
 
 export const hasFocus = (type) => has(type, omit([CHORO], TYPES));
 
 export const getDimensionsWithValues = (data) => pipe(
-  splitDimensions,
-  prop('values'),
+  propOr([], 'dimensions'),
+  reject(d => d.header || isEmpty(d.values || []))
 )(data);
 
 export const toState = (artefact) => prop('id', artefact);
 
 export const getPropertyDimension = (property) => (data, state) => {
-  const statePropertyDimensionId = prop(property, state);
-  const { dimensions } = extractSdmxArtefacts(data);
-  return find(
-    propEq('id', statePropertyDimensionId),
-    dimensions
-  );
+  const dimensionId = prop(property, state);
+  const { dimensions = [] } = data || {};
+
+  return find(propEq(dimensionId, 'id'), dimensions);
 };
 
 export const getGroupedDimensions = pipe(
@@ -73,10 +71,6 @@ export const optionParser = option => pipe(
   option => is(String, option) ? option : undefined
 )(option);
 
-export const optionsParser = selection => pipe(
-  selection => is(Array, selection) ? selection : [selection],
-  selection => map(optionParser, selection)
-)(selection);
 
 export const artefactToOption = (display) => (artefact) => isNil(artefact)
   ? undefined
@@ -85,11 +79,6 @@ export const artefactToOption = (display) => (artefact) => isNil(artefact)
     value: prop('id', artefact)
   };
 
-export const dimensionWithValuesToOptions = ({ data, display }) => pipe(
-  getDimensionsWithValues,
-  map(artefactToOption(display))
-)(data);
-
 export const chartDimensionToOption = (property) => ({ data, display }, state) => pipe(
   getPropertyDimension(property),
   artefactToOption(display)
@@ -99,7 +88,7 @@ export const chartDimensionOptions = ({ data, type, display }, typeValidator) =>
   if (!typeValidator(type)) {
     return [];
   }
-  const dimensions = prop('values', splitDimensions(data));
+  const dimensions = getDimensionsWithValues(data);
   if ((equals(type, STACKED_BAR) || equals(type, STACKED_ROW)) && length(dimensions) === 1) {
     return [];
   }

package/src/rules/src/sdmx-data/index.js

@@ -1,39 +1,10 @@
 import * as R from 'ramda';
 
-export const LAYOUT_ROW = 'LAYOUT_ROW';
-export const LAYOUT_COLUMN = 'LAYOUT_COLUMN';
-export const LAYOUT_ROW_SECTION = 'LAYOUT_ROW_SECTION';
-
-const ROWS = 'rows';
-const HEADER = 'header';
-const SECTIONS = 'sections';
-
-const ORDER = 'ORDER';
 const NOT_DISPLAYED = 'NOT_DISPLAYED';
 
-const getType = R.propOr({}, 'type');
-const getIds = (stringIds = '') => R.pipe(
-  R.append(R.split(',', stringIds)),
-  R.flatten
-);
-const getPivot = (key, stringIds) => R.over(R.lensProp(key), getIds(stringIds));
-
-export const setAnnotationsLayout = (stringIds, layout) => R.reduce((acc, annotation) => {
-  if (R.equals(getType(annotation), LAYOUT_ROW)) return getPivot(ROWS, stringIds)(acc);
-  if (R.equals(getType(annotation), LAYOUT_COLUMN)) return getPivot(HEADER, stringIds)(acc);
-  if (R.equals(getType(annotation), LAYOUT_ROW_SECTION)) return getPivot(SECTIONS, stringIds)(acc);
-  return acc;
-}, layout);
-
-export const getRelationnalAnnotations = annotationIndexes => annotations => R.map(annotationIndex =>
-  R.propOr({}, annotationIndex)(annotations)
-)(annotationIndexes);
-
-export const hiddenFormat = { isHidden: true }
-
 export const getIsHidden = annotations => R.pipe(
-  R.find(R.propEq('type', NOT_DISPLAYED)),
+  R.find(R.propEq(NOT_DISPLAYED, 'type')),
   R.complement(R.isNil)
 )(annotations);
 
-export const getFullName = R.identity;
+export const getFullName = R.identity;

package/src/rules2/src/combinedValuesDisplay.js

@@ -1,5 +1,5 @@
 import * as R from 'ramda';
-import { dimensionValueDisplay } from '../../rules/src';
+import { dimensionValueDisplay } from '../../rules/src/dimension-utils';
 import { REJECTED_VALUE_IDS } from './constants';
 
 const getRefinedMissinParentsLabels = R.pipe(
@@ -46,7 +46,7 @@ const _combinedValuesDisplay = (_display) => (values) =>
       if (!R.isEmpty(labels) || _display !== 'label') {
         return R.join(', ', labels);
       }
-      const totalValue = R.find(R.propEq('id', '_T'), values);
+      const totalValue = R.find(R.propEq('_T', 'id'), values);
       if (!R.isNil(totalValue)) {
         return dimensionValueDisplay('label')(totalValue);
       }

package/src/rules2/src/getAttributes.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+import { getIsHidden } from '../../rules/src/sdmx-data';
+import { getValuesEnhanced } from '../../rules/src/get-values-enhanced';
+
+export const getAttributes = ({ attributes, annotations, options }) => {
+  const {
+    hiddenCombinations = {},
+    hiddenValues = {},
+    locale = '',
+    ...restOptions
+  } = options;
+
+  const datasetAttributes = R.propOr([], 'dataSet', attributes);
+  const obsAttributes = R.propOr([], 'observation', attributes);
+
+  return R.pipe(
+    R.concat,
+    R.addIndex(R.map)((attr, index) => {
+      const attrAnnotations = R.props(attr.annotations || [], annotations);
+      return ({
+        ...attr,
+        __index: index,
+        display: !R.has(attr.id, hiddenValues) && !getIsHidden(attrAnnotations),
+        values: getValuesEnhanced({
+          locale,
+          annotations,
+          parent: attr.id,
+          hiddenIds: hiddenValues,
+          options: restOptions,
+        })(attr.values || [])
+      })
+    })
+  )(obsAttributes, datasetAttributes);
+};

package/src/rules2/src/getDataflowTooltipAttributesIds.js

@@ -4,8 +4,8 @@ export const getDataflowTooltipAttributesIds = (sdmxJson, defaults = {}) => {
   const dataflowAnnotationsIndexes = R.pathOr([], ['data', 'dataSets', 0, 'annotations'], sdmxJson);
   const dataflowAnnotations = R.props(dataflowAnnotationsIndexes, R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson));
 
-  const flagsAttrAnnotation = R.find(R.propEq('type', 'LAYOUT_FLAG'), dataflowAnnotations);
-  const footnotesAttrAnnotation = R.find(R.propEq('type', 'LAYOUT_NOTE'), dataflowAnnotations);
+  const flagsAttrAnnotation = R.find(R.propEq('LAYOUT_FLAG', 'type'), dataflowAnnotations);
+  const footnotesAttrAnnotation = R.find(R.propEq('LAYOUT_NOTE', 'type'), dataflowAnnotations);
 
   const customFlags = R.pipe(
     R.propOr('', 'title'),

package/src/rules2/src/getHeaderCombinations.js

@@ -1,5 +1,5 @@
 import * as R from 'ramda';
-import { dimensionValueDisplay } from '../../rules/src';
+import { dimensionValueDisplay } from '../../rules/src/dimension-utils';
 import { combinedValuesDisplay } from './combinedValuesDisplay';
 import { REJECTED_VALUE_IDS } from './constants';
 

package/src/rules2/src/getHeaderSubtitle.js

@@ -1,6 +1,6 @@
 import * as R from 'ramda';
 import { getFlagsAndNotes } from './table/getFlagsAndNotes';
-import { dimensionValueDisplay } from '../../rules/src/';
+import { dimensionValueDisplay } from '../../rules/src/dimension-utils';
 
 export const getHeaderSubtitle = (dimensions, combinations, customAttributes, display, microdataDimension) => {
   const combinationsConepts = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
@@ -8,7 +8,7 @@ export const getHeaderSubtitle = (dimensions, combinations, customAttributes, di
 
   return R.reduce(
     (acc, dim) => {
-      if (!R.propOr(true, 'display', dim) || R.propEq('id', microdataDimension, dim)
+      if (!R.propOr(true, 'display', dim) || R.propEq(microdataDimension, 'id', dim)
         || R.includes(dim.id, combinationsConepts)) {
         return acc;
       }

package/src/rules2/src/getHeaderTitle.js

@@ -1,5 +1,5 @@
 import * as R from 'ramda';
-import { dimensionValueDisplay } from '../../rules/src';
+import { dimensionValueDisplay } from '../../rules/src/dimension-utils';
 import { getFlagsAndNotes } from './table/getFlagsAndNotes';
 
 export const getHeaderTitle = (dataflow, attributes, display, customAttributes) => ({

package/src/rules2/src/getMetadataCoordinates.js

@@ -6,7 +6,7 @@ export const getMetadataCoordinates = (sdmxJson) => {
   const metadataAvailKeys = R.pipe(
     R.pathOr([], ['data', 'dataSets', 0, 'dimensionGroupAttributes']),
     R.map(indexes => R.props(indexes, annotations)),
-    R.filter(R.find(a => a && R.propEq('type', 'HAS_METADATA', a))),
+    R.filter(R.find(a => a && R.propEq('HAS_METADATA', 'type', a))),
     R.keys
   )(sdmxJson);
 

package/src/rules2/src/getNotDisplayedIds.js

@@ -42,7 +42,7 @@ const getNotDisplayedValues = annot => {
 };
 
 export const getNotDisplayedIds = (annotations) => R.pipe(
-  R.find(R.propEq('type', 'NOT_DISPLAYED')),
+  R.find(R.propEq('NOT_DISPLAYED', 'type')),
   R.converge((hiddenValues, hiddenCombinations) => ({
     hiddenValues,
     hiddenCombinations

package/src/rules2/src/index.js

@@ -16,6 +16,7 @@ export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierar
 export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
 export { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
+export { getAttributes } from './getAttributes';
 export { refineDimensions } from './refineDimensions';
 export { parseAttributes } from './parseAttributes';
 export { parseCombinations } from './parseCombinations';

package/src/rules2/src/parseAttributes.js

@@ -14,10 +14,10 @@ export const parseAttributes = (attributes, dimensions, customAttributes) => {
       || attr.id === REPYEARSTART) {
       return R.assoc('display', false, res);
     }
-    if (R.propEq('id', customAttributes.prefscale, attr)) {
+    if (R.propEq(customAttributes.prefscale, 'id', attr)) {
       return R.assoc('prefscale', true, res);
     }
-    if (R.propEq('id', customAttributes.decimals, attr)) {
+    if (R.propEq(customAttributes.decimals, 'id', attr)) {
       return R.assoc('decimals', true, res);
     }
     if (R.hasPath(['relationship', 'none'], attr) || R.hasPath(['relationship', 'dataflow'], attr)) {

package/src/rules2/src/parseHierarchicalCodelist.js

@@ -2,7 +2,7 @@ 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 hierarchy = R.find(R.propEq(hierarchyId, 'id'), hCodelist.hierarchies || []);
 
   const getParentedCodes = (codes, parent) => {
     const ids = R.pluck('codeID', codes);

package/src/rules2/src/parseMetadataSeries.js

@@ -47,7 +47,7 @@ export const parseMetadataSeries = (metadataJson, options) => {
           const val = R.nth(Number(vInd), dim.values || []);
 
           const originalVal = R.find(
-            R.propEq('id', val.id),
+            R.propEq(val.id, 'id'),
           )(R.propOr([], 'values', R.nth(dInd, options.dimensions)));
           return R.propOr('', '__index', originalVal);
         }),