@sis-cc/dotstatsuite-components 23.2.0 → 24.0.0

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

@@ -1,78 +0,0 @@
-import * as R from 'ramda';
-import { H_SYMBOL, V_SYMBOL } from '../constants';
-import {
-  getDimensionsWithValues,
-  getGroupedDimensions,
-  getPropertyDimension,
-  toState
-} from './utils';
-import { focusStateFromNewProps } from './focus';
-
-const getSymbolDimension = getPropertyDimension('symbolDimension');
-
-export const isSymbol = (type) => (type === H_SYMBOL || type === V_SYMBOL);
-
-const toSymbolState = (dimension) => ({
-  symbolDimension: toState(dimension)
-});
-
-export const toSymbolSingularity = (data, state) => {
-  const symbolDimension = getSymbolDimension(data, state);
-  const res = ({
-    id: R.isNil(symbolDimension) ? undefined : R.prop('id', symbolDimension),
-    serie: R.pipe(
-      R.prop('values'),
-      values => R.isNil(values) ? [] : values,
-      R.take(5)
-    )(symbolDimension),
-  });
-  return res;
-};
-
-export const symbolStateFromNewProps = (props, state) => {
-  const { data, type } = props;
-  if (!isSymbol(type)) {
-    return toSymbolState(undefined);
-  }
-  if (R.isNil(data)) {
-    return {};
-  }
-  const dimensions = getDimensionsWithValues(data);
-  if (R.isEmpty(dimensions)) {
-    return { ...toSymbolState(undefined), baseline: [], highlight: [] };
-  }
-  let symbolDimension = getSymbolDimension(data, state);
-  if (R.isNil(symbolDimension)) {
-    const { area, other, time } = getGroupedDimensions(data);
-    if (!R.isNil(other) && !R.isEmpty(other)) {
-      symbolDimension = R.head(other);
-    }
-    else if (!R.isNil(time) && !R.isEmpty(time)) {
-      symbolDimension = R.head(time);
-    }
-    else {
-      symbolDimension = R.head(area);
-    }
-  }
-  const symbolState = toSymbolState(symbolDimension);
-  return ({
-    ...symbolState,
-    ...focusStateFromNewProps(
-      props,
-      toSymbolSingularity(data, symbolState),
-      state
-    )
-  });
-};
-
-export const onChangeSymbolDim = ({ data }) => (option) => {
-  const dimension = getSymbolDimension(data, { symbolDimension: option });
-  if (R.isNil(dimension)) {
-    return ({});
-  }
-  return ({
-    ...toSymbolState(dimension),
-    highlight: [],
-    baseline: [],
-  });
-};

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

