@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/src/rules/src/header/getHeaderUnits.js

@@ -1,17 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay, parseDisplay } from '../';
-
-export const getHeaderUnits = ({ units, display }) => {
-  const _display = parseDisplay(display);
-  return R.converge(
-    (header, label) => R.isEmpty(label) ? null : { header, label },
-    [
-      (units) => `${dimensionValueDisplay(_display)(units)}:`,
-      R.pipe(
-        R.propOr([], 'values'),
-        R.map(R.pipe(R.propOr({}, 'value'), dimensionValueDisplay(_display))),
-        R.join(', ')
-      )
-    ]
-  )(units);
-};

package/src/rules/src/header/getSubtitleFlags.js

@@ -1,43 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay, getFlags, parseDisplay } from '../';
-import { DEFAULT_REJECTED_SUBTITLE_IDS } from '../constants';
-
-export const getSubtitleFlags = ({ customAttributes, dimensions, display, units }) =>  {
-  const _display = parseDisplay(display);
-  const formatter = dimensionValueDisplay(_display);
-  const _getFlags =  getFlags(customAttributes, formatter, {});
-  const unitsValuesIds = R.pipe(R.propOr([], 'values'), R.pluck('id'))(units);
-
-  return R.pipe(
-    R.propOr([], 'one'),
-    R.values,
-    R.sortBy(R.prop('__index')),
-    R.reduce(
-      (acc, dim) => {
-        if (!R.propOr(true, 'display', dim)) {
-          return acc;
-        }
-        if (R.includes(dim.id, unitsValuesIds)) {
-          return acc;
-        }
-        const value = R.path(['values', 0], dim);
-
-        if (R.includes(value.id, DEFAULT_REJECTED_SUBTITLE_IDS) || !R.propOr(true, 'display', value)) {
-          return acc;
-        }
-
-        const flags = _getFlags({ attributes: R.propOr({}, 'attributes', value), notes: R.propOr([], 'notes', value) });
-        if (R.isEmpty(flags)) {
-          return acc;
-        }
-
-        return R.append({
-          header: `${formatter(dim)}:`,
-          label: formatter(value),
-          sub: flags
-        }, acc);
-      },
-      []
-    )
-  )(dimensions);
-};

package/src/rules/src/header/getTitleFlags.js

@@ -1,8 +0,0 @@
-import * as R from 'ramda';
-import { parseDisplay, dimensionValueDisplay, getFlags } from '../';
-
-export const getTitleFlags = ({ customAttributes, dataflowAttributes, display }) => {
-  const _display = parseDisplay(display);
-  const formatter = dimensionValueDisplay(_display);
-  return getFlags(customAttributes, formatter, {})({ attributes: dataflowAttributes });
-};

package/src/rules/src/header/index.js

@@ -1,4 +0,0 @@
-export { getDefaultSubtitle } from './getDefaultSubtitle';
-export { getSubtitleFlags } from './getSubtitleFlags';
-export { getHeaderUnits } from './getHeaderUnits';
-export { getTitleFlags } from './getTitleFlags';

package/src/rules/src/index.js

