@sis-cc/dotstatsuite-components 22.5.0 → 23.0.0

package/src/rules/src/factories/choro-series.js

@@ -1,55 +1,66 @@
-import { get, has, head, isUndefined, map, split, transform } from 'lodash';
+import * as R from 'ramda';
 import { getRefAreaDimension } from '@sis-cc/dotstatsuite-sdmxjs';
 import { categoryDisplay, dimensionValueDisplay } from '../dimension-utils';
 
 const parseByAreas = (observations, refAreaDimension) => {
-  if (isUndefined(refAreaDimension)) {
+  if (R.isNil(refAreaDimension)) {
     return null;
   }
-  const refAreaDimIndex = get(refAreaDimension, 'index');
-  const refAreaValues = refAreaDimension.values;
+  const { __index, values=[] } = refAreaDimension;
 
-  return transform(
-    observations,
-    (acc, value, key) => {
-      const splitedKey = split(key, ':');
-      const areaValueIndex = get(splitedKey, `[${refAreaDimIndex}]`, null);
-      const areaValue = get(refAreaValues, `[${areaValueIndex}]`, null);
-      const areaId = get(areaValue, 'id', null);
-      if (!has(acc, areaId)) {
-        acc[areaId] = [];
-      }
-      acc[areaId].push({ splitedKey, value, areaValueIndex });
-    },
-    {}
-  );
+  return R.pipe(
+    R.keys,
+    R.reduce((acc, key) => {
+      const value = observations[key];
+      const splitedKey = R.split(':', key);
+      const areaValueIndex = Number(R.nth(__index, splitedKey));
+      const areaValue = isNaN(areaValueIndex)
+        ? null : R.nth(areaValueIndex, values);
+      const areaId = R.prop('id', areaValue || {});
+      return R.over(
+        R.lensProp(areaId),
+        vals => R.append({ splitedKey, value, areaValueIndex }, vals || []),
+        acc
+      ); 
+    }, {})
+  )(observations);
 };
 
 export default ({ observations, dimensions }, dimensionsWithValuesIndexedById, topoMap, display) => {
   const refAreaDimension = getRefAreaDimension({ dimensions });
   const observationsByAreas = parseByAreas(observations, refAreaDimension);
-  const topology = get(topoMap, 'topology', {});
-  const areaSelection = get(topoMap, 'areaSelection', null);
-  const topoAreas = get(topology, `objects.${areaSelection}`, null);
+  const topology = R.propOr({}, 'topology', topoMap);
+  const areaSelection = R.propOr(null, 'areaSelection', topoMap);
+  const topoAreas = R.pathOr(null, ['objects', areaSelection], topology);
   if (!observationsByAreas || !topoAreas) {
     return null;
   }
-  const topoAreasWithData = map(
-    topoAreas.geometries,
+  const topoAreasWithData = R.map(
     (areaGeometry) => {
-      const areaObservation = head(get(observationsByAreas, get(areaGeometry, 'properties.id', null), []));
-      const areaValueIndex = get(areaObservation, 'areaValueIndex', null);
-      const areaValue = get(refAreaDimension, `values[${areaValueIndex}]`, null);
+      const areaObservation = R.pipe(
+        R.pathOr(null, ['properties', 'id']),
+        id => R.propOr([], id, observationsByAreas),
+        R.head
+      )(areaGeometry);
+      const areaValueIndex = R.propOr(null, 'areaValueIndex', areaObservation);
+      const areaValue = R.pathOr(null, ['values', areaValueIndex], refAreaDimension);
       return {
         ...areaGeometry,
         properties: {
-          ...get(areaGeometry, 'properties', {}),
+          ...R.propOr({}, 'properties', areaGeometry),
           label: dimensionValueDisplay(display)(areaValue),
-          value: head(get(areaObservation, 'value', [])),
-          category: categoryDisplay(get(areaObservation, 'splitedKey', null), dimensions, dimensionsWithValuesIndexedById, refAreaDimension.id, display),
+          value: R.head(R.propOr([], 'value', areaObservation)),
+          category: categoryDisplay(
+            R.propOr([], 'splitedKey', areaObservation),
+            dimensions,
+            dimensionsWithValuesIndexedById,
+            refAreaDimension.id,
+            display
+          ),
         }
       };
-    }
+    },
+    topoAreas.geometries,
   );
   return ({
     objects: {

package/src/rules/src/factories/focus.js

@@ -0,0 +1,17 @@
+import sampleFocus from './sample-focus';
+import scatterFocus from './scatter-focus';
+import timelineFocus from './timeline-focus';
+
+export default ({ type, series, focusOptions }) => {
+  switch(type) {
+    case 'ScatterChart':
+      return scatterFocus(series, focusOptions);
+    case 'TimelineChart':
+      return timelineFocus(series, focusOptions);
+    case 'BarChart': case 'RowChart': case 'StackedBarChart':
+    case 'StackedRowChart': case 'HorizontalSymbolChart': case 'VerticalSymbolChart':
+      return sampleFocus(series, focusOptions);
+    default:
+      return series;
+  }
+};

package/src/rules/src/factories/getChartSeries.js

@@ -0,0 +1,8 @@
+import getFocusedSeries from './focus';
+import getSeries from './series';
+
+export const getChartSeries = ({ type, data, options, singularity, focusOptions }) => {
+  const chartSeries = getSeries({ type, data, options, singularity });
+  const focusedSeries = getFocusedSeries({ type, series: chartSeries, focusOptions });
+  return focusedSeries;
+};

package/src/rules/src/factories/sample-focus.js

@@ -1,22 +1,18 @@
-import { map, each, get, omit, isArray, keys, head } from 'lodash';
+import * as R from 'ramda';
 
 export default function focus(series, focusSelections) {
-  const serie = head(series);
-  const datapoints = get(serie, 'datapoints', []);
+  const { highlight = [], baseline = [] } = focusSelections || {};
+  if (R.isEmpty(highlight) && R.isEmpty(baseline)) {
+    return series;
+  }
 
-  const _datapoints = map(datapoints, (datapoint) => {
-    let _datapoint = omit(datapoint, map(keys(focusSelections), focusKey => `${focusKey}Index`));
-    
-    each(focusSelections, (focusSelection, focusKey) => {
-      const _focusKey = `${focusKey}Index`;
-
-      each(isArray(focusSelection) ? focusSelection : [focusSelection], (focus, index) => {
-        if (get(focus, 'value') === _datapoint.key) _datapoint[_focusKey] = index;
-      });
-    });
-
-    return _datapoint;
-  });
-
-  return [{ ...serie, datapoints: _datapoints }];
+  return R.over(
+    R.lensPath([0, 'datapoints']),
+    R.map(dp => ({
+      ...dp,
+      highlightIndex: R.findIndex(R.propEq(dp.key, 'value'), highlight),
+      baselineIndex: R.path([0, 'value'], baseline) === dp.key ? 0 : -1
+    })),
+    series || []
+  );
 }

package/src/rules/src/factories/sample-series.js

@@ -1,35 +1,35 @@
-import { map, sortBy, head, isEmpty, isNil, split } from 'lodash';
+import * as R from 'ramda';
 import { categoryDisplay } from '../dimension-utils';
 import { getFormatedObservation } from '../observation-formater';
 
-export const getDatapoints = (
+const getDatapoints = (
   keys, observations, dimensions, dimensionsWithValuesIndexedById, sortDirection, display, formaterAttrs
 ) => {
   const [categoryKey, valueKey] = keys;
   const sortFunc =  dp => dp[valueKey] * sortDirection;
 
-  return sortBy(
-    map(
-      observations,
-      (observationValue, observationKey) => {
-        const value = head(observationValue);
-        const category = categoryDisplay(split(observationKey, ':'), dimensions, dimensionsWithValuesIndexedById, null, display);
-        const categoryIds = categoryDisplay(split(observationKey, ':'), dimensions, dimensionsWithValuesIndexedById, null, 'code');
-        const formatedValue = getFormatedObservation(observationValue, formaterAttrs);
+  return R.pipe(
+    R.keys,
+    R.map((observationKey) => {
+      const observationValue = R.prop(observationKey, observations);
+      const value = R.head(observationValue);
+      const splitKey = R.split(':', observationKey);
+      const category = categoryDisplay(splitKey, dimensions, dimensionsWithValuesIndexedById, null, display);
+      const categoryIds = categoryDisplay(splitKey, dimensions, dimensionsWithValuesIndexedById, null, 'code');
+      const formatedValue = getFormatedObservation(observationValue, formaterAttrs);
 
-        let key = categoryIds;
-        if (isNil(key) || isEmpty(key)) {
-          key = 'uniq-dp';
-        }
-
-        return { value, category, [valueKey]: value, [categoryKey]: category, key, formatedValue };
+      let key = categoryIds;
+      if (R.isNil(key) || R.isEmpty(key)) {
+        key = 'uniq-dp';
       }
-    ),
-    sortFunc
-  );
+
+      return { value, category, [valueKey]: value, [categoryKey]: category, key, formatedValue };
+    }),
+    R.sortBy(sortFunc)
+  )(observations);
 };
 
-export const series = (
+const series = (
   keys, observations, dimensions, dimensionsWithValuesIndexedById, sortDirection, display, formaterAttrs
 ) => {
   return [{

package/src/rules/src/factories/scatter-focus.js

@@ -1,39 +1,25 @@
-import { map, each, omit, get, split, reduce, isEmpty, keys } from 'lodash';
+import * as R from 'ramda';
 
 export default function focus(series, focusSelections) {
-  // scatter has only 1 serie
-  const serie = get(series, '[0]', {});
-
-  const _focusSelections = reduce(
-    focusSelections,
-    (memo, focusSelection, focusKey) => {
-      if (!isEmpty(focusSelection)) memo[focusKey] = focusSelection;
-      return memo;
-    },
-    {}
+  const { highlight = [], baseline = [] } = focusSelections || {};
+  if (R.isEmpty(highlight && R.isEmpty(baseline))) {
+    return series;
+  }
+
+  return R.over(
+    R.lensPath([0, 'datapoints']),
+    R.map(dp => {
+      const isFocusMatch = f => {
+        const focusedDim = R.path(['options', 'dimensionId'], f);
+        const dpValId = R.path(['dimensionValues', focusedDim, 'id'], dp);
+        return dpValId === R.path(['options', 'dimensionValueId'], f);
+      }
+      return ({
+        ...dp,
+        highlightIndex: R.findIndex(isFocusMatch, highlight),
+        baselineIndex: isFocusMatch(R.head(baseline)) ? 0 : -1
+      })
+    }),
+    series
   );
-
-  if (isEmpty(_focusSelections)) return series;
-
-  const datapoints = get(serie, 'datapoints', []);
-
-  let _datapoints = map(datapoints, (datapoint) => (
-    omit(datapoint, map(keys(focusSelections), focusKey => `${focusKey}Index`))
-  ));
-
-  const __datapoints = map(_datapoints, (datapoint) => {
-    each(_focusSelections, (focusSelection, focusKey) => {
-      const _focusKey = `${focusKey}Index`;
-
-      each(focusSelection, (focus, i) => {
-        const _focus = get(focus, 'options', {});
-        const dimensionValueId = get(datapoint, `dimensionValues.${_focus.dimensionId}.id`);
-        if (dimensionValueId === _focus.dimensionValueId) datapoint[_focusKey] = i;
-      });
-    });
-
-    return datapoint;
-  });
-
-  return [{ ...serie, datapoints: __datapoints }];
-}
+};

package/src/rules/src/factories/scatter-series.js

@@ -2,14 +2,14 @@ import * as R from 'ramda';
 import { dimensionValueDisplay } from '../dimension-utils';
 import { getFormatedObservation } from '../observation-formater';
 
-export function dimensionValueIsValid(dimensionValue, chartDimension) {
+function dimensionValueIsValid(dimensionValue, chartDimension) {
   return R.includes(
     R.prop('id', dimensionValue),
     R.map(k => R.prop(`${k}Id`, chartDimension), ['x', 'y']),
   );
 };
 
-export function getDimensionValues(
+function getDimensionValues(
   dimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, chartDimensionId, display
 ) {
   const dimensionsWithValuesIds = R.keys(dimensionsWithValuesIndexedById);
@@ -32,13 +32,13 @@ export function getDimensionValues(
   );
 };
 
-export function getDimensionValueKey(chartDimension, dimensionValue) {
+function getDimensionValueKey(chartDimension, dimensionValue) {
   return R.prop('xId', chartDimension,) === R.prop('id', dimensionValue) ? 'x' : 'y';
 };
 
-export function datapoints(observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) {
+function datapoints(observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) {
   const chartDimensionId = R.prop('id', chartDimension);
-  const chartDimensionIndex = R.findIndex(R.propEq('id', chartDimensionId), dimensions);
+  const chartDimensionIndex = R.findIndex(R.propEq(chartDimensionId, 'id'), dimensions);
   const datapoints = R.reduce(
     (acc, k) => {
       const o = R.prop(k, observations);
@@ -74,10 +74,10 @@ export function datapoints(observations, dimensions, dimensionsWithValuesIndexed
   )(datapoints);
 };
 
-export const series = (observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) => {
+const series = (observations, dimensions, dimensionsWithValuesIndexedById, chartDimension, display, formaterAttrs) => {
   const values = R.pipe(R.prop(R.prop('id', chartDimension || {})), R.propOr([], 'values'))(dimensionsWithValuesIndexedById);
-  const xValue = R.find(R.propEq('id', R.prop('xId', chartDimension)), values);
-  const yValue = R.find(R.propEq('id', R.prop('yId', chartDimension)), values);
+  const xValue = R.find(R.propEq(R.prop('xId', chartDimension),'id'), values);
+  const yValue = R.find(R.propEq(R.prop('yId', chartDimension), 'id'), values);
   return [{
     dimensionValues: {
       x: { ...xValue, name: dimensionValueDisplay(display)(xValue) },

package/src/rules/src/factories/series.js

@@ -0,0 +1,45 @@
+import * as R from 'ramda';
+import sampleSeries from './sample-series';
+import scatterSeries from './scatter-series';
+import timelineSeries from './timeline-series';
+import symbolSeries from './symbol-series';
+import stackedSeries from './stacked-series';
+import choroSeries from './choro-series';
+import { getObservationsFormaterAttributes } from '../observation-formater';
+
+export default ({ type, data, options, singularity }) => {
+  const {
+    display,
+    formatterIds,
+    map,
+  } = options;
+
+  const { attributes = [] } = data;
+  const formaterAttributes = getObservationsFormaterAttributes(attributes, formatterIds);
+
+  const indexedDimensions = R.reduce((acc, dim) => {
+    if (dim.header) {
+      return acc;
+    }
+    return R.assoc(dim.id, dim, acc);
+  }, {}, data.dimensions || []);
+
+  switch(type) {
+    case 'BarChart': case 'RowChart':
+      return sampleSeries(type, data, indexedDimensions, display, formaterAttributes);
+    case 'ScatterChart':
+      return scatterSeries(data, indexedDimensions, singularity, display, formaterAttributes);
+    case 'TimelineChart':
+      return timelineSeries(data, indexedDimensions, display, formaterAttributes);
+    case 'HorizontalSymbolChart': case 'VerticalSymbolChart':
+      return symbolSeries(data, type, indexedDimensions, singularity, display, formaterAttributes);
+    case 'StackedBarChart':
+      return stackedSeries(data, indexedDimensions, singularity, display, formaterAttributes, ['y', 'x']);
+    case 'StackedRowChart':
+      return stackedSeries(data, indexedDimensions, singularity, display, formaterAttributes, ['x', 'y']);
+    case 'ChoroplethChart':
+      return choroSeries(data, indexedDimensions, map, display);
+    default:
+      return [];
+  }
+};

package/src/rules/src/factories/stacked-series.js

@@ -65,12 +65,11 @@ const serie = (
   [stackKey, categoryKey]
 ) => {
   const serieDimensionId = R.propOr(null, 'id', singularity);
-  const serieDimension = R.find(R.propEq('id', serieDimensionId), dimensions);
+  const serieDimension = R.find(R.propEq(serieDimensionId, 'id'), dimensions);
   if (R.isNil(serieDimension)) {
     return { datapoints: [], layerSeries: [] };
   }
   const _flatDatapoints = flatDatapoints(observations, dimensions, dimensionsWithValuesIndexedById, serieDimensionId, display, formaterAttrs, [stackKey, categoryKey]);
-
   const layeredDatapoints = R.groupBy(
     R.prop('layerKey'),
     _flatDatapoints
@@ -145,7 +144,7 @@ const percentSerie = (stackKey) => R.pipe(
       });
     })
   ),
-  R.of
+  res => R.of(Array, res)
 );
 
 const serieSortedByTotal = (stackKey) => R.pipe(
@@ -153,7 +152,7 @@ const serieSortedByTotal = (stackKey) => R.pipe(
     R.lensProp('datapoints'),
     R.sortBy(R.pipe(R.prop(stackKey), R.map(v => v > 0 ? R.negate(v) : 0), R.sum))
   ),
-  R.of
+  res => R.of(Array, res)
 );
 
 const serieSortedByDataOrder = R.pipe(
@@ -161,7 +160,7 @@ const serieSortedByDataOrder = R.pipe(
     R.lensProp('datapoints'),
     R.sortBy(R.prop('index'))
   ),
-  R.of
+  res => R.of(Array, res)
 );
 
 export default (

package/src/rules/src/factories/symbol-series.js

@@ -1,52 +1,45 @@
-import { fill, findIndex, get, head, isEmpty, isNil, map, reduce, split, size, sortBy } from 'lodash';
+import * as R from 'ramda';
 import { categoryDisplay, dimensionValueDisplay } from '../dimension-utils';
 import { getFormatedObservation } from '../observation-formater';
 
 const series = (observations, dimensions, dimensionsWithValuesIndexedById, symbolDimension, sortDirection, display, formaterAttrs) => {
-  const symbolDimensionId = get(symbolDimension, 'id', null);
-  if (symbolDimensionId === null) return [];
-  const symbolDimensionIndex = findIndex(dimensions, d => d.id === symbolDimensionId);
-  const datapoints = sortBy(
-    reduce(
-      observations,
-      (memo, observationValue, observationKey) => {
-        if (!(head(observationValue))) {
-          // because yes it is possible to have null observations, why not ...
-          return memo;
-        }
-        const oDimensionValuesIndexes = split(observationKey, ':');
-        const oSymbolDimensionValueIndex = Number(oDimensionValuesIndexes[symbolDimensionIndex]);
-        const oSymbolDimensionValueId = dimensions[symbolDimensionIndex].values[oSymbolDimensionValueIndex].id;
+  const symbolDimensionId = R.propOr(null, 'id', symbolDimension);
+  if (symbolDimensionId === null)
+    return [];
+  const symbolDimIndex = R.findIndex(d => d.id === symbolDimensionId, dimensions);
+  const datapoints = R.pipe(
+    R.keys,
+    R.reduce((acc, obsKey) => {
+      const obs = observations[obsKey];
+      if (R.isNil(R.head(obs)) || R.isEmpty(R.head(obs))) {
+        return acc;
+      }
+      const obsDimsValsIndexes = R.split(':', obsKey);
+      const symbolValIndex = Number(R.nth(symbolDimIndex, obsDimsValsIndexes));
+      const symbolValId = R.path([symbolDimIndex, 'values', symbolValIndex, 'id'], dimensions);
+      const symbolIndex = R.findIndex(R.propEq(symbolValId, 'id'), symbolDimension.serie);
+      if (symbolIndex === -1) {
+        return acc;
+      }
+      const category = categoryDisplay(obsDimsValsIndexes, dimensions, dimensionsWithValuesIndexedById, symbolDimensionId, display);
+      const ids = categoryDisplay(obsDimsValsIndexes, dimensions, dimensionsWithValuesIndexedById, symbolDimensionId, 'code');
+      const key = R.isNil(ids) || R.isEmpty(ids) ? 'uniq-dp' : ids;
+      const dpIndex = R.findIndex(R.propEq(key, 'key'), acc);
+      const dp = R.pipe(
+        dpIndex => dpIndex === -1
+          ? { category, formatedValues: new Array(R.length(symbolDimension.serie)), values: new Array(R.length(symbolDimension.serie)), key }
+          : R.nth(dpIndex, acc),
+        R.set(R.lensPath(['values', symbolValIndex]), R.head(obs)),
+        R.set(R.lensPath(['formatedValues', symbolValIndex]), getFormatedObservation(obs, formaterAttrs)),
+      )(dpIndex);
+      return dpIndex === -1
+        ? R.append(dp, acc)
+        : R.set(R.lensIndex(dpIndex), dp, acc);
+    }, []),
+    R.sortBy(d => R.head(d.values) * sortDirection)
+  )(observations);
 
-        const symbolIndex = findIndex(symbolDimension.serie, v => v.id === oSymbolDimensionValueId);
-        if (symbolIndex === -1) {
-          return memo;
-        }
-        const category = categoryDisplay(oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, symbolDimensionId, display);
-        const ids = categoryDisplay(oDimensionValuesIndexes, dimensions, dimensionsWithValuesIndexedById, symbolDimensionId, 'code');
-        let dpIndex = findIndex(memo, dp => dp.key === ids);
-        let dpValues = (dpIndex === -1) ? fill(Array(size(symbolDimension.serie)), null) : memo[dpIndex].values;
-        let dpFormatedValues = (dpIndex === -1) ? fill(Array(size(symbolDimension.serie)), null) : memo[dpIndex].formatedValues;
-        dpValues[oSymbolDimensionValueIndex] = head(observationValue);
-        dpFormatedValues[oSymbolDimensionValueIndex] = getFormatedObservation(observationValue, formaterAttrs);
-        let key = ids;
-        if (isNil(ids) || isEmpty(ids)) {
-          key = 'uniq-dp';
-        }
-        if (dpIndex !== -1) {
-          memo[dpIndex].values = dpValues;
-          memo[dpIndex].formatedValues = dpFormatedValues;
-        }
-        else {
-          memo.push({ category, formatedValues: dpFormatedValues, values: dpValues, key });
-        }
-        return memo;
-      },
-      []
-    ),
-    d => head(d.values) * sortDirection
-  );
-  const symbolValues = map(symbolDimension.serie, v => dimensionValueDisplay(display)(v));
+  const symbolValues = R.map(dimensionValueDisplay(display), symbolDimension.serie);
   return [{ datapoints , symbolValues }];
 }
 

package/src/rules/src/factories/timeline-focus.js

@@ -1,18 +1,14 @@
-import { map, each, findIndex, get, omit, isArray, keys } from 'lodash';
+import * as R from 'ramda';
 
 export default function focus(series, focusSelections) {
-  return map(
-    series,
-    (serie, index) => {
-      each(focusSelections, (focusSelection, focusKey) => {
-        const _focusKey = `${focusKey}Index`;
-        const res = findIndex(
-          isArray(focusSelection) ? focusSelection : [focusSelection],
-          focus => focus.value === serie.key
-        );
-        serie[`${_focusKey}`] = res;
-      });
-      return serie;
-    }
+  const { highlight = [], baseline = [] } = focusSelections || {};
+
+  return R.map(
+    serie => ({
+      ...serie,
+      highlightIndex: R.findIndex(R.propEq(serie.key, 'value'), highlight),
+      baselineIndex: R.path([0, 'value'], baseline) === serie.key ? 0 : -1
+    }),
+    series
   );
 }