@@ -1,100 +0,0 @@
-import {
-  equals,
-  find,
-  groupBy,
-  has,
-  is,
-  isEmpty,
-  isNil,
-  length,
-  map,
-  not,
-  omit,
-  pipe,
-  prop,
-  propEq,
-  propOr,
-  reject
-} from 'ramda';
-import { isRefAreaDimension, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-import { parseDisplay } from '../dimension-utils';
-import { CHORO, STACKED_BAR, STACKED_ROW, TYPES } from '../constants';
-import { dimensionValueDisplay } from '../dimension-utils';
-
-export const isNumber = (input) => {
-  const value = Number(input);
-  return not(isNil(value) || isNaN(value));
-};
-
-export const isPositiveNumber = (input) => {
-  return (isNumber(input) && Number(input) >= 0);
-};
-
-export const isNaturalInt = 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(
-  propOr([], 'dimensions'),
-  reject(d => d.header || isEmpty(d.values || []))
-)(data);
-
-export const toState = (artefact) => prop('id', artefact);
-
-export const getPropertyDimension = (property) => (data, state) => {
-  const dimensionId = prop(property, state);
-  const { dimensions = [] } = data || {};
-
-  return find(propEq(dimensionId, 'id'), dimensions);
-};
-
-export const getGroupedDimensions = pipe(
-  getDimensionsWithValues,
-  groupBy(
-    dimension => {
-      if (isRefAreaDimension(dimension)) {
-        return 'area';
-      }
-      if (isTimePeriodDimension(dimension)) {
-        return 'time';
-      }
-      return 'other';
-    }
-  )
-);
-
-export const optionParser = option => pipe(
-  option => is(Array, option) ? head(option) : option,
-  option => is(Object, option) ? prop('value', option) : option,
-  option => is(String, option) ? option : undefined
-)(option);
-
-
-export const artefactToOption = (display) => (artefact) => isNil(artefact)
-  ? undefined
-  : {
-    label: dimensionValueDisplay(parseDisplay(display))(artefact),
-    value: prop('id', artefact)
-  };
-
-export const chartDimensionToOption = (property) => ({ data, display }, state) => pipe(
-  getPropertyDimension(property),
-  artefactToOption(display)
-)(data, state);
-
-export const chartDimensionOptions = ({ data, type, display }, typeValidator) => {
-  if (!typeValidator(type)) {
-    return [];
-  }
-  const dimensions = getDimensionsWithValues(data);
-  if ((equals(type, STACKED_BAR) || equals(type, STACKED_ROW)) && length(dimensions) === 1) {
-    return [];
-  }
-  return map(
-    artefactToOption(display),
-    dimensions
-  );
-};

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

@@ -1,10 +0,0 @@
-import * as R from 'ramda';
-
-const NOT_DISPLAYED = 'NOT_DISPLAYED';
-
-export const getIsHidden = annotations => R.pipe(
-  R.find(R.propEq(NOT_DISPLAYED, 'type')),
-  R.complement(R.isNil)
-)(annotations);
-
-export const getFullName = R.identity;

package/src/rules/src/table/factories/getCellValue.js

@@ -1,50 +0,0 @@
-import * as R from 'ramda';
-import numeral from 'numeral';
-
-const isValidNumber = R.both(R.is(Number), R.complement(R.equals(NaN)));
-
-export const getCellValue = (observation) => {
-  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 scale = Number(observation.prefscale);
-  const formatScale = R.ifElse(
-    R.always(isValidNumber(scale)),
-    value => numeral(value).multiply(Math.pow(10, -1 * Number(scale))).value(),
-    R.identity
-  );
-  const formatSeparator = value => numeral(value).format(`0,0.[0000000]`);
-  const decimals = Number(observation.decimals);
-  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
-  );
-  const res = R.ifElse(
-    isValidNumber,
-    R.pipe(
-      formatScale,
-      formatDecimals,
-    ),
-    R.always('..')
-  )(observation.value);
-  return res;
-};

package/src/rules/src/table/index.js

@@ -1 +0,0 @@
-export { getCellValue } from './factories/getCellValue';

package/src/rules2/src/applyHierarchicalCodesToDim.js

