@sis-cc/dotstatsuite-components 23.2.0 → 24.0.0

package/src/rules/src/properties/index.js

@@ -1,333 +0,0 @@
-import * as R from 'ramda';
-import {
-  H_SYMBOL,
-  SCATTER,
-  STACKED_BAR,
-  STACKED_ROW,
-  TIMELINE,
-  V_SYMBOL,
-} from '../constants';
-import {
-  onChangeFocusSelection,
-  focusOptions,
-  sampleFocusStateFromNewProps,
-} from './focus';
-import {
-  isScatter,
-  onChangeScatterDim,
-  onChangeScatterVal,
-  scatterStateFromNewProps,
-  scatterStateValueToOption,
-  scatterValueOptions,
-  toScatterSingularity,
-} from './scatter';
-import {
-  isSymbol,
-  onChangeSymbolDim,
-  symbolStateFromNewProps,
-  toSymbolSingularity,
-} from './symbol';
-import {
-  isStacked,
-  isStackedDimActive,
-  onChangeStackedDimension,
-  onChangeStackedMode,
-  stackedModeOptions,
-  stackedStateFromNewProps,
-  toStackedSingularity
-} from './stacked';
-import {
-  linearStateFromNewProps,
-  initialState as linearInitialState,
-  toProperties as toLinearProperties
-} from './linear';
-import {
-  chartDimensionOptions,
-  chartDimensionToOption,
-  hasFocus,
-  isChart,
-  isNaturalInt,
-  optionParser,
-} from './utils';
-import { getSourceLabel } from './getHeaderProps';
-import { stringifySubtitle } from './getStringifiedSubtitle';
-
-/*
- - width/height -> initial undefined, if undefined or blank, replaced by options.base
-*/
-
-export const toSingularity = ({ data, type }, state) => {
-  switch(type) {
-    case SCATTER:
-      return toScatterSingularity(state);
-    case H_SYMBOL: case V_SYMBOL:
-      return toSymbolSingularity(data, state);
-    case STACKED_BAR: case STACKED_ROW:
-      return toStackedSingularity(state);
-    default:
-      return null;
-  }
-};
-
-const toFloat = (value) => {
-  const float = parseFloat(value);
-  return isNaN(float) ? undefined : float;
-}
-
-const toOption = (stateValue, optionValue) => R.isNil(stateValue)
-  ? optionValue : toFloat(stateValue);
-
-const getFreqStepOption = (props, state) => {
-  if (props.type !== TIMELINE) {
-    return null;
-  }
-  const inputState = toFloat(state.freqStep);
-  return R.isNil(inputState) ? 1 : inputState;
-};
-
-export const toChartOptions = (props, state) => {
-  const options = R.propOr({}, 'options', props);
-  const base = R.propOr({}, 'base', options);
-  const axis = R.propOr({}, 'axis', options);
-  const axeX = R.propOr({}, 'x', axis);
-  const axeY = R.propOr({}, 'y', axis);
-  const linearX = R.propOr({}, 'linear', axeX);
-  const linearY = R.propOr({}, 'linear', axeY);
-  const tickX = R.propOr({}, 'tick', axeX);
-  const pivotX = R.propOr({}, 'pivot', linearX);
-  const pivotY = R.propOr({}, 'pivot', linearY);
-  const map = R.propOr({}, 'map', props);
-  return ({
-    ...options,
-    axis: {
-      ...axis,
-      x: {
-        ...axeX,
-        tick: {
-          ...tickX,
-          step: getFreqStepOption(props, state)
-        },
-        linear: {
-          ...linearX,
-          max: toOption(state.maxX, linearX.max),
-          min: toOption(state.minX, linearX.min),
-          pivot: {
-            value: toOption(state.pivotX, pivotX.value)
-          },
-          step: toOption(
-            props.type === TIMELINE ? 1 :  state.stepX,
-            linearX.step
-          ),
-        }
-      },
-      y: {
-        ...axeY,
-        linear: {
-          ...linearY,
-          max: toOption(state.maxY, linearY.max),
-          min: toOption(state.minY, linearY.min),
-          pivot: {
-            value: toOption(state.pivotY, pivotY.value)
-          },
-          step: toOption(state.stepY, linearY.step),
-        }
-      }
-    },
-    map: R.pick(['projection', 'scale'], map),
-    base: {
-      ...base,
-      height: toOption(state.fixedHeight, base.height),
-      width: toOption(state.fixedWidth, base.width),
-    },
-  });
-};
-
-export const stateFromNewProps = (props, state) => {
-  const focusState = sampleFocusStateFromNewProps(props, state);
-  const scatterState = scatterStateFromNewProps(props, state);
-  const symbolState = symbolStateFromNewProps(props, state);
-  const stackedState = stackedStateFromNewProps(props, state);
-  const linearState = linearStateFromNewProps(props.type);
-  return ({
-  ...focusState,
-  ...scatterState,
-  ...symbolState,
-  ...stackedState,
-  ...linearState,
-  fixedWidth: R.prop('fixedWidth', state),
-  fixedHeight: R.prop('fixedHeight', state),
-  responsiveWidth: R.prop('responsiveWidth', state),
-  responsiveHeight: R.prop('responsiveHeight', state),
-  freqStep: props.type === TIMELINE
-    ? R.prop('freqStep', state) || '1' : undefined,
-  type: R.prop('type', props),
-  });
-};
-
-export const toProperties = (props, state, onChange) => ({
-  ...toLinearProperties(props, state, onChange),
-  highlight: {
-    id: 'highlight',
-    isActive: hasFocus(props.type),
-    onChange: R.pipe(
-      onChangeFocusSelection,
-      selection => {
-        onChange({ highlight: selection });
-      }
-    ),
-    options: focusOptions(
-      props,
-      state,
-      'baseline',
-      toSingularity(props, state)
-    ),
-    value: R.prop('highlight', state),
-  },
-  baseline: {
-    id: 'baseline',
-    isActive: hasFocus(props.type),
-    onChange: R.pipe(
-      onChangeFocusSelection,
-      selection => onChange({ baseline: selection })
-    ),
-    options: focusOptions(
-      props,
-      state,
-      'highlight',
-      toSingularity(props, state)
-    ),
-    value: R.prop('baseline', state),
-  },
-  width: {
-    id: 'width',
-    isActive: isChart(props.type),
-    onChange: (value) => onChange({
-      fixedWidth: isNaturalInt(value) ? value : undefined
-    }),
-    placeholder: R.when(R.complement(R.isNil), (value) => String(Math.floor(Number(value))))(state.responsiveWidth),
-    value: R.prop('fixedWidth', state),
-  },
-  height: {
-    id: 'height',
-    isActive: isChart(props.type),
-    onChange: (value) => onChange({
-      fixedHeight: isNaturalInt(value) ? value : undefined
-    }),
-    placeholder: R.when(R.complement(R.isNil), (value) => String(Math.floor(Number(value))))(state.responsiveHeight),
-  },
-  freqStep: {
-    id: 'freqStep',
-    isActive: props.type === TIMELINE,
-    onChange: (value) => onChange({
-      freqStep: isNaturalInt(value) ? String(value) : undefined
-    }),
-    value: R.prop('freqStep', state),
-  },
-  title: {
-    id: 'title',
-    isActive: isChart(props.type),
-    isDefault: R.isNil(state.title),
-    onChange: (value) => onChange({ title: value }),
-    value: R.isNil(state.title) || R.isEmpty(state.title)
-      ? R.pathOr('', ['title', 'label'], props) : state.title,
-    onReset: R.isNil(state.title)
-      ? null : () => onChange({ title: null })
-  },
-  subtitle: {
-    id: 'subtitle',
-    isActive: isChart(props.type),
-    isDefault: R.isNil(state.subtitle),
-    onChange: (value) => onChange({ subtitle: value }),
-    value: R.isNil(state.subtitle) || R.isEmpty(state.subtitle)
-      ? stringifySubtitle(props.subtitle || []) : state.subtitle,
-    onReset: R.isNil(state.subtitle)
-      ? null : () => onChange({ subtitle: null })
-  },
-  source: {
-    id: 'source',
-    isActive: isChart(props.type),
-    isDefault: R.isNil(state.sourceLabel),
-    onChange: (value) => onChange({ sourceLabel: value }),
-    value: getSourceLabel(props, state),
-    onReset: R.isNil(state.sourceLabel)
-      ? null : () => onChange({ sourceLabel: null })
-  },
-  scatterDimension: {
-    id: 'scatterDimension',
-    isActive: isScatter(props.type),
-    onChange: R.pipe(
-      optionParser,
-      onChangeScatterDim(props, state),
-      onChange
-    ),
-    options: chartDimensionOptions(props, isScatter),
-    value: chartDimensionToOption('scatterDimension')(props, state),
-  },
-  scatterX: {
-    id: 'scatterX',
-    isActive: isScatter(props.type),
-    onChange: R.pipe(
-      optionParser,
-      onChangeScatterVal(props, state, 'scatterX', 'scatterY'),
-      onChange
-    ),
-    options: scatterValueOptions(props, state),
-    value: scatterStateValueToOption('scatterX', props, state),
-  },
-  scatterY: {
-    id: 'scatterY',
-    isActive: isScatter(props.type),
-    onChange: R.pipe(
-      optionParser,
-      onChangeScatterVal(props, state, 'scatterY', 'scatterX'),
-      onChange
-    ),
-    options: scatterValueOptions(props, state),
-    value: scatterStateValueToOption('scatterY', props, state),
-  },
-  symbolDimension: {
-    id: 'symbolDimension',
-    isActive: isSymbol(props.type),
-    options: chartDimensionOptions(props, isSymbol),
-    onChange: R.pipe(
-      optionParser,
-      onChangeSymbolDim(props),
-      onChange
-    ),
-    value: chartDimensionToOption('symbolDimension')(props, state)
-  },
-  stackedDimension: {
-    id: 'stackedDimension',
-    isActive: isStackedDimActive(props),
-    options: chartDimensionOptions(props, isStacked),
-    onChange: R.pipe(
-      optionParser,
-      onChangeStackedDimension(props, state),
-      onChange,
-    ),
-    value: chartDimensionToOption('stackedDimension')(props, state)
-  },
-  stackedMode: {
-    id: 'stackedMode',
-    isActive: isStacked(props.type),
-    options: stackedModeOptions,
-    onChange: R.pipe(
-      optionParser,
-      onChangeStackedMode,
-      onChange
-    ),
-    value: R.prop('stackedMode', state)
-  },
-  logo: {
-    id: 'logo',
-    isActive: isChart(props.type),
-    checked: !state.withLogo,
-    onChange: () => onChange({ withLogo: !state.withLogo })
-  },
-  copyright: {
-    id: 'copyright',
-    isActive: isChart(props.type),
-    checked: !state.withCopyright,
-    onChange: () => onChange({ withCopyright: !state.withCopyright })
-  }
-});

