@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/src/rules/src/properties/scatter.js

@@ -1,158 +0,0 @@
-import * as R from 'ramda';
-import { isRefAreaDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-import { SCATTER } from '../constants';
-import {
-  artefactToOption,
-  getDimensionsWithValues,
-  getPropertyDimension,
-  toState,
-} from './utils';
-import { focusStateFromNewProps } from './focus';
-
-const getScatterDimension = getPropertyDimension('scatterDimension');
-
-const toScatterState = (dim, xVal, yVal) => ({
-  scatterDimension: toState(dim),
-  scatterX: toState(xVal),
-  scatterY: toState(yVal),
-});
-
-export const toScatterSingularity = (state) => ({
-  id: R.prop('scatterDimension', state),
-  xId: R.prop('scatterX', state),
-  yId: R.prop('scatterY', state),
-}); 
-
-export const isScatter = (type) => type === SCATTER;
-
-export const scatterValueOptions = ({ data, type, display }, state) => {
-  if (!isScatter(type)) {
-    return [];
-  }
-  const scatterDimension = getScatterDimension(data, state);
-  if (R.isNil(scatterDimension)) {
-    return [];
-  }
-  return R.map(
-    artefactToOption(display),
-    R.prop('values', scatterDimension)
-  );
-};
-
-export const onChangeScatterDim = (props, state) => (value) => {
-  const { data } = props;
-  const dimension = getScatterDimension(data, { scatterDimension: value });
-  if (R.isNil(dimension)) {
-    return ({});
-  }
-
-  const [xVal, yVal] = R.take(2, R.prop('values', dimension));
-
-  const newScatterState = toScatterState(dimension, xVal, yVal);
-
-  return ({
-    ...newScatterState,
-    ...focusStateFromNewProps(
-      props,
-      toScatterSingularity(newScatterState),
-      state
-    )
-  });
-};
-
-export const scatterStateValueToOption = (property, props, state) => {
-  const dimension = getScatterDimension(props.data, state);
-  if (R.isNil(dimension) || !isScatter(props.type)) {
-    return undefined;
-  }
-  const value = R.find(
-    R.propEq('id', R.prop(property, state)),
-    R.prop('values', dimension)
-  );
-  return artefactToOption(props.display)(value);
-};
-
-export const onChangeScatterVal = ({ data, type }, state, valKey, otherValKey) => (value) => {
-  const options = scatterValueOptions({ data, type }, state);
-  const [matching, otherOptions] = R.partition(R.propEq('value', value), options);
-  if (R.isEmpty(matching)) {
-    return ({});
-  }
-  const stateOtherValue = R.prop(otherValKey, state);
-  return ({
-    [valKey]: value,
-    [otherValKey]: stateOtherValue === value
-      ? R.prop('value', R.head(otherOptions))
-      : stateOtherValue 
-  }); 
-};
-
-//----------------------------------------------------------------------------------------------------
-
-export const scatterStateFromNewProps = (props, state) => {
-  const { data, type } = props;
-  const undefinedState = toScatterState(undefined, undefined, undefined);
-  if (!isScatter(type)) {
-    return undefinedState;
-  }
-  if (R.isNil(data)) {
-    return {};
-  }
-  const dimensions = getDimensionsWithValues(data);
-  if (R.isEmpty(dimensions)) {
-    return { ...undefinedState, highlight: [], baseline: [] };
-  }
-
-  let scatterDimension = getScatterDimension(props.data, state);
-  if (R.isNil(scatterDimension)) {
-    const refinedDimensions = R.reject(isRefAreaDimension, dimensions);
-    scatterDimension = R.head(R.isEmpty(refinedDimensions) ? dimensions : refinedDimensions);
-  }
-
-  const values = R.prop('values', scatterDimension);
-
-  const stateScatterX = R.prop('scatterX', state);
-  let stateScatterY = R.prop('scatterY', state);
-
-  if (stateScatterX === stateScatterY) {
-    stateScatterY = undefined;
-  }
-
-  let _scatterX = undefined;
-  let _scatterY = undefined;
-
-  R.forEach(
-    (value) => {
-      if (R.prop('id', value) === stateScatterX) {
-        _scatterX = value;
-      }
-      else if (R.prop('id', value) === stateScatterY) {
-        _scatterY = value;
-      }
-    },
-    values
-  );
-
-  //dirty as f
-  const scatterX = R.isNil(_scatterX)
-    ? R.head(R.reject(R.propEq('id', R.prop('id', _scatterY)), values))
-    : _scatterX;
-  const scatterY = R.isNil(_scatterY)
-    ? R.head(R.reject(R.propEq('id', R.prop('id', scatterX)), values))
-    : _scatterY;
-
-  const scatterState = toScatterState(
-    scatterDimension,
-    scatterX,
-    scatterY,
-  );
-
-  return ({
-    ...scatterState,
-    ...focusStateFromNewProps(
-      props,
-      toScatterSingularity(scatterState),
-      state
-    )
-  });
-};

package/src/rules/src/properties/stacked.js

@@ -1,98 +0,0 @@
-import * as R from 'ramda';
-import { PERCENT, STACKED_BAR, STACKED_ROW, VALUES } from '../constants';
-import {
-  getDimensionsWithValues,
-  getGroupedDimensions,
-  getPropertyDimension,
-  toState
-} from './utils';
-import { splitDimensions } from '../';
-import { focusStateFromNewProps } from './focus';
-
-const getStackedDimension = getPropertyDimension('stackedDimension');
-
-const stackedModes = { [PERCENT]: PERCENT, [VALUES]: VALUES };
-
-export const isStacked = (type) => type === STACKED_BAR || type === STACKED_ROW;
-
-const toStackedState = (dimension, mode) => ({
-  stackedDimension: toState(dimension),
-  stackedMode: mode,
-});
-
-export const toStackedSingularity = (state) => ({
-  id: R.prop('stackedDimension', state),
-  mode: R.prop('stackedMode', state),
-  limit: 5
-});
-
-export const onChangeStackedDimension = ({ data }, state) => (value) => {
-  const dimension = getStackedDimension(data, { stackedDimension: value });
-  if (R.isNil(dimension)) {
-    return ({});
-  }
-  return ({
-    stackedDimension: toState(dimension),
-    highlight: [],
-    baseline: [],
-  })
-};
-
-export const stackedModeOptions = [{ value: VALUES }, { value: PERCENT }];
-
-export const isStackedDimActive = ({ data, type }) => {
-  const { values } = splitDimensions(data);
-  if (R.length(values) < 2) {
-    return false;
-  }
-  return isStacked(type);
-};
-
-export const onChangeStackedMode = (value) => R.has(value, stackedModes)
-  ? ({ stackedMode: value })
-  : ({});
-
-export const stackedStateFromNewProps = (props, state) => {
-  const { data, type } = props;
-  if (!isStacked(type)) {
-    return toStackedState(undefined, undefined);
-  }
-  if (R.isNil(data)) {
-    return {};
-  }
-  const dimensions = getDimensionsWithValues(data);
-  if (R.isEmpty(dimensions)) {
-    return { ...toStackedState(undefined, undefined), baseline: [], highlight: [] };
-  }
-
-  let dimension = getStackedDimension(data, state);
-  if (R.isNil(dimension)) {
-    const { value, values } = splitDimensions(data);
-    if (R.length(values) === 1) {
-      dimension = R.head(value);
-    }
-    else {
-      const { area, time, other } = getGroupedDimensions(data);
-      if (!R.isNil(area) && !R.isEmpty(area)) {
-        dimension = R.head(area);
-      }
-      else if (!R.isNil(time) && !R.isEmpty(time)) {
-        dimension = R.head(time)
-      }
-      else {
-        dimension = R.head(other);
-      }
-    }
-  }
-  const _mode = R.prop('stackedMode', state);
-  const mode = R.has(_mode, stackedModes) ? _mode : VALUES;
-  const stackedState = toStackedState(dimension, mode);
-  return ({
-    ...stackedState,
-    ...focusStateFromNewProps(
-      props,
-      toStackedSingularity(stackedState), 
-      state
-    )
-  });
-}

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

@@ -1,79 +0,0 @@
-import * as R from 'ramda';
-import { extractSdmxArtefacts } from '../';
-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,110 +0,0 @@
-import {
-  equals,
-  find,
-  groupBy,
-  has,
-  head,
-  is,
-  isNil,
-  length,
-  map,
-  not,
-  omit,
-  pipe,
-  prop,
-  propEq,
-} from 'ramda';
-import { isRefAreaDimension, isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-import { extractSdmxArtefacts, parseDisplay, splitDimensions } from '../';
-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 isInt = 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(
-  splitDimensions,
-  prop('values'),
-)(data);
-
-export const toState = (artefact) => prop('id', artefact);
-
-export const getPropertyDimension = (property) => (data, state) => {
-  const statePropertyDimensionId = prop(property, state);
-  const { dimensions } = extractSdmxArtefacts(data);
-  return find(
-    propEq('id', statePropertyDimensionId),
-    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 optionsParser = selection => pipe(
-  selection => is(Array, selection) ? selection : [selection],
-  selection => map(optionParser, selection)
-)(selection);
-
-export const artefactToOption = (display) => (artefact) => isNil(artefact)
-  ? undefined
-  : {
-    label: dimensionValueDisplay(parseDisplay(display))(artefact),
-    value: prop('id', artefact)
-  };
-
-export const dimensionWithValuesToOptions = ({ data, display }) => pipe(
-  getDimensionsWithValues,
-  map(artefactToOption(display))
-)(data);
-
-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 = prop('values', splitDimensions(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,39 +0,0 @@
-import * as R from 'ramda';
-
-export const LAYOUT_ROW = 'LAYOUT_ROW';
-export const LAYOUT_COLUMN = 'LAYOUT_COLUMN';
-export const LAYOUT_ROW_SECTION = 'LAYOUT_ROW_SECTION';
-
-const ROWS = 'rows';
-const HEADER = 'header';
-const SECTIONS = 'sections';
-
-const ORDER = 'ORDER';
-const NOT_DISPLAYED = 'NOT_DISPLAYED';
-
-const getType = R.propOr({}, 'type');
-const getIds = (stringIds = '') => R.pipe(
-  R.append(R.split(',', stringIds)),
-  R.flatten
-);
-const getPivot = (key, stringIds) => R.over(R.lensProp(key), getIds(stringIds));
-
-export const setAnnotationsLayout = (stringIds, layout) => R.reduce((acc, annotation) => {
-  if (R.equals(getType(annotation), LAYOUT_ROW)) return getPivot(ROWS, stringIds)(acc);
-  if (R.equals(getType(annotation), LAYOUT_COLUMN)) return getPivot(HEADER, stringIds)(acc);
-  if (R.equals(getType(annotation), LAYOUT_ROW_SECTION)) return getPivot(SECTIONS, stringIds)(acc);
-  return acc;
-}, layout);
-
-export const getRelationnalAnnotations = annotationIndexes => annotations => R.map(annotationIndex =>
-  R.propOr({}, annotationIndex)(annotations)
-)(annotationIndexes);
-
-export const hiddenFormat = { isHidden: true }
-
-export const getIsHidden = annotations => R.pipe(
-  R.find(R.propEq('type', NOT_DISPLAYED)),
-  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';