@sis-cc/dotstatsuite-components 22.0.1 → 22.0.2

package/src/rules/src/preparators/enhanceObservations.js

@@ -0,0 +1,152 @@
+import * as R from 'ramda';
+import { formatValue } from './formatValue';
+
+/*
+  options = {
+    attachmentSeriesIndexes, //units
+    customAttributes: {
+      decimals: id,
+      prefscale: id,
+    },
+    unitsArtefacts,
+    obsAttributes,
+    rejectedValueIds,
+  }
+*/
+
+const getSerieKey = (dimValuesIndexes, options) => {
+  let indexes = R.propOr([], 'attachmentSeriesIndexes', options);
+  return R.pipe(
+    R.addIndex(R.map)((valueIndex, dimIndex) => {
+      if (dimIndex === R.head(indexes)) {
+        indexes = R.tail(indexes);
+        return valueIndex;
+      }
+      return 'x';
+    }),
+    R.join(':')
+  )(dimValuesIndexes);
+};
+
+const getUnitsValues = (indexes, options) => R.reduce(
+  (acc, codelist) => {
+    const { id } = codelist;
+    if (!R.includes(id, R.propOr([], 'unitsIds', options))) {
+      return acc;
+    }
+    const valueIndex = R.prop(codelist.__index, indexes);
+    if (R.isNil(valueIndex) || !R.propOr(true, 'display', codelist)) {
+      return acc;
+    }
+    const value = R.path(['values', Number(valueIndex)], codelist);
+    if (R.isNil(value) || R.includes(value.id, R.propOr([], 'rejectedValueIds', options))
+      || !R.propOr(true, 'display', value)) {
+      return acc;
+    }
+    return R.assoc(
+      id,
+      {
+        ...R.pick(['id', 'name', '__index'], codelist),
+        value: R.when(R.complement(R.isNil), R.assoc('index', Number(valueIndex)))(value)
+      },
+      acc
+    );
+  },
+  {}
+);
+
+const getObservationUnits = (observation, dimensions, attributes, options) => {
+  const dimensionsUnits = getUnitsValues(
+    R.propOr([], 'dimValuesIndexes', observation),
+    options
+  )(dimensions);
+
+  const attributesUnits = getUnitsValues(
+    R.propOr([], 'attrValuesIndexes', observation),
+    options
+  )(attributes);
+  
+  const serieKey = getSerieKey(R.propOr([], 'dimValuesIndexes', observation), options);
+
+  return ({ ...dimensionsUnits, ...attributesUnits, serieKey });
+};
+
+const getFormatAttributesIndexes = (attributes, customAttributes) => R.addIndex(R.reduce)(
+  (acc, attribute, index) => {
+    if (R.equals(attribute.id, customAttributes.decimals)) {
+      return ({ ...acc, decimals: index });
+    }
+    if (R.equals(attribute.id, customAttributes.prefscale)) {
+      return ({ ...acc, prefscale: index });
+    }
+    return acc;
+  },
+  { prefscale: null, decimals: null },
+  attributes
+);
+
+const getAttributeValue = (attribute, valueIndex, options) => {
+  if (!R.propOr(true, 'display', attribute)) {
+    return null;
+  }
+  const value = R.pipe(
+    R.propOr([], 'values'),
+    R.nth(valueIndex)
+  )(attribute);
+
+  if (R.isNil(value) || !R.propOr(true, 'display', value) || R.includes(value.id,R.propOr([],'rejectedValueIds')(options))) {
+    return null;
+  }
+
+  return ({
+    ...R.pick(['id', 'name'], attribute),
+    value: R.pick(['id', 'name'], value)
+  });
+};
+
+
+export const enhanceObservations = (dimensions = [], observations = {}, attributes = [], options = {}) => {
+  const formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
+  const _attributes = R.addIndex(R.map)((attr, index) => R.assoc('__index', index, attr), attributes);
+  const _obsAttributes = R.pipe(
+    R.indexBy(R.prop('id')),
+    R.props(options.attributesIds || [])
+  )(_attributes);
+
+  return R.mapObjIndexed(
+    (observation) => {
+      const { attrValuesIndexes, dimValuesIndexes } = observation;
+      const obsAttributes = R.reduce(
+        (acc, attribute) => {
+          const attrValue = getAttributeValue(attribute, R.nth(attribute.__index, attrValuesIndexes), options);
+          if (R.isNil(attrValue)) {
+            return acc;
+          }
+          return R.assoc(attribute.id, attrValue, acc);
+        },
+        {},
+        _obsAttributes
+      );
+
+      const indexedDimValIds = R.addIndex(R.reduce)(
+        (acc, dimension, dimensionIndex) => {
+          const id = dimension.id;
+          const valueIndex = R.nth(dimensionIndex, dimValuesIndexes);
+          const valueId = R.path(['values', Number(valueIndex), 'id'], dimension);
+          return R.assoc(id, valueId, acc);
+        },
+        {},
+        dimensions
+      );
+
+      return ({
+        ...observation,
+        attributes: obsAttributes,
+        formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
+        units: getObservationUnits(observation, dimensions, _attributes, options),
+        indexedDimValIds,
+      });
+    },
+    observations
+  );
+};

