@sis-cc/dotstatsuite-components 22.0.1 → 22.0.2

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

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

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

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

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

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

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

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