@sis-cc/dotstatsuite-components 15.0.21 → 16.0.0

package/src/rules2/src/table/getCells.js

@@ -0,0 +1,72 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './getFlagsAndNotes';
+import { hasCellMetadata } from '../hasCellMetadata';
+import { trimedProps } from '../utils';
+
+export const getCellRelevantAttributes = (attributes, attributesSeries, cellAttributeIds) => R.filter(
+  (attr) => {
+    if (R.has(attr.id, cellAttributeIds)) {
+      return true;
+    }
+    const attrInSerie = R.path([attr.serieKey, attr.id], attributesSeries);
+    return R.isNil(attrInSerie);
+  },
+  attributes
+);
+
+export const getCellCombinedAttributes = (attributes, combinations) => R.reduce(
+  (acc, comb) => {
+    const values = trimedProps(comb.concepts, attributes);
+    if (R.isEmpty(values)) {
+      return acc;
+    }
+    return R.append({ ...R.pick(['id', 'name'], comb), values: R.pluck('value', values) }, acc);
+  },
+  [],
+  combinations
+)
+
+// combinations = { cells, layout };
+export const getCells = (customAttributes, cellsAttributesId, combinations, attributesSeries, metadataCoordinates) => observations => {
+  const attributesInLayoutCombination = R.pipe(
+    R.propOr([], 'layout'),
+    R.pluck('concepts'),
+    R.unnest
+  )(combinations);
+
+  const attributesInCellsCombination = R.pipe(
+    R.propOr([], 'cells'),
+    R.pluck('concepts'),
+    R.unnest
+  )(combinations);
+
+  const _customAttributes = R.over(
+    R.lensProp('notes'),
+    notes => R.concat(notes || [], attributesInLayoutCombination)
+  )(customAttributes);
+
+  return R.mapObjIndexed(
+    obs => {
+      const relevantAttributes = getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
+      const flagsAndNotes = getFlagsAndNotes(relevantAttributes, _customAttributes);
+      const combinedAttributes = getCellCombinedAttributes(relevantAttributes, combinations.cells || []);
+
+      const hasAdvancedAttributes = R.pipe(
+        R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])),
+        R.isEmpty,
+        R.not
+      )(relevantAttributes);
+
+      const hasMetadata = hasCellMetadata(metadataCoordinates, obs.indexedDimValIds);
+
+      return ({
+        ...R.pick(['indexedDimValIds', 'key'], obs),
+        flags: R.concat(flagsAndNotes, combinedAttributes),
+        sideProps: hasAdvancedAttributes || hasMetadata ? { hasAdvancedAttributes, hasMetadata, coordinates: obs.indexedDimValIds } : null,
+        intValue: R.is(Number, obs.value) ? obs.value : null,
+        value: obs.formattedValue,
+      });
+    },
+    observations
+  );
+};

package/src/rules2/src/table/getCellsAttributesIds.js

@@ -0,0 +1,38 @@
+import * as R from 'ramda';
+
+export const getCellsAttributesIds = (layoutIds, attributes) => {
+  return R.reduce(
+    (acc, attr) => {
+      if (!attr.series) {
+        return acc;
+      }
+      if (R.isEmpty(attr.relationship || [])) {
+        return R.assoc(attr.id, attr.id, acc);
+      }
+      const indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
+      const indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
+      const indexedRowsIds = { ...indexedSectionsIds, ...R.indexBy(R.identity, layoutIds.rows) };
+      const [idsInHeader, rest] = R.partition(
+        id => R.has(id, indexedHeaderIds),
+        attr.relationship,
+      );
+      if (R.isEmpty(rest)) {
+        return acc;
+      } else if (!R.isEmpty(idsInHeader)) {
+        return R.assoc(attr.id, attr.id, acc);
+      } else {
+        const idsNotInSections = R.reject(id => R.has(id, indexedSectionsIds), attr.relationship);
+        if (R.isEmpty(idsNotInSections)) {
+          return acc;
+        }
+        const idsNotInRows = R.reject(id => R.has(id, indexedRowsIds), idsNotInSections);
+        if (R.isEmpty(idsNotInRows)) {
+          return acc;
+        }
+      }
+      return R.assoc(attr.id, attr.id, acc);
+    },
+    {},
+    attributes,
+  );
+};