@@ -1,123 +0,0 @@
-import * as R from 'ramda';
-
-const addParentId = (id, ids) => {
-  const last = R.last(ids);
-  return R.append(R.isNil(last) ? id : `${last}.${id}`, ids); 
-}
-
-const _refineUnconfirmedPaths = (paths) => R.map(p => [R.head(p)], paths);
-
-const getHierId = v => R.isNil(v.parent) || R.isEmpty(v.parent)
-  ? v.id
-  : `${v.parent}.${v.id}`;
-
-export const applyHierarchicalCodesToDim = (hCodes, dim) => {
-  const confirmedHierarchisedChilds = new Set([]);
-  let unconfirmedPaths = {};
-
-  const indexedValues = R.reduce((acc, val) => {
-    if (!val.isSelected) {
-      return acc;
-    }
-    return R.assoc(val.id, val, acc);
-  }, {}, dim.values || []);
-
-  const parseHCodes = (parentsDef, parentsInDim) => R.reduce((acc, hC) => {
-    const { codeID, hierarchicalCodes = [] } = hC;
-    const hasInDim = R.has(codeID, indexedValues);
-    const isUnconfirmed = R.length(parentsInDim) !== R.length(parentsDef);
-    const children = parseHCodes(
-      R.append(codeID, parentsDef),
-      hasInDim ? addParentId(codeID, parentsInDim) : parentsInDim
-    )(hierarchicalCodes);
-    if (!hasInDim) {
-      return R.concat(acc, children);
-    }
-    const path = R.join('.', parentsDef);
-    let val = {
-      ...R.prop(codeID, indexedValues),
-      path,
-      parents: parentsInDim,
-      parent: R.last(parentsInDim),
-      children
-    };
-
-    if (isUnconfirmed) {
-      unconfirmedPaths = R.over(R.lensProp(val.id), paths => R.append(path, paths || []), unconfirmedPaths);
-      val = R.assoc('unconfirmed', true, val);
-      return R.append(val, acc);
-    }
-    confirmedHierarchisedChilds.add(codeID);
-    return R.append(val, acc);
-  }, []);
-
-  const parsed = parseHCodes([], [])(hCodes);
-
-  const _unconfirmedPaths = R.pipe(
-    R.reject(id => confirmedHierarchisedChilds.has(id)),
-    ids => R.pick(ids, unconfirmedPaths)
-  )(R.keys(unconfirmedPaths));
-
-  const refinedUnconfirmedPaths = _refineUnconfirmedPaths(_unconfirmedPaths);
-
-  const flattenDescendants = R.reduce((acc, val ) => {
-    const children = flattenDescendants(val.children || []);
-    return R.concat(acc, R.prepend(val, children));
-  }, []);
-
-  const isValid = val => !val.unconfirmed || val.path === R.head(refinedUnconfirmedPaths[val.id] || []);
-
-  const refineCodes = R.reduce((acc, hC) => {
-    const _flatDescendants = flattenDescendants(hC.children);
-    const flatDescendants = R.prepend(hC, _flatDescendants);
-
-    const valids = R.filter(isValid, flatDescendants);
-
-    if (R.isEmpty(valids)) {
-      return acc;
-    }
-    const refined = R.pipe(
-      R.reduce((_acc, v) => {
-        confirmedHierarchisedChilds.add(v.id);
-        const prev = R.last(_acc);
-        const parents = R.pipe(
-          p => R.isNil(p) ? [] : R.append(getHierId(p), prev.parents || []),
-          R.filter(id => R.includes(id, v.parents)),
-        )(prev);
-        const rV = {
-          ...R.omit(['unconfirmed', 'children', 'path'], v),
-          parents,
-          parent: R.isEmpty(parents) ? undefined : R.last(parents)
-        };
-        return R.append(rV, _acc);
-      }, [])
-    )(valids);
-    return R.concat(acc, refined);
-  }, []);
-
-  const refined = refineCodes(parsed);
-
-  const missingValues = R.pipe(
-    R.keys,
-    R.filter(id => !confirmedHierarchisedChilds.has(id)),
-    ids => R.props(ids, indexedValues),
-    R.map(v => ({ ...v, parents: [], parent: undefined })),
-    R.sortBy(R.propOr(-1, '__indexPosition')),
-  )(indexedValues);
-
-  let hierarchicalIndexes = {};
-  return R.pipe(
-    R.concat,
-    R.addIndex(R.map)((v, ind) => {
-      const parents = R.props(v.parents, hierarchicalIndexes);
-      const hierId = getHierId(v);
-      hierarchicalIndexes[hierId] = ind;
-      return {
-        ...R.dissoc('path', v),
-        parents,
-        __indexPosition: ind
-      };
-    }),
-    values => ({ ...dim, values })
-  )(missingValues, refined);
-};

package/src/rules2/src/combinedValuesDisplay.js

