@sis-cc/dotstatsuite-components 23.2.0 → 24.0.0

package/src/rules/src/layout.js

@@ -1,115 +0,0 @@
-import * as R from 'ramda';
-import {
-  H_SYMBOL,
-  SCATTER,
-  STACKED_BAR,
-  STACKED_ROW,
-  V_SYMBOL
-} from './constants';
-import {
-  getCombinationDefinitions,
-  refineDimensions,
-  parseCombinationDefinition
-} from '../../rules2/src';
-import { getReportingYearStart } from './/preparators/getReportingYearStart';
-
-const isTableLayoutCompatible = (data, layout, combinationsDefinitions = [], dataquery = '') => {
-  const indexedCombinations = R.indexBy(R.prop('id'), combinationsDefinitions);
-  const reportYearStart = getReportingYearStart(data);
-  const indexedManyValuesDimensions = R.pipe(
-    R.pathOr([], ['structure', 'dimensions', 'observation']),
-    dimensions => refineDimensions({ dimensions, options: { dataquery, reportYearStart } }),
-    R.reject(d => R.prop('header', d) || !R.length(d.values || [])),
-    R.indexBy(R.prop('id'))
-  )(data);
-  let remainings = indexedManyValuesDimensions;
-  const layoutIds = R.pipe(R.values, R.unnest)(layout);
-  let hasFoundIrrelevant = false;
-  R.forEach(id => {
-    if (R.has(id, indexedManyValuesDimensions)) {
-      remainings = R.dissoc(id, remainings);
-    }
-    else if (R.has(id, indexedCombinations)) {
-      remainings = R.omit(R.pathOr([], [id, 'concepts'], indexedCombinations), remainings);
-    }
-    else if (id !== 'OBS_ATTRIBUTES') {
-      hasFoundIrrelevant = true;
-    }
-  }, layoutIds);
-  return R.isEmpty(remainings) && !hasFoundIrrelevant;
-};
-
-
-const isScatterLayoutCompatible = (data, chartDimension) => {
-  const { id, xId, yId } = chartDimension;
-
-  const dimensions = R.pathOr([], ['structure', 'dimensions', 'observation'], data);
-
-  const dimension = R.find(R.propEq(id, 'id'), dimensions);
-  if (R.isNil(dimension)) {
-    return false;
-  }
-  return R.pipe(
-    R.propOr([], 'values'),
-    R.indexBy(R.prop('id')),
-    R.pick([xId, yId]),
-    R.values,
-    R.length,
-    R.equals(2)
-  )(dimension);
-};
-
-const isSymbolLayoutCompatible = (data, chartDimension) => {
-  const { id, serie } = chartDimension;
-  const serieIds = R.pluck('id',serie);
-
-  return R.pipe(
-    R.pathOr([], ['structure', 'dimensions', 'observation']),
-    R.indexBy(R.prop('id')),
-    R.pathOr([], [id, 'values']),
-    R.indexBy(R.prop('id')),
-    R.pick(serieIds),
-    R.values,
-    R.length,
-    R.equals(R.length(serieIds))
-  )(data);
-};
-
-const isStackedLayoutCompatible = (data, chartDimension) => {
-  const { id } = chartDimension;
-
-  return R.pipe(
-    R.pathOr([], ['structure', 'dimensions', 'observation']),
-    R.filter(R.pipe(R.propOr([], 'values'), R.length, R.lt(1))),
-    R.indexBy(R.prop('id')),
-    R.has(id)
-  )(data);
-};
-
-const isChartLayoutCompatible = (data, type, chartDimension) => {
-  return R.cond([
-    [R.always(R.equals(SCATTER, type)), isScatterLayoutCompatible],
-    [R.always(R.equals(H_SYMBOL, type) || R.equals(V_SYMBOL, type)), isSymbolLayoutCompatible],
-    [R.always(R.anyPass([R.equals(STACKED_BAR), R.equals(STACKED_ROW)])(type)), isStackedLayoutCompatible],
-    [R.T, R.T]
-  ])(data, chartDimension);
-};
-
-export const isSharedLayoutCompatible = (sdmxData, sharedData) => {
-  const type = R.prop('type', sharedData);
-  if (type === 'table') {
-    const layoutIds = R.pathOr({}, ['config', 'table', 'layoutIds'], sharedData);
-    const dataquery = R.path(['config', 'sdmxSource', 'dataquery'], sharedData);
-    const annotations = R.pathOr({}, ['structure', 'annotations'], sdmxData)
-    const locale = R.pathOr({}, ['config', 'table', 'locale'], sharedData);
-    const rawDefaultCombinationsDefinition = R.pathOr({}, ['config', 'defaultCombinations'], sharedData);
-    const { concepts='', names='' } = rawDefaultCombinationsDefinition;
-    const defaultCombinationsDefinition = parseCombinationDefinition(locale)(concepts, names);
-    const customCombinationsDefinitions = getCombinationDefinitions(annotations, locale);
-    const combinationsDefinitions = R.isNil(customCombinationsDefinitions) || R.isEmpty(customCombinationsDefinitions)
-      ? defaultCombinationsDefinition : customCombinationsDefinitions;
-    return isTableLayoutCompatible(sdmxData, layoutIds, combinationsDefinitions, dataquery);
-  }
-  const chartDimension = R.pathOr({}, ['config', 'chart', 'chartDimension'], sharedData);
-  return isChartLayoutCompatible(sdmxData, type, chartDimension);
-};