package/src/rules2/src/table/getCombinationDimensionsData.js

@@ -0,0 +1,38 @@
+import * as R from 'ramda';
+import { parseValueHierarchy } from './parseValueHierarchy';
+
+export const getCombinationDimensionsData = (indexes, combination, previous, sameSerie) => {
+  let coordinates = {};
+  let ids = [];
+  let _sameSerie = sameSerie;
+  let hasAdvancedAttributes = false;
+
+  const { dimensions=[] } = combination;
+  const dimValues = R.addIndex(R.reduce)(
+    (acc, valIndex, dimIndex) => {
+      const dimension = R.nth(dimIndex, dimensions);
+      const value = R.nth(Math.abs(valIndex), R.propOr([], 'values', dimension));
+      hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
+      if (!value) {
+        return acc;
+      }
+      coordinates = R.assoc(dimension.id, value.id, coordinates);
+      ids = R.append(`${dimension.id}=${value.id}`, ids);
+      const previousValue = R.propOr({}, dimension.id, previous);
+      if (value.id === R.prop('id', previousValue || {}) && _sameSerie) {
+        return R.assoc(dimension.id, previousValue, acc);
+      }
+      else {
+        const parsedValue = parseValueHierarchy(value, _sameSerie ? previousValue || {} : {}, dimension.indexedValues);
+        if (!R.isNil(previous)) {
+          _sameSerie = false;
+        }
+        return R.assoc(dimension.id, parsedValue, acc);
+      }
+    },
+    {},
+    indexes
+  );
+
+  return ({ dimValues, coordinates, ids, sameSerie: _sameSerie, hasAdvancedAttributes });
+};

package/src/rules2/src/table/getCuratedCells.js

@@ -0,0 +1,33 @@
+import * as R from 'ramda';
+
+export const getCuratedCells = (cells, layout) => {
+  const layoutIds = R.map(
+    R.pipe(
+      R.map(entry =>
+        R.has('dimensions', entry) ? R.pluck('id', entry.dimensions || []) : entry.id,
+      ),
+      R.unnest,
+    ),
+  )(layout);
+  return R.pipe(
+    R.values,
+    R.reduce((acc, cell) => {
+      const keys = R.map(
+        R.pipe(
+          R.map(dim => {
+            const val = R.prop(dim, cell.indexedDimValIds);
+            return `${dim}=${val}`;
+          }),
+          R.join(':'),
+        ),
+        layoutIds,
+      );
+
+      return R.over(
+        R.lensPath(R.props(['header', 'sections', 'rows'], keys)),
+        cells => (R.isNil(cells) ? [cell] : R.append(cell, cells)),
+        acc,
+      );
+    }, {}),
+  )(cells);
+};

package/src/rules2/src/table/getFlagsAndNotes.js

@@ -0,0 +1,21 @@
+import * as R from 'ramda';
+
+export const getFlagsAndNotes = (attributesValues, customAttributes) => {
+  const flagsIds = R.propOr([], 'flags', customAttributes);
+  const notesIds = R.propOr([], 'notes', customAttributes);
+
+  return R.addIndex(R.reduce)(
+    (acc, id, index) => {
+      if (!R.has(id, attributesValues)) {
+        return acc;
+      }
+      const attr = R.prop(id, attributesValues);
+      if (R.isNil(attr.value)) {
+        return acc;
+      }
+      return R.append(index < flagsIds.length ? R.assoc('code', R.path(['value', 'id'], attr), attr) : attr, acc);
+    },
+    [],
+    R.concat(flagsIds, notesIds)
+  );
+};

package/src/rules2/src/table/getIndexedCombinationsByDisplay.js

@@ -0,0 +1,16 @@
+import * as R from 'ramda';
+
+export const getIndexedCombinationsByDisplay = (layout, combinations) => {
+  const layoutIds = R.pipe(
+    R.map(R.pluck('id')),
+    R.values,
+    R.unnest,
+    R.indexBy(R.identity),
+  )(layout);
+
+  const [combsInLayout, combsInCells] = R.partition(
+    comb => R.has(comb.id, layoutIds),
+    combinations,
+  );
+  return { cells: combsInCells, layout: combsInLayout };
+};