package/src/rules/src/preparators/formatValue.js

@@ -0,0 +1,93 @@
+import * as R from 'ramda';
+import numeral from 'numeral';
+
+const isValidNumber = R.both(R.is(Number), R.complement(R.equals(NaN)));
+const parseValidNumber = R.pipe(
+  v => R.isNil(v) ? null : Number(v),
+  v => isNaN(v) ? null : v
+);
+
+const getFormatAttributesValues = (observation, formatAttributesIndexes, attributes) => R.mapObjIndexed(
+  attributeIndex => {
+    let valueIndex;
+    const relationship = R.pipe(R.nth(attributeIndex), R.propOr({}, 'relationship'))(attributes);
+    //if (!R.isNil(attributeIndex) && attributeIndex >= R.length(R.propOr([], 'attrValuesIndexes', observation))) {
+    if (R.has('none', relationship) || R.has('dataflow', relationship)) {
+      valueIndex = 0;
+    }
+    else {
+      valueIndex = R.pipe(
+        R.propOr([], 'attrValuesIndexes'),
+        R.nth(attributeIndex),
+        parseValidNumber
+      )(observation);
+    }
+
+    return R.pipe(
+      R.path([attributeIndex, 'values', valueIndex, 'id']),
+      parseValidNumber
+    )(attributes);
+  },
+  formatAttributesIndexes
+);
+
+export const formatValue = (observation, formatAttributesIndexes, attributes) => {
+  const value = R.prop('value', observation);
+  if (R.is(Boolean, value)) {
+    return value;
+  }
+  if (R.is(String, value)) {
+    const monthMatch = value.match(/^\-\-([\d]{2})$/);
+    if (R.is(Array, monthMatch)) {
+      return R.nth(1, monthMatch);
+    }
+    const monthDayMatch = value.match(/^\-\-([\d]{2}\-[\d]{2})$/);
+    if (R.is(Array, monthDayMatch)) {
+      return R.nth(1, monthDayMatch);
+    }
+    const dayMatch = value.match(/^\-\-\-([\d]{2})$/);
+    if (R.is(Array, dayMatch)) {
+      return R.nth(1, dayMatch);
+    }
+    return value;
+  }
+
+  const { prefscale, decimals } = getFormatAttributesValues(
+    observation,
+    formatAttributesIndexes,
+    attributes
+  );
+
+  const formatScale = R.when(
+    R.always(isValidNumber(prefscale)),
+    value => numeral(value).multiply(Math.pow(10, -1 * Number(prefscale))).value(),
+  );
+
+  const formatSeparator = value => numeral(value).format(`0,0.[0000000]`);
+  const formatDecimals = R.ifElse(
+    R.always(isValidNumber(decimals)),
+    v => {
+      const num = Number(v);
+      const isTiny = Math.abs(num) < Math.pow(10, -(decimals ?? 2) + 1);
+      const displayNum = isTiny ? 0 : num;
+      const decimalFormat =
+        R.ifElse(
+          R.equals(0),
+          R.always('0,0'),
+          d => `0,0.${R.join('', R.times(R.always('0'), d))}`
+        )(decimals ?? 2);
+
+      return numeral(displayNum).format(decimalFormat);
+    },
+    formatSeparator
+  );
+  return R.ifElse(
+    isValidNumber,
+    R.pipe(
+      formatScale,
+      formatDecimals,
+      res => res === 'NaN' ? String(value) : res
+    ),
+    R.always('..')
+  )(observation.value);
+};

package/src/rules/src/preparators/getObservations.js