package/src/rules/src/observation-formater.js

@@ -1,77 +0,0 @@
-import numeral from 'numeral';
-import * as R from 'ramda';
-
-const DEFAULT_PREFSCALE_ATTR_IDS = ["PREF_SCALE"];
-
-const DEFAULT_DECIMALS_ATTR_IDS = ["DECIMALS"];
-
-const getFormaterAttribute = (ids, attributes) => R.find(
-  (attr) => R.includes(attr.id, ids),
-  attributes
-);
-
-const parseAttributeFormaterIds = (ids = {}) => {
-  let prefscale = R.prop('prefscale', ids);
-  let decimals = R.prop('decimals', ids);
-  decimals = R.isNil(decimals) ? DEFAULT_DECIMALS_ATTR_IDS : decimals;
-  prefscale = R.isNil(prefscale) ? DEFAULT_PREFSCALE_ATTR_IDS : prefscale;
-  return ({
-    decimals: R.is(Array, decimals) ? decimals : [decimals],
-    prefscale: R.is(Array, prefscale) ? prefscale : [prefscale],
-  });
-}
-
-export const getObservationsFormaterAttributes = (attributes = [], ids = {}) => {
-  const { decimals, prefscale } = parseAttributeFormaterIds(ids);
-  return ({
-    decimals: getFormaterAttribute(decimals, attributes),
-    prefscale: getFormaterAttribute(prefscale, attributes)
-  });
-};
-
-const getObservationFormaterValue = (observation, attribute) => {
-  const attributeIndex = R.prop('index', attribute);
-  const attributeValueIndex = R.nth(attributeIndex, observation);
-  return R.nth(attributeValueIndex, R.propOr([], 'values', attribute));
-}
-
-const getObservationFormaterValues = (formaterAttributes) => (observation) => ({
-  decimals: getObservationFormaterValue(observation, R.prop('decimals', formaterAttributes)),
-  prefscale: getObservationFormaterValue(observation, R.prop('prefscale', formaterAttributes)),
-});
-
-const makeObservationFormater = (formaterValues) => {
-  let prefscale = 0;
-  if (!R.isNil(R.prop('prefscale', formaterValues))) {
-    prefscale = Number(R.propOr('0', 'id', formaterValues.prefscale));
-  }
-  let decimals = null;
-  if (!R.isNil(R.prop('decimals', formaterValues))) {
-    let _decimals = Number(R.prop('id', formaterValues.decimals));
-    decimals = R.is(Number, _decimals) && !Number.isNaN(_decimals)
-      ? _decimals : null;
-  }
-  let format = '0,0';
-  if (R.isNil(decimals)) {
-    format = R.concat(format, '.[0000000]');
-  }
-  else if (decimals > 0) {
-    format = R.concat(format, `.[${'0'.repeat(decimals)}]`);
-  }
-  return value => numeral(Number(value))
-    .multiply(Math.pow(10, R.negate(prefscale)))
-    .format(format);
-};
-
-export const getObservationFormater = (observation, formaterAttributes) => {
-  return R.pipe(
-    R.tail,
-    getObservationFormaterValues(formaterAttributes),
-    makeObservationFormater
-  )(observation);
-}
-
-export const getFormatedObservation = (observation, formaterAttributes) => {
-  const formater = getObservationFormater(observation, formaterAttributes);
-  return formater(R.head(observation));
-};

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

@@ -1,95 +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 _decimals = !decimals ? 2 : decimals;
-
-  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));
-      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);
-
-      const res = numeral(displayNum).format(decimalFormat);
-      return res;
-    },
-    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/focus.js

@@ -1,117 +0,0 @@
-import * as R from 'ramda';
-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 [];
-  }
-  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 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,22 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay, parseDisplay } from '../dimension-utils';
-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 getSourceLabel = (props, state) => R.when(
-  isCustomInvalid({ type: props.type }),
-  R.always(getDataflowName(props))
-)(state.sourceLabel);
-
-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/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(' · ')
-);