@@ -1,398 +0,0 @@
-import {
-  get, partition, reject, isEmpty, map, compact, size, keyBy, pick, omit, isNil, flatten, reduce,
-  filter, find, includes, isArray, findIndex, isEqual
-} from 'lodash';
-import * as R from 'ramda';
-import memoizee from 'memoizee';
-import __sampleSeries from './factories/sample-series';
-import __sampleFocus from './factories/sample-focus';
-import __scatterSeries from './factories/scatter-series';
-import __scatterFocus from './factories/scatter-focus';
-import __scatterDimension from './factories/scatter-dimension';
-import __symbolSeries from './factories/symbol-series';
-import __symbolDimension from './factories/symbol-dimension';
-import __timelineSeries from './factories/timeline-series';
-import __timelineFocus from './factories/timeline-focus';
-import __stackedSeries from './factories/stacked-series';
-import __stackedDimension from './factories/stacked-dimension';
-import __choroSeries from './factories/choro-series';
-import {
-  DEFAULT_UPR_IDS, DEFAULT_REJECTED_UPR_VALUES_IDS, DEFAULT_REJECTED_SUBTITLE_IDS,
-  FREQ_A, FREQ_Q, FREQ_M
-} from './constants';
-import { dimensionValueDisplay } from './dimension-utils';
-import { getObservationsFormaterAttributes } from './observation-formater';
-
-export const freqA = FREQ_A;
-export const freqQ = FREQ_Q;
-export const freqM = FREQ_M;
-
-// --------------------------------------------------------------------------------extractSdmxErrors
-const _extractSdmxErrors = (data) => R.compose(
-  (errors) => map(errors, (error) => ({ label: error.code, description: error.message })),
-  (data) => get(data, 'errors', [])
-);
-export const extractSdmxErrors = memoizee(_extractSdmxErrors);
-
-export const extractDataName = (data) => R.pathOr(null, ['structure', 'name'], data);
-
-// -----------------------------------------------------------------------------extractSdmxArtefacts
-const _extractSdmxArtefacts = (data) => {
-  const parseStructure = (data) => get(data, 'structure', {});
-  const parseItem = (item) => parseComponents(get(item, 'observation', []));
-  const parseDimensions = (structure) => parseItem(get(structure, 'dimensions', {}));
-  const parseAttributes = (structure) => parseItem(get(structure, 'attributes', {}));
-  const parseComponents = (components) => map(components, parseComponent);
-  const parseComponent = (component, index) => {
-    let parsed = { ...pick(component, 'id', 'name', 'values', 'role', 'isHidden'), index };
-    if (isEmpty(parsed))
-      return parsed;
-    if (isNil(parsed.role))
-      parsed.role = parsed.id;
-    parsed.values = R.sortBy(R.prop('__index'))(parsed.values);
-    return parsed;
-  };
-  const parseDatasetItem = (item) => parseComponents(get(item, 'dataSet', []));
-  const parseDatasetAttributes = (structure) => parseDatasetItem(get(structure, 'attributes', {}));
-
-  return {
-    attributes: parseAttributes(parseStructure(data)),
-    datasetAttributes: parseDatasetAttributes(parseStructure(data)),
-    dimensions: parseDimensions(parseStructure(data)),
-    id: get(data, 'header.id', null),
-    name: extractDataName(data),
-    observations: R.pipe(
-      R.pathOr({}, ['dataSets', 0, 'observations']),
-      R.mapObjIndexed(obs => R.over(R.lensIndex(0), val => R.isNil(val) ? null : Number(val))(obs)),
-      R.reject(R.pipe(R.head, R.anyPass([R.isNil, isNaN]))),
-    )(data),
-    source: get(data, 'header.links[0].href', null),
-  };
-};
-export const extractSdmxArtefacts = memoizee(_extractSdmxArtefacts);
-
-const _getRelevantsDatasetAttributes = (data) => {
-  const { datasetAttributes } = extractSdmxArtefacts(data);
-  return filter(datasetAttributes, attr => size(attr.values) === 1);
-};
-export const getRelevantsDatasetAttributes = memoizee(_getRelevantsDatasetAttributes);
-
-// -------------------------------------------------------------------------------getDimensionValues
-export const getDimensionValues = (dimension) => get(dimension, 'values', []);
-
-// ----------------------------------------------------------------------------------splitDimensions
-const _splitDimensions = (data) => {
-  const { dimensions } = extractSdmxArtefacts(data);
-  const [value, values] = partition(
-    reject(dimensions, R.compose(isEmpty, getDimensionValues)),
-    R.compose((values) => size(values) === 1, getDimensionValues)
-  );
-  return { value, values };
-}
-export const splitDimensions = memoizee(_splitDimensions);
-
-// ------------------------------------------------------------------dimensionsWithValuesIndexedById
-const _dimensionsWithValuesIndexedById = (data) => R.compose(
-  (dimensionsWithValues) => keyBy(dimensionsWithValues, 'id'),
-  (split) => split.values,
-  splitDimensions
-)(data);
-export const dimensionsWithValuesIndexedById = memoizee(_dimensionsWithValuesIndexedById);
-
-// -------------------------------------------------------------------------------------parseDisplay
-const _parseDisplay = (display) =>
-  (isNil(display) || !(includes(['both', 'code'], display)))
-    ? 'label' : display;
-export const parseDisplay = memoizee(_parseDisplay);
-
-// -------------------------------------------------------------------------------------sampleSeries
-const _sampleSeries = (data, type, display, formaterIds) => __sampleSeries(
-  type,
-  extractSdmxArtefacts(data),
-  dimensionsWithValuesIndexedById(data),
-  parseDisplay(display),
-  getObservationsFormaterAttributes(data, formaterIds)
-);
-export const sampleSeries = memoizee(_sampleSeries);
-
-// ---------------------------------------------------------------------------------scatterDimension
-const _scatterDimension = (data, ids) => {
-  const { values } = splitDimensions(data);
-  return __scatterDimension(values, ids);
-};
-export const scatterDimension = memoizee(_scatterDimension);
-
-// ----------------------------------------------------------------------------------symbolDimension
-const _symbolDimension = (data, ids) => {
-  const { values } = splitDimensions(data);
-  return __symbolDimension(values, ids);
-};
-export const symbolDimension = memoizee(_symbolDimension);
-
-const _stackedDimension = (data, singularity) => {
-  return __stackedDimension(splitDimensions(data), singularity);
-}
-export const stackedDimension = memoizee(_stackedDimension);
-
-// ------------------------------------------------------------------------------------scatterSeries
-const _scatterSeries = (data, ids, display, formaterIds) => __scatterSeries(
-  extractSdmxArtefacts(data),
-  dimensionsWithValuesIndexedById(data),
-  scatterDimension(data, ids),
-  parseDisplay(display),
-  getObservationsFormaterAttributes(data, formaterIds)
-);
-export const scatterSeries = memoizee(_scatterSeries);
-
-// -------------------------------------------------------------------------------------symbolSeries
-const _symbolSeries = (data, type, ids, display, formaterIds) => __symbolSeries(
-  extractSdmxArtefacts(data),
-  type,
-  dimensionsWithValuesIndexedById(data),
-  symbolDimension(data, ids),
-  parseDisplay(display),
-  getObservationsFormaterAttributes(data, formaterIds)
-);
-export const symbolSeries = memoizee(_symbolSeries);
-
-// -----------------------------------------------------------------------------------timelineSeries
-const _timelineSeries = (data, display, formaterIds) => __timelineSeries(
-  extractSdmxArtefacts(data),
-  dimensionsWithValuesIndexedById(data),
-  parseDisplay(display),
-  getObservationsFormaterAttributes(data, formaterIds)
-);
-export const timelineSeries = memoizee(_timelineSeries);
-
-const _stackedSeries = (data, singularity, display, formaterIds, [stackKey, categoryKey]) => __stackedSeries(
-  extractSdmxArtefacts(data),
-  dimensionsWithValuesIndexedById(data),
-  stackedDimension(data, singularity),
-  parseDisplay(display),
-  getObservationsFormaterAttributes(data, formaterIds),
-  [stackKey, categoryKey]
-);
-export const stackedSeries = memoizee(_stackedSeries);
-
-// --------------------------------------------------------------------------------------choroSeries
-const _choroSeries = (data, map, display) => __choroSeries(
-  extractSdmxArtefacts(data),
-  dimensionsWithValuesIndexedById(data),
-  map,
-  parseDisplay(display)
-);
-export const choroSeries = memoizee(_choroSeries);
-
-// -------------------------------------------------------------------------------------------series
-const _series = (data, type, focus, singularity, map, display, formaterIds) => {
-  switch(type) {
-    case 'RowChart': case 'BarChart':
-      return __sampleFocus(sampleSeries(data, type, display, formaterIds), focus);
-    case 'ScatterChart':
-      return __scatterFocus(scatterSeries(data, singularity, display, formaterIds), focus);
-    case 'HorizontalSymbolChart': case 'VerticalSymbolChart':
-      return __sampleFocus(symbolSeries(data, type, singularity, display, formaterIds), focus);
-    case 'TimelineChart':
-      return __timelineFocus(timelineSeries(data, display, formaterIds), focus);
-    case 'StackedBarChart':
-      return __sampleFocus(stackedSeries(data, singularity, display, formaterIds, ['y', 'x']), focus);
-    case 'StackedRowChart':
-      return __sampleFocus(stackedSeries(data, singularity, display, formaterIds, ['x', 'y']), focus);
-    case 'ChoroplethChart':
-      return choroSeries(data, map, display);
-  }
-};
-export const series = memoizee(_series);
-
-// -------------------------------------------------------------------------------------------source
-const _source = (data, config, meta) => {
-  const hasSource = get(meta, 'hasSource', true);
-  if (!hasSource)
-    return null;
-  const source = get(config, 'source', null);
-  if (source && !(isEmpty(source)))
-    return source;
-  const artefacts = extractSdmxArtefacts(data);
-  const uri = get(artefacts, 'source');
-  if (!uri)
-    return get(config, 'defaultSource', null);
-  const match = uri.match(/(^http.*)\/SDMX-JSON\/data\/([^\/]+)\//);
-  if (size(match) !== 3)
-    return null;
-  const [m, domain, dataset] = match;
-  return `${domain}/Index.aspx?DataSetCode=${dataset}`; //tmp
-};
-export const source = memoizee(_source);
-
-// --------------------------------------------------------------------------------------------focus
-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.compose(
-        (datapoints) => map(datapoints, (dp) => ({ label: dp.category, value: dp.key })),
-        (series) => series[0].datapoints,
-        series
-      )(data, type, null, dimension, null, display);
-    case 'TimelineChart':
-      return R.compose(
-        (series) => map(series, (serie) => ({ label: serie.category, value: serie.key })),
-        series
-      )(data, type, null, dimension, null, display)
-    case 'ScatterChart':
-      const id = get(dimension, 'id');
-      if (isNil(id)) return [];
-      const dimensions = R.compose(
-        (dimensions) => omit(dimensions, id),
-        dimensionsWithValuesIndexedById
-      )(data);
-      return flatten(map(
-        dimensions,
-        (dimension) => {
-          return map(
-            get(dimension, 'values'),
-            (value) => ({
-              label: `${dimensionValueDisplay(display)(dimension)} - ${dimensionValueDisplay(display)(value)}`,
-              options: { dimensionId: dimension.id, dimensionValueId: value.id },
-              value: `${dimension.id}-${value.id}`
-            })
-          )
-        }
-      ));
-  }
-};
-export const focus = memoizee(_focus);
-
-const _parseFocus = (data, type, dimension, display, { baseline, highlight }) => {
-  const options = focus(data, type, dimension, display);
-
-  const parseSelection = selection => compact(map(selection, ({ value }) => find(options, option => isEqual(option.value, value))));
-  return ({ baseline: parseSelection(baseline), highlight: parseSelection(highlight) });
-};
-export const parseFocus = memoizee(_parseFocus);
-
-const _defaultSubtitle = (data, display, REJECTED_SUBTITLE_IDS = DEFAULT_REJECTED_SUBTITLE_IDS) => {
-  const { value } = splitDimensions(data);
-  const values = reduce(
-    R.reject(R.prop('isHidden'))(value),
-    (memo, d) => {
-      const dvId = get(d, 'values[0].id');
-      if (!includes(REJECTED_SUBTITLE_IDS, dvId)) {
-        memo.push(`${dimensionValueDisplay(display)(d)}: ${dimensionValueDisplay(display)(get(d, 'values[0]'))}`);
-      }
-      return memo;
-    },
-    []
-  );
-  return values;
-}
-export const defaultSubtitle = memoizee(_defaultSubtitle);
-
-const _uprAttributes = (attributes, UPR_IDS = DEFAULT_UPR_IDS) => (
-  reduce(
-    UPR_IDS,
-    (memo, ids, uprKey) => {
-      const attr = find(attributes, attribute => includes(ids, get(attribute, 'id')));
-      if (attr) {
-        memo[uprKey] = attr;
-      }
-      return memo;
-    },
-    {}
-  )
-);
-export const uprAttributes = memoizee(_uprAttributes);
-
-const _uprAttributesWithOneRelevantValue = (uprAttributes, UPR_IDS = DEFAULT_UPR_IDS, REJECTED_UPR_VALUES_IDS = DEFAULT_REJECTED_UPR_VALUES_IDS) => reduce(
-  uprAttributes,
-  (memo, attr, key) => {
-    if (size(get(attr, 'values', [])) === 1 && !(includes(REJECTED_UPR_VALUES_IDS[key], get(attr, 'values[0].id', ''))))
-      memo[key] = attr;
-    return memo;
-  },
-  {}
-);
-export const uprAttributesWithOneRelevantValue = memoizee(_uprAttributesWithOneRelevantValue);
-
-export const headerUprsLabel = display => uprAttributes => {
-  return map(
-    uprAttributes,
-    attr => dimensionValueDisplay(display)(get(attr, 'values[0]'))
-  ).join(', ');
-}
-
-export const getUprs = (data, display) => R.compose(
-  headerUprsLabel(parseDisplay(display)),
-  uprAttributesWithOneRelevantValue,
-  ({ attributes }) => uprAttributes(attributes),
-  extractSdmxArtefacts
-)(data);
-
-const _header = (data, _title, _subtitle, _display) => {
-  const display = parseDisplay(_display);
-  const title = (isNil(_title) || isEmpty(_title)) ? get(data, 'structure.name') : _title;
-  const subtitle = (isNil(_subtitle) || isEmpty(_subtitle)) ? defaultSubtitle(data, display) : _subtitle;
-  return ({
-    title,
-    subtitle: isArray(subtitle) ? subtitle : [subtitle],
-    uprs: R.compose(
-      headerUprsLabel(display),
-      uprAttributesWithOneRelevantValue,
-      ({ attributes }) => uprAttributes(attributes),
-      extractSdmxArtefacts
-    )(data)
-  });
-};
-export const header = memoizee(_header);
-
-const _sourceLabel = (data, label) => (
-  (isNil(label) || isEmpty(label)) ? extractSdmxArtefacts(data).name : label
-);
-export const sourceLabel = memoizee(_sourceLabel);
-
-const _getTopologyAreasCollections = (topology) => map(topology.objects, (entry, key) => key);
-export const getTopologyAreasCollections = memoizee(_getTopologyAreasCollections);
-
-const _isNonIdealState = (data, type, map) => {
-  const defaultSeries = series(data, type, null, null, map);
-  if (type === 'ChoroplethChart')
-  {
-    return findIndex(get(defaultSeries, 'objects.areas.geometries', []), geometry => get(geometry, 'properties.value', null)) === -1;
-  }
-  return isEmpty(get(defaultSeries, '[0].datapoints', []));
-}
-export const isNonIdealState = memoizee(_isNonIdealState);
-
-export { dimensionValueDisplay } from './dimension-utils';
-export { DEFAULT_UPR_IDS, DIMENSION_DISPLAY_PARTS, DEFAULT_MAJOR_ATTRIBUTES, V8_SDMX_JSON,
-  TYPES as chartTypes } from './constants';
-export {
-  initialState,
-  stateFromNewProps,
-  onChangeProperties,
-  toChartData,
-  toChartOptions,
-  toProperties,
-  getErrors,
-  toSingularity
-} from './properties';
-export { dataTransformer as v8Transformer } from './v8-transformer';
-export {
-  getCellValue,
-} from './table';
-export {
-  getFullName,
-} from './sdmx-data';
-export { getTimePeriodLabel } from './date';
-export { getHeaderProps, getFooterProps,  } from './properties/getHeaderProps';
-export { getInformationsStateFromNewProps } from './properties/getInformationsStateFromNewProps';
-export { getObservationsType } from './properties/getObservationsType';
-export { getAvailableChartTypes } from './properties/getAvailableChartTypes';
-export { isSharedLayoutCompatible } from './layout';
-
-export { getObservations } from './preparators/getObservations';
-
-export const getFlags = R.identity;
-export const prepareData = R.identity;