package/src/rules2/src/table/getLayout.js

@@ -0,0 +1,80 @@
+import * as R from 'ramda';
+import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+import { trimedProps } from '../utils';
+
+export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted, fixedDimensions) => {
+    const indexedDimensions = R.pipe(
+      R.indexBy(R.prop('id')),
+      R.map(d => (isTimePeriodDimension(d) && isTimeInverted ? R.assoc('isInverted', true, d) : d)),
+    )(dimensions);
+    const indexedFixedDimsValues = R.reduce(
+      (acc, dim) => {
+        const value = R.head(dim.values);
+        return !dim.display || !value.display ? acc : R.assoc(dim.id, R.head(dim.values), acc);
+      },
+      {},
+      fixedDimensions,
+    );
+    const indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
+    const indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
+    const indexedRowsIds = { ...indexedSectionsIds, ...R.indexBy(R.identity, layoutIds.rows) };
+    let layout = { header: [], sections: [], rows: [] };
+    R.forEach(comb => {
+      if (R.isEmpty(comb.relationship)) {
+        return;
+      }
+      const [idsInHeader, rest] = R.partition(id => R.has(id, indexedHeaderIds), comb.relationship);
+      if (R.isEmpty(rest)) {
+        layout = R.over(
+          R.lensProp('header'),
+          R.append({
+            ...comb,
+            dimensions: trimedProps(comb.concepts, indexedDimensions),
+            fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
+          }),
+        )(layout);
+      } else if (!R.isEmpty(idsInHeader)) {
+        return;
+      } else {
+        const idsNotInSections = R.reject(id => R.has(id, indexedSectionsIds), comb.relationship);
+        if (R.isEmpty(idsNotInSections)) {
+          layout = R.over(
+            R.lensProp('sections'),
+            R.append({
+              ...comb,
+              dimensions: trimedProps(comb.concepts, indexedDimensions),
+              fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
+            }),
+          )(layout);
+        } else {
+          const idsNotInRows = R.reject(id => R.has(id, indexedRowsIds), comb.relationship);
+          if (R.isEmpty(idsNotInRows)) {
+            layout = R.over(
+              R.lensProp('rows'),
+              R.append({
+                ...comb,
+                dimensions: R.pipe(R.omit(layoutIds.sections), o => trimedProps(comb.concepts, o))(
+                  indexedDimensions,
+                ),
+                fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
+              }),
+            )(layout);
+          }
+        }
+      }
+    }, combinations);
+    return R.mapObjIndexed((combs, key) => {
+      const conceptIds = R.pipe(R.pluck('concepts'), R.unnest, R.indexBy(R.identity))(combs);
+      const rest = R.reduce(
+        (acc, id) => {
+          if (R.has(id, conceptIds)) {
+            return acc;
+          }
+          return R.append(R.prop(id, indexedDimensions), acc);
+        },
+        [],
+        layoutIds[key],
+      );
+      return R.concat(rest, combs);
+    }, layout);
+  };

package/src/rules2/src/table/getLayoutData.js