@@ -1,74 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay } from '../../rules/src/dimension-utils';
-import { REJECTED_VALUE_IDS } from './constants';
-
-const getRefinedMissinParentsLabels = R.pipe(
-  R.propOr([], 'missingParents'),
-  R.reduce((acc, par) => {
-    if (
-      !R.propOr(true, 'display', par) ||
-      R.includes(par.id, REJECTED_VALUE_IDS)
-    ) {
-      return acc;
-    }
-    return R.append(dimensionValueDisplay('label')(par), acc);
-  }, []),
-);
-
-export const singleValueDisplay = (display, value) => {
-  if (display === 'label') {
-    return R.converge(
-      (missingParents, label) =>
-        R.isEmpty(missingParents)
-          ? label
-          : R.join(' > ', R.append(label, missingParents)),
-      [getRefinedMissinParentsLabels, dimensionValueDisplay(display)],
-    )(value);
-  } else if (display === 'both') {
-    return `(${singleValueDisplay('code', value)}) ${singleValueDisplay(
-      'label',
-      value,
-    )}`;
-  }
-  return dimensionValueDisplay(display)(value);
-};
-
-const _combinedValuesDisplay = (_display) => (values) =>
-  R.pipe(
-    R.reduce((acc, val) => {
-      if (R.isNil(val)) return acc;
-      const isDisplayed = R.propOr(true, 'display', val);
-      const isRejected = R.includes(val.id, REJECTED_VALUE_IDS);
-      if ((!isDisplayed || isRejected) && _display === 'label') return acc;
-      return R.append(singleValueDisplay(_display, val), acc);
-    }, []),
-    (labels) => {
-      if (!R.isEmpty(labels) || _display !== 'label') {
-        return R.join(', ', labels);
-      }
-      const totalValue = R.find(R.propEq('_T', 'id'), values);
-      if (!R.isNil(totalValue)) {
-        return dimensionValueDisplay('label')(totalValue);
-      }
-      if (R.isEmpty(values)) {
-        return '';
-      }
-      const firstValue = R.head(values);
-      return dimensionValueDisplay('label')(firstValue);
-    },
-  )(values);
-
-export const combinedValuesDisplay = (display, values) => {
-  if (display === 'both') {
-    return R.converge(
-      (_ids, labels) => {
-        return dimensionValueDisplay('both')({
-          id: _ids,
-          name: labels,
-        });
-      },
-      [_combinedValuesDisplay('code'), _combinedValuesDisplay('label')],
-    )(values);
-  }
-  return _combinedValuesDisplay(display)(values);
-};

package/src/rules2/src/constants.js

@@ -1,6 +0,0 @@
-export const SDMX_3_0_JSON_DATA_FORMAT = 'application/vnd.sdmx.data+json;version=2.0';
-export const SDMX_3_0_CSV_DATA_FORMAT = 'application/vnd.sdmx.data+csv;version=2.0';
-export const EMPTY_ATTACHMENT_LEVEL_CHAR = '~';
-export const REPORTING_YEAR_START_DAY = 'REPORTING_YEAR_START_DAY';
-export const REPYEARSTART = 'REPYEARSTART';
-export const REJECTED_VALUE_IDS = ['_L', '_T', '_Z'];

package/src/rules2/src/duplicateObservations.js

@@ -1,35 +0,0 @@
-import * as R from 'ramda';
-
-export const duplicateObs = (dims, observations) => {
-  const obsValues = R.values(observations);
-  if (R.length(dims) === 0) {
-    return observations;
-  }
-  const duplicated = R.reduce(
-    (obs, dim) => {
-      const groupedObs = R.groupBy(o => R.prop(dim.id, o.indexedDimValIds), obs);
-      const enhancedObs = R.addIndex(R.map)(
-        (value, index) => {
-          const matchingObs = R.propOr([], value.id, groupedObs);
-
-          return R.map(
-            obs => R.over(
-              R.lensProp('orderedDimIndexes'),
-              _indexes => {
-                const indexes = R.isNil(_indexes) ? R.map(i => Number(i), obs.dimValuesIndexes) : _indexes;
-                return R.set(R.lensIndex(dim.__index), index)(indexes);
-              }
-            )(obs),
-            matchingObs
-          );
-        },
-        dim.values
-      );
-      return R.unnest(enhancedObs);
-    },
-    obsValues,
-    dims
-  );
-  const res =  R.indexBy(R.pipe(R.prop('orderedDimIndexes'), R.join(':')), duplicated);
-  return res;
-};