@@ -0,0 +1,19 @@
+import * as R from 'ramda';
+
+export const getObservations = (sdmxJson) => R.pipe(
+  R.pathOr({}, ['data', 'dataSets', 0, 'observations']),
+  R.mapObjIndexed(
+    (observation, observationKey) => {
+      const value = R.head(observation);
+      const attrValuesIndexes = R.tail(observation);
+      const dimValuesIndexes = R.split(':', observationKey);
+
+      return ({
+        key: observationKey,
+        value,
+        attrValuesIndexes,
+        dimValuesIndexes
+      });
+    },
+  )
+)(sdmxJson);

package/src/rules/src/preparators/getReportingYearStart.js

@@ -0,0 +1,16 @@
+import * as R from 'ramda';
+import { REPORTING_YEAR_START_DAY, REPYEARSTART } from '../constants';
+
+export const getReportingYearStart = (sdmxJson) => {
+  const attributes = R.pipe(
+    R.pathOr({}, ['data', 'structure', 'attributes']),
+    ({ dataSet=[], observation=[], series=[] }) => [...dataSet, ...observation, ...series]
+  )(sdmxJson);
+
+  const reportYearStartAttr = R.find(({ id }) => {
+    return id === REPORTING_YEAR_START_DAY || id === REPYEARSTART;
+  }, attributes) || {};
+  const reportYearStart = R.pathOr('--01-01', ['values', 0, 'value'], reportYearStartAttr);
+  const [month = '01', day = '01'] = R.match(/[\d]{2}/g, reportYearStart);
+  return ({ month, day });
+};

package/src/rules/src/properties/errors.js

@@ -0,0 +1,19 @@
+import * as R from 'ramda';
+import { TIMELINE } from '../constants';
+import { getTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+
+export const getHasNoTimePeriodError = ({ data, type }) => {
+  if (!R.equals(TIMELINE, type)) {
+    return false;
+  }
+  const dimensions = R.pathOr([], ['structure', 'dimensions', 'observation'], data);
+  const timeDimension = getTimePeriodDimension({ dimensions });
+  if (R.isNil(timeDimension)) {
+    return true;
+  }
+  return R.pipe(
+    R.propOr([], 'values'),
+    R.length,
+    R.gte(1)
+  )(timeDimension);
+};

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

@@ -0,0 +1,69 @@
+import * as R from 'ramda';
+import { extractSdmxArtefacts, focus } from '../';
+import { BAR, ROW, TIMELINE } from '../constants';
+import { hasFocus } from './utils';
+
+const sampleFocusTypes = { [BAR]: BAR, [ROW]: ROW, [TIMELINE]: TIMELINE };
+
+const focusComparator = (op1, op2) => op1.value === op2.value;
+
+export const focusOptions = (props, state, otherFocus, singularity) => {
+  if (!hasFocus(props.type)) {
+    return [];
+  }
+  const options = focus(
+    props.data,
+    props.type,
+    singularity,
+    props.display
+  );
+  return R.differenceWith(
+    focusComparator,
+    options,
+    R.prop(otherFocus, state)
+  );
+};
+
+export const onChangeFocusSelection = (_value) => {
+  const value = R.isNil(_value) ? [] : _value;
+  return (R.is(Array, value) ? value : [value]);
+};
+
+const toKey = () => R.prop('value');
+
+const filterFocus = (focus, keyedOptions, type) => R.reduce(
+  (acc, entry) => {
+    const entryKey = toKey(type)(entry);
+    if (R.has(entryKey, keyedOptions)) {
+      return R.append(R.prop(entryKey, keyedOptions), acc);
+    }
+    return acc;
+  },
+  [],
+  focus
+)
+
+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);
+  const keyedOptions = R.indexBy(toKey(type), options);
+  return ({
+    baseline: filterFocus(baselineState, keyedOptions, R.prop('type', state)),
+    highlight: filterFocus(highlightState, keyedOptions, R.prop('type', state)),
+  });
+};
+
+/*
+  This props/state parser which will be exposed in highlight/baseline properties,
+  only deals for Bar and Row Chart (no chart dimension singularity involved).
+  For other chart types, their own chart dimension singularity parser will handle focus management.
+*/
+
+export const sampleFocusStateFromNewProps = (props, state) => {
+  if (!R.has(props.type, sampleFocusTypes) || R.isNil(props.data)) {
+    return ({}); //no changes
+  }
+  return focusStateFromNewProps(props, null, state);
+};