package/src/rules/src/layout.js

@@ -1,113 +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';
-
-const isTableLayoutCompatible = (data, layout, combinationsDefinitions = [], dataquery = '') => {
-  const indexedCombinations = R.indexBy(R.prop('id'), combinationsDefinitions);
-  const indexedManyValuesDimensions = R.pipe(
-    R.pathOr([], ['structure', 'dimensions', 'observation']),
-    dimensions => refineDimensions(dimensions, dataquery),
-    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,83 +0,0 @@
-import memoizee from 'memoizee';
-import numeral from 'numeral';
-import * as R from 'ramda';
-import { extractSdmxArtefacts } from './';
-
-export const DEFAULT_PREFSCALE_ATTR_IDS = ["PREF_SCALE"];
-
-export const DEFAULT_DECIMALS_ATTR_IDS = ["DECIMALS"];
-
-export const getFormaterAttribute = (ids, attributes) => R.find(
-  (attr) => R.includes(attr.id, ids),
-  attributes
-);
-
-export 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 = (data, ids) => R.pipe(
-  extractSdmxArtefacts,
-  ({ attributes }) => {
-    const { decimals, prefscale } = parseAttributeFormaterIds(ids);
-    return ({
-      decimals: getFormaterAttribute(decimals, attributes),
-      prefscale: getFormaterAttribute(prefscale, attributes)
-    });
-  }
-)(data);
-export const getObservationsFormaterAttributes = memoizee(_getObservationsFormaterAttributes);
-
-export const getObservationFormaterValue = (observation, attribute) => {
-  const attributeIndex = R.prop('index', attribute);
-  const attributeValueIndex = R.nth(attributeIndex, observation);
-  return R.nth(attributeValueIndex, R.propOr([], 'values', attribute));
-}
-
-export const getObservationFormaterValues = (formaterAttributes) => (observation) => ({
-  decimals: getObservationFormaterValue(observation, R.prop('decimals', formaterAttributes)),
-  prefscale: getObservationFormaterValue(observation, R.prop('prefscale', formaterAttributes)),
-});
-
-export 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));
-};