package/src/rules2/src/enhanceObservations.js

@@ -1,95 +0,0 @@
-import * as R from 'ramda';
-import { formatValue } from '../../rules/src/preparators/formatValue';
-import { REJECTED_VALUE_IDS } from './constants';
-
-/*
-  options = {
-    customAttributes: {
-      decimals: id,
-      prefscale: id,
-    },
-  }
-*/
-
-const parseAttributesValues = (obs, attributes, indexedDimensions) => {
-  const { attrValuesIndexes, dimValuesIndexes } = obs;
-  return R.addIndex(R.reduce)(
-    (acc, valueIndex, attrIndex) => {
-      const attribute = R.nth(attrIndex, attributes);
-      if (R.isNil(attribute) || !R.prop('series', attribute)) {
-        return acc;
-      }
-      const _value = R.nth(valueIndex, attribute.values || []);
-      let value = R.isNil(_value)
-        ? _value
-        : R.over(R.lensProp('display'), (display=true) => display && !R.includes(_value.id, REJECTED_VALUE_IDS))(_value);
-      if ((!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value))) {
-        value = null;
-      }
-      const relationship = R.propOr([], 'relationship', attribute);
-      let coordinates = {};
-      const serieKey = R.pipe(
-        dims => R.isEmpty(relationship) ? R.values(dims) : R.props(relationship, dims),
-        R.map(dim => {
-          const valueIndex = R.nth(dim.__index, dimValuesIndexes);
-          const valueId = R.path(['values', valueIndex, 'id'], dim);
-          coordinates = R.assoc(dim.id, valueId, coordinates);
-          return `${dim.id}=${valueId}`;
-        }),
-        R.ifElse(R.isEmpty, R.always(null), R.join(':'))
-      )(indexedDimensions);
-
-      return R.assoc(
-        attribute.id,
-        { ...R.pick(['id', 'name', 'relationship', 'display', 'combined'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) },
-        acc
-      );
-    },
-    {},
-    attrValuesIndexes
-  );
-};
-
-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
-);
-
-export const enhanceObservations = (dimensions = [], observations = {}, attributes = [], options = {}) => {
-  const formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
-  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
-
-  return R.map(
-    (observation) => {
-      const { dimValuesIndexes } = observation;
-
-      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: parseAttributesValues(observation, attributes, indexedDimensions),
-        formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
-        indexedDimValIds,
-      });
-    },
-    observations
-  );
-};

package/src/rules2/src/getAttributes.js

@@ -1,34 +0,0 @@
-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/getAttributesSeries.js

@@ -1,36 +0,0 @@
-import * as R from 'ramda';
-
-export const getAttributesSeries = observations => R.pipe(
-  R.values,
-  R.reduce(
-    (acc, { attributes }) => {
-      let res = acc.res;
-      let rejected = acc.rejected;
-      R.forEachObjIndexed(
-        (attribute) => {
-          if (!R.isNil(attribute.serieKey) && !attribute.isObs) {
-            if (R.isNil(attribute.value)) {
-              res = R.dissocPath([attribute.serieKey, attribute.id], res);
-              rejected = R.assocPath([attribute.serieKey, attribute.id], true, rejected);
-            }
-            if (R.path([attribute.serieKey, attribute.id], rejected)) {
-              return ;
-            }
-            const valueInRes = R.path([attribute.serieKey, attribute.id, 'value', 'id'], res);
-            if (!R.isNil(valueInRes) && valueInRes !== R.path(['value', 'id'], attribute)) {
-              res = R.dissocPath([attribute.serieKey, attribute.id], res);
-              rejected = R.assocPath([attribute.serieKey, attribute.id], true, rejected);
-            }
-            else {
-              res = R.assocPath([attribute.serieKey, attribute.id], attribute, res);
-            }
-          }
-        },
-        attributes
-      );
-      return ({ res, rejected });
-    },
-    { res: {}, rejected: {}, }
-  ),
-  R.prop('res')
-)(observations);