package/src/rules/src/properties/getAvailableChartTypes.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+import {
+  CHORO,
+  OBS_TYPE_NUMBER,
+  OBS_TYPE_NUMERICAL_STRING,
+  TIMELINE,
+  TYPES
+} from '../constants';
+import { getRefAreaDimension, getTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+import { getObservationsType } from './getObservationsType';
+
+export const getAvailableChartTypes = (data) => {
+  const observationsType = getObservationsType(data);
+  if (!R.includes(observationsType, [OBS_TYPE_NUMBER, OBS_TYPE_NUMERICAL_STRING])) {
+    return {};
+  }
+  const dimensions = R.pathOr([], ['structure', 'dimensions', 'observation'], data);
+  const timeDimension = getTimePeriodDimension({ dimensions });
+  const refAreaDimension = getRefAreaDimension({ dimensions });
+  const hasNoTime = R.anyPass([
+    R.isNil,
+    R.pipe(R.propOr([], 'values'), R.length, R.gte(1))
+  ])(timeDimension);
+  return R.pipe(
+    R.when(
+      R.always(hasNoTime),
+      R.omit([TIMELINE])
+    ),
+    R.when(
+      R.always(R.isNil(refAreaDimension)),
+      R.omit([CHORO])
+    )
+  )(TYPES);
+};

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

@@ -0,0 +1,74 @@
+import * as R from 'ramda';
+import {
+  getDefaultSubtitle,
+  getHeaderUnits,
+  getSubtitleFlags,
+  getTitleFlags
+} from '../header';
+import { dimensionValueDisplay, parseDisplay } from '../';
+import { isChart } from './utils';
+
+const isCustomInvalid = ({ type }) => (value) => R.isNil(value) || !isChart(type);
+
+const getDataflowName = (props) => {
+  const dataflow = R.propOr({}, 'dataflow', props);
+  const display = parseDisplay(props.display);
+  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,
+  sourceLabel: getSourceLabel(props, state)
+});

package/src/rules/src/properties/getInformationsStateFromNewProps.js

@@ -0,0 +1,47 @@
+import * as R from 'ramda';
+import { extractSdmxArtefacts, prepareData } from '../';
+
+const initialState = {
+  dataflow: null,
+  dataflowAttributes: null,
+  dimensions: null,
+  units: null,
+  id: null,
+  sourceLabel: null,
+  subtitle: null,
+  title: null,
+  withCopyright: true,
+  withLogo: true
+};
+
+export const getInformationsStateFromNewProps = (props, state) => {
+  if (R.isNil(props.data)) {
+    return initialState
+  }
+  const id = R.pipe(
+    R.prop('data'),
+    extractSdmxArtefacts,
+    R.prop('id')
+  )(props);
+  if (id === state.id && props.display === state.display) {
+    return {};
+  }
+  const {
+    dataflowAttributes,
+    dataflowName,
+    dimensions,
+    units
+  } = prepareData({ data: props.data }, props.customAttributes, props.units);
+  return {
+    ...initialState,
+    dataflow: {
+      id: props.dataflowId,
+      name: dataflowName
+    },
+    dataflowAttributes,
+    dimensions,
+    display: props.display,
+    id,
+    units
+  };
+};

package/src/rules/src/properties/getObservationsType.js

@@ -0,0 +1,29 @@
+import * as R from 'ramda';
+import {
+  OBS_TYPE_NUMBER,
+  OBS_TYPE_NUMERICAL_STRING,
+  OBS_TYPE_STRING
+} from '../constants';
+
+export const getObservationsType = (data) => {
+  if (R.isNil(data)) {
+    return undefined;
+  }
+  const firstObs = R.pipe(
+    R.pathOr({}, ['dataSets', 0, 'observations']),
+    R.values,
+    R.find(obs => R.not(R.either(R.isNil, R.isEmpty)(R.head(obs))))
+  )(data);
+  if (R.isNil(firstObs)) {
+    return undefined;
+  }
+  const firstObsValue = R.head(firstObs);
+  if (R.is(Number, firstObsValue)) {
+    return OBS_TYPE_NUMBER;
+  }
+  return R.ifElse(
+    R.equals(NaN),
+    R.always(OBS_TYPE_STRING),
+    R.always(OBS_TYPE_NUMERICAL_STRING)
+  )(Number(firstObsValue));
+};

package/src/rules/src/properties/getStringifiedSubtitle.js

@@ -0,0 +1,6 @@
+import * as R from 'ramda';
+
+export const stringifySubtitle = R.pipe(
+  R.map(({ header, label }) => R.isNil(header) ? label : `${header} ${label}`),
+  R.join(' · ')
+);