@@ -0,0 +1,183 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './getFlagsAndNotes';
+import { hasCellMetadata } from '../hasCellMetadata';
+import { getCombinationDimensionsData } from './getCombinationDimensionsData';
+import { parseValueHierarchy } from './parseValueHierarchy';
+
+const getSubLayoutData = (series, _definition, { metadataCoordinates, attributesSeries, customAttributes }) => {
+  const getHasAdvancedAttributes = (attrValues) => R.pipe(
+    R.omit(R.concat(customAttributes.flags, customAttributes.notes)),
+    R.isEmpty,
+    R.not
+  )(attrValues);
+
+  const combinationConceptIds = R.reduce(
+    (acc, def) => {
+      const concepts = R.propOr([], 'concepts', def);
+      if (R.isEmpty(concepts)) {
+        return acc;
+      }
+      return R.concat(acc, concepts);
+    },
+    [],
+    _definition
+  );
+
+  const definition = R.map( //used for parseValueHierarchy ...
+    (entry) => {
+      if (R.has('dimensions', entry)) {
+        return ({ 
+          ...entry,
+          dimensions: R.map(
+            dim => R.assoc('indexedValues', R.indexBy(R.prop('id'), dim.values || []), dim),
+            entry.dimensions
+          )
+        });
+      }
+      return R.assoc('indexedValues', R.indexBy(R.prop('id'), entry.values || []), entry);
+    },
+    _definition
+  );
+
+  const { res } = R.reduce(
+    (acc, serie) => {
+      let data = [];
+      let next = [];
+      let sameSerie = true;
+      let i = 0;
+      let hasAdvancedAttributes = false;
+      let coordinates = {};
+      let ids = [];
+      while (i < serie.length) {
+        const entry = serie[i];
+        if (R.is(Array, entry)) {
+          const combination = definition[i];
+          const previousDimValues = R.nth(i, acc.previous);
+          const combData = getCombinationDimensionsData(entry, combination, previousDimValues, sameSerie);
+          data = R.append({
+            dimension: R.pick(['id', 'name'], combination),
+            dimValues: combData.dimValues
+          }, data);
+          next = R.append(combData.dimValues, next);
+          hasAdvancedAttributes = !hasAdvancedAttributes ? combData.hasAdvancedAttributes : true;
+          sameSerie = combData.sameSerie;
+          coordinates = { ...coordinates, ...combData.coordinates };
+          ids = R.concat(ids, combData.ids);
+        }
+        else {
+          const dimension = definition[i];
+          const value = R.nth(Math.abs(entry), dimension.values || []);
+          const previousValue = R.nth(i, acc.previous) || {};
+          coordinates = R.assoc(dimension.id, value.id, coordinates);
+          ids = R.append(`${dimension.id}=${value.id}`, ids);
+          if (value.id === R.prop('id', previousValue || {}) && sameSerie) {
+            next = R.append(previousValue, next);
+            data = R.append({
+              dimension: R.pick(['id', 'name', '__index'], dimension),
+              value:  previousValue,
+            }, data);
+          }
+          else {
+            hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
+            const parsedValue = parseValueHierarchy(value, sameSerie ? previousValue || {} : {}, dimension.indexedValues);
+            next = R.append(parsedValue, next);
+            data = R.append({
+              dimension: R.pick(['id', 'name', '__index'], dimension),
+              value: parsedValue,
+            }, data);
+            if (!R.isNil(acc.previous)) {
+              sameSerie = false;
+            }
+          }
+        }
+        i++;
+      }
+
+      const attributesValues = R.reduce(
+        (acc, key) => {
+          const splitKey = R.split(':', key);
+          const isValid = R.all(entry => {
+            const [d, v] = R.split('=', entry);
+            return R.propEq(d, v, coordinates);
+          }, splitKey);
+          return isValid ? { ...acc, ...(R.length(splitKey) === 1 ? R.pick(combinationConceptIds, R.prop(key, attributesSeries)) : R.prop(key, attributesSeries)) } : acc;
+        },
+        {},
+        R.keys(attributesSeries)
+      );
+
+      data = R.addIndex(R.map)(
+        (entry, ind) => {
+          if (!R.has('dimValues', entry)) {
+            return entry;
+          }
+          const { dimValues, dimension } = entry;
+          const def = R.nth(ind, definition);
+          const fixedDimValues = R.propOr([], 'fixedDimValues', def);
+          const values = R.reduce(
+            (_acc, id) => {
+              if (R.has(id, dimValues)) {
+                return R.append(R.prop(id, dimValues), _acc);
+              }
+              if (R.has(id, fixedDimValues)) {
+                return R.append(R.prop(id, fixedDimValues), _acc);
+              }
+              if (!R.has(id, attributesValues)) {
+                return _acc;
+              }
+              return R.append(R.path([id, 'value'], attributesValues), _acc);
+            },
+            [],
+            def.concepts
+          );
+          return ({ dimension, values });
+        },
+        data
+      );
+
+      const layoutAttrValues = R.pipe(
+        R.omit(combinationConceptIds),
+        R.reject(R.prop('isObs'))
+      )(attributesValues);
+
+      const flags = getFlagsAndNotes(layoutAttrValues, customAttributes);
+      const hasMetadata = hasCellMetadata(metadataCoordinates, coordinates);
+
+      if (!hasAdvancedAttributes) {
+        hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues);
+      }
+
+      const sideProps = hasMetadata || hasAdvancedAttributes
+        ? { hasMetadata, hasAdvancedAttributes, coordinates } : null;
+
+      return {
+        res: R.append({ data, key: R.join(':', ids), flags, sideProps }, acc.res),
+        previous: next,
+      };
+    },
+    { res: [], previous: [] },
+    series
+  );
+
+  return res;
+};
+
+export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes }) => {
+  const { header, sections, ...rest } = layoutIndexes;
+  const opts = { metadataCoordinates, attributesSeries, customAttributes };
+  const headerData = getSubLayoutData(header, layout.header, opts);
+  const sectionsData = R.pipe(
+    R.transpose,
+    ([sections, sectionsRows]) => {
+      if (R.isNil(sections)) {
+        return [];
+      }
+      const _sectionsData = getSubLayoutData(sections, layout.sections, opts);
+      const rowsData = R.map(rows => getSubLayoutData(rows, layout.rows, opts), sectionsRows);
+
+      return R.transpose([_sectionsData, rowsData]);
+    }
+  )(sections);
+
+  return ({ headerData, sectionsData, ...rest });
+};

