@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

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

@@ -1,152 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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)),
-    value => numeral(value).format(
-      R.ifElse(R.equals(0), R.always('0,0'), d => `0,0.${R.join('', R.times(R.always('0'), d))}`)(decimals)
-    ),
-    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

@@ -1,19 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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