package/src/rules/src/properties/linear.js

@@ -1,129 +0,0 @@
-import * as R from 'ramda';
-import {
-  BAR,
-  H_SYMBOL,
-  ROW,
-  SCATTER,
-  STACKED_BAR,
-  STACKED_ROW,
-  TIMELINE,
-  V_SYMBOL,
-} from '../constants';
-import { isNumber, isPositiveNumber } from './utils';
-import { isStacked } from './stacked';
-
-const hasXLinear = (type) => R.includes(type, [H_SYMBOL, ROW, SCATTER, STACKED_ROW]);
-
-const hasYLinear = (type) => R.includes(type, [BAR, SCATTER, STACKED_BAR, TIMELINE, V_SYMBOL]);
-
-const hasXPivot = (type) => R.equals(ROW, type);
-const hasYPivot = (type) => R.equals(BAR, type);
-
-const xInitialState = {
-  computedMaxX: undefined,
-  computedMinX: undefined,
-  computedStepX: undefined,
-  computedPivotX: undefined,
-  maxX: undefined,
-  minX: undefined,
-  pivotX: undefined,
-  stepX: undefined,
-};
-
-const yInitialState = {
-  computedMaxY: undefined,
-  computedMinY: undefined,
-  computedStepY: undefined,
-  computedPivotY: undefined,
-  maxY: undefined,
-  minY: undefined,
-  pivotY: undefined,
-  stepY: undefined,
-};
-
-export const initialState = { ...xInitialState, ...yInitialState };
-
-export const linearStateFromNewProps = (type) => {
-  const xLinearState = hasXLinear(type) ? {} : xInitialState;
-  const YLinearState = hasYLinear(type) ? {} : yInitialState;
-  return ({
-    ...xLinearState,
-    ...R.when(
-      R.always(isStacked(type)),
-      R.assoc('pivotY', 0)
-    )(YLinearState),
-  });
-};
-
-export const toProperties = (props, state, onChange) => ({
-  maxX: {
-    id: 'maxX',
-    isActive: hasXLinear(props.type),
-    onChange: (value) => onChange({
-      maxX: isNumber(value) ? value : undefined
-    }),
-    value: R.isNil(state.maxX) ? String(state.computedMaxX) : state.maxX
-  },
-  maxY: {
-    id: 'maxY',
-    isActive: hasYLinear(props.type),
-    onChange: (value) => onChange({
-      maxY: isNumber(value) ? value : undefined
-    }),
-    value: R.isNil(state.maxY) ? String(state.computedMaxY) : state.maxY
-  },
-  minX: {
-    id: 'minX',
-    isActive: hasXLinear(props.type),
-    onChange: (value) => onChange({
-      minX: isNumber(value) ? value : undefined
-    }),
-    value: R.isNil(state.minX) ? String(state.computedMinX) : state.minX
-  },
-  minY: {
-    id: 'minY',
-    isActive: hasYLinear(props.type),
-    onChange: (value) => onChange({
-      minY: isNumber(value) ? value : undefined
-    }),
-    value: R.isNil(state.minY) ? String(state.computedMinY) : state.minY
-  },
-  pivotX: {
-    id: 'pivotX',
-    isActive: hasXPivot(props.type),
-    onChange: (value) => onChange({
-      pivotX: isNumber(value) ? value : undefined
-    }),
-    value: R.when(
-      v => R.isNil(v) && (R.propEq(ROW, 'type')(props) || R.propEq(STACKED_ROW, 'type')(props)),
-      R.always(0)
-    )(R.isNil(state.pivotX) ? String(state.computedPivotX) : state.pivotX)
-  },
-  pivotY: {
-    id: 'pivotY',
-    isActive: hasYPivot(props.type),
-    onChange: (value) => onChange({
-      pivotY: isNumber(value) ? value : undefined
-    }),
-    value: R.when(
-      v => R.isNil(v) && (R.propEq(BAR, 'type')(props) || R.propEq(STACKED_BAR, 'type')(props)),
-      R.always(0)
-    )(R.isNil(state.pivotY) ? String(state.computedPivotY) : state.pivotY)
-  },
-  stepX: {
-    id: 'stepX',
-    isActive: hasXLinear(props.type),
-    onChange: (value) => onChange({
-      stepX: isPositiveNumber(value) ? value : undefined
-    }),
-    value: R.isNil(state.stepX) ? String(state.computedStepX) : state.stepX
-  },
-  stepY: {
-    id: 'stepY',
-    isActive: hasYLinear(props.type),
-    onChange: (value) => onChange({
-      stepY: isPositiveNumber(value) ? value : undefined
-    }),
-    value: R.isNil(state.stepY) ? String(state.computedStepY) : state.stepY
-  },
-});

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(R.prop(property, state), 'id'),
-    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(R.prop('id', _scatterY), 'id'), values))
-    : _scatterX;
-  const scatterY = R.isNil(_scatterY)
-    ? R.head(R.reject(R.propEq(R.prop('id', scatterX),'id'), values))
-    : _scatterY;
-
-  const scatterState = toScatterState(
-    scatterDimension,
-    scatterX,
-    scatterY,
-  );
-
-  return ({
-    ...scatterState,
-    ...focusStateFromNewProps(
-      props,
-      toScatterSingularity(scatterState),
-      state
-    )
-  });
-};

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

@@ -1,96 +0,0 @@
-import * as R from 'ramda';
-import { PERCENT, STACKED_BAR, STACKED_ROW, VALUES } from '../constants';
-import {
-  getDimensionsWithValues,
-  getGroupedDimensions,
-  getPropertyDimension,
-  toState
-} from './utils';
-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 dimensions = getDimensionsWithValues(data);
-  if (R.length(dimensions) < 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)) {
-    if (R.length(dimensions) === 1) {
-      dimension = R.find(R.prop('header'), data.dimensions);
-    }
-    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
-    )
-  });
-}