package/src/rules2/src/table/getSortedLayoutIndexes.js

@@ -0,0 +1,119 @@
+import * as R from 'ramda';
+
+/*
+  const layout = {
+    header: [
+      { id, __index },
+      { id: COMB, dimensions: [{ id, __index }] }
+    ],
+    sections: [],
+    rows: []
+  }
+
+*/
+
+const getLayoutPivots = layoutEntry => {
+  const valIndexGetter = d => R.pipe(
+    R.nth(R.prop('__index', d)),
+    ind => d.isInverted ? R.negate(ind) : ind
+  );
+  return indexes => R.map(
+    R.ifElse(
+      R.has('dimensions'),
+      c => R.map(d => valIndexGetter(d)(indexes), R.prop('dimensions', c)),
+      d => valIndexGetter(d)(indexes)
+    ),
+    layoutEntry
+  );
+};
+
+const comparator = (a, b) => {
+  const size = R.length(a);
+  let i = 0;
+  while (i < size) {
+    if (R.is(Array, a[i])) {
+      const _a = a[i];
+      const _b = b[i];
+      const _size = R.length(_a);
+      let j = 0;
+      while (_a[j] === _b[j] && j < _size) {
+        j++;
+      }
+      if (_a[j] !== _b[j]) {
+        return _a[j] - _b[j];
+      }
+    }
+    else if (a[i] !== b[i]) {
+      return a[i] - b[i];
+    }
+    i++;
+  }
+  return a[i] - b[i];
+};
+
+// simple call to ramda uniq method is very slow regarding performance
+const uniqIndexes = (indexes) => R.pipe(
+  R.reduce(
+    (acc, i) => {
+      const key = R.join(':', R.unnest(i));
+      if (R.has(key, acc.keys)) {
+        return acc;
+      }
+      return ({
+        indexes: R.append(i, acc.indexes),
+        keys: R.assoc(key, key, acc.keys)
+      });
+    },
+    { indexes: [], keys: {} },
+  ),
+  R.prop('indexes')
+)(indexes);
+
+export const getSortedLayoutIndexes = (layout, observations) => {
+  const dimIndexes = R.pipe(R.values, R.map(R.propOr([], 'orderedDimIndexes')))(observations);
+
+  const headerPivots = getLayoutPivots(layout.header);
+  const sectionsPivots = getLayoutPivots(R.concat(layout.sections, layout.rows));
+
+  const sectionLength = R.length(layout.sections);
+  const { header, sections } = R.pipe(
+    R.reduce(
+      (acc, indexes) => {
+        const headerIndexes = headerPivots(indexes);
+        const sectionsIndexes = sectionsPivots(indexes);
+
+        return ({
+          header: R.append(headerIndexes, acc.header),
+          sections: R.append(sectionsIndexes, acc.sections)
+        });
+      },
+      { header: [], sections: [] },
+    ),
+    R.mapObjIndexed(uniqIndexes),
+    R.evolve({
+      header: R.sort(comparator),
+      sections: R.sort(comparator)
+    }),
+    indexes => ({
+      ...indexes,
+      sections: R.reduce(
+        (acc, i) => {
+          const [sectionIndexes, rowIndexes] = R.splitAt(sectionLength, i);
+          const previousSecIndexes = R.pipe(R.nth(-1), i => R.isNil(i) ? null : R.head(i))(acc);
+          if (R.equals(R.unnest(sectionIndexes), previousSecIndexes ? R.unnest(previousSecIndexes) : null)) { //perhaps a bit dirty ...
+            return R.over(
+              R.lensIndex(-1),
+              R.over(R.lensIndex(1), R.append(rowIndexes))
+            )(acc);
+          }
+
+          return R.append([sectionIndexes, [rowIndexes]], acc);
+        },
+        [],
+        indexes.sections
+      )
+    })
+  )(dimIndexes);
+
+  return ({ header, sections });
+};

package/src/rules2/src/table/getTableProps.js

@@ -0,0 +1,36 @@
+import * as R from 'ramda';
+import { getLayout } from './getLayout';
+import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
+import { refineLayoutSize } from './refineLayoutSize';
+import { getLayoutData } from './getLayoutData';
+import { getCellsAttributesIds } from './getCellsAttributesIds';
+import { getIndexedCombinationsByDisplay } from './getIndexedCombinationsByDisplay';
+import { getCells } from './getCells';
+import { getCuratedCells } from './getCuratedCells';
+
+export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTimeInverted }) => {
+  const {
+    observations,
+    dimensions,
+    combinations,
+    oneValueDimensions,
+    attributesSeries,
+    metadataCoordinates,
+    attributes
+  } = data;
+
+  const seriesCombinations = R.filter(R.prop('series'), combinations);
+  const layout = getLayout(layoutIds, dimensions, seriesCombinations, isTimeInverted, oneValueDimensions);
+  const layoutIndexes = getSortedLayoutIndexes(layout, observations);
+  const refinedLayoutIndexes = refineLayoutSize({ layout, observations, limit })(layoutIndexes);
+  const layoutData = getLayoutData(refinedLayoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes });
+
+  const cellsAttributesIds = getCellsAttributesIds(layoutIds, attributes);
+  const indexedCombinations = getIndexedCombinationsByDisplay(layout, seriesCombinations);
+  const cells = getCells(customAttributes, cellsAttributesIds, indexedCombinations, attributesSeries, metadataCoordinates)(observations);
+
+  return ({
+    ...layoutData,
+    cells: getCuratedCells(cells, layout)
+  });
+};

package/src/rules2/src/table/parseValueHierarchy.js

@@ -0,0 +1,27 @@
+import * as R from 'ramda';
+
+export const parseValueHierarchy = (value, previousValue, indexedValues) => {
+  const parentsIds = R.propOr([], 'parents', value);
+  if (R.isEmpty(parentsIds)) {
+    return value;
+  }
+  const _previousParentsIds = R.propOr([], 'parentsIds', previousValue);
+  const previousParentsIds = R.isNil(previousValue) ? [] : R.append(R.prop('id', previousValue), _previousParentsIds);
+  const [presentIds, missingIds] = R.addIndex(R.splitWhen)((val, ind) => R.nth(ind, previousParentsIds) !== val, parentsIds);
+  //console.log({ presentIds, missingIds });
+  const _previousParents = R.propOr([], 'parents', previousValue);
+  const previousParents = R.isNil(previousValue) ? [] : R.append(R.pick(['id', 'name'], previousValue), _previousParents);
+  //console.log('previousParents', previousParents);
+  const parents = R.takeWhile(p => R.includes(p.id, presentIds), previousParents);
+  const missingParents = R.concat(
+    R.includes(R.prop('id', previousValue), presentIds)
+      ? [] : R.takeWhile(p => R.includes(p.id, presentIds), R.propOr([], 'missingParents', previousValue)),
+    R.props(missingIds, indexedValues)
+  );
+  return ({
+    ...value,
+    parents,
+    parentsIds,
+    missingParents
+  });
+};