@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/src/rules2/src/getHeaderTitle.js

@@ -1,15 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay } from '../../rules/src';
-import { getFlagsAndNotes } from './table/getFlagsAndNotes';
-
-export const getHeaderTitle = (dataflow, attributes, display, customAttributes) => ({
-  label: dimensionValueDisplay(display)(dataflow),
-  flags: R.pipe(
-    getFlagsAndNotes,
-    R.map(entry => ({
-      code: entry.code,
-      header: `${dimensionValueDisplay(display)(entry)}:`,
-      label: dimensionValueDisplay(display)(entry.value),
-    })),
-  )(attributes, customAttributes),
-});

package/src/rules2/src/getMSDInformations.js

@@ -1,23 +0,0 @@
-import * as R from 'ramda';
-
-export const getMSDInformations = msdJson => {
-  const attributesDefinitions = R.pathOr([], ['data', 'metadataStructures', 0, 'metadataStructureComponents', 'reportStructures', 0, 'metadataAttributes'], msdJson);
-  const indexedConcepts = R.pipe(R.pathOr([], ['data', 'conceptSchemes', 0, 'concepts']), R.indexBy(R.prop('id')))(msdJson);
-
-  const parseAttributes = (parent) => R.reduce(
-    (acc, attribute) => {
-      const id = attribute.id;
-      const name = R.path([id, 'name'], indexedConcepts);
-      const hierarchicalId = parent === '#ROOT' ? id : `${parent}.${id}`;
-      const format = R.path(['localRepresentation', 'textFormat', 'textType'], attribute);
-      if (R.has('metadataAttributes', attribute)) {
-        const collection = parseAttributes(hierarchicalId)(attribute.metadataAttributes);
-        return ({ ...acc, ...collection, [hierarchicalId]: { format, parent, id, name } });
-      }
-      return R.assoc(hierarchicalId, { format, parent, id, name }, acc);
-    },
-    {}
-  )
-
-  return ({ attributes: parseAttributes('#ROOT')(attributesDefinitions) });
-};

package/src/rules2/src/getManyValuesDimensions.js

@@ -1,34 +0,0 @@
-import * as R from 'ramda';
-import { getFlagsAndNotes } from './table/getFlagsAndNotes';
-
-export const getManyValuesDimensions = (dimensions, attributesSeries, customAttributes, combinations) => {
-  const combConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
-  return R.reduce(
-    (acc, dim) => {
-      if (dim.header || !R.length(dim.values)) {
-        return acc;
-      }
-      const enhancedValues = R.map(val => {
-        const attrSeries = R.propOr({}, `${dim.id}=${val.id}`, attributesSeries);
-        if (R.isEmpty(attrSeries)) {
-          return val;
-        }
-        const flags = getFlagsAndNotes(attrSeries, customAttributes);
-        const hasAdvancedAttributes = R.pipe(
-          R.omit(
-            R.unnest([
-              customAttributes.flags || [],
-              customAttributes.notes || [],
-              combConceptsIds,
-            ]),
-          ),
-          R.complement(R.isEmpty),
-        )(attrSeries);
-        return { ...val, flags, hasAdvancedAttributes };
-      }, dim.values);
-      return R.append(R.assoc('values', enhancedValues, dim), acc);
-    },
-    [],
-    dimensions,
-  );
-};

package/src/rules2/src/getMetadataCoordinates.js

@@ -1,37 +0,0 @@
-import * as R from 'ramda';
-
-export const getMetadataCoordinates = (sdmxJson) => {
-  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
-  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
-  const metadataAvailKeys = R.pipe(
-    R.pathOr([], ['data', 'dataSets', 0, 'dimensionGroupAttributes']),
-    R.map(indexes => R.props(indexes, annotations)),
-    R.filter(R.find(a => a && R.propEq('type', 'HAS_METADATA', a))),
-    R.keys
-  )(sdmxJson);
-
-  return R.map(
-    key => {
-      const indexes = R.split(':', key);
-      return R.addIndex(R.reduce)(
-        (acc, vIndex, dimIndex) => {
-          if (R.isNil(vIndex) || R.isEmpty(vIndex)) {
-            return acc;
-          }
-          const dim = R.nth(dimIndex, dimensions);
-          if (R.isNil(dim)) {
-            return acc;
-          }
-          const val = R.path(['values', Number(vIndex)], dim);
-          if (R.isNil(val)) {
-            return acc;
-          }
-          return R.assoc(dim.id, val.id, acc);
-        },
-        {},
-        indexes
-      );
-    },
-    metadataAvailKeys
-  );
-};

package/src/rules2/src/getMetadataStructureFromData.js

@@ -1,17 +0,0 @@
-import * as R from 'ramda';
-
-export const getDataflowMetadataStructure = sdmxJson => {
-  const annotations = R.pathOr([], ['data', 'stucture', 'annotations'], sdmxJson);
-  const dataSetAnnotIndexes = R.pathOr([], ['data', 'dataSets', 0, 'annotations'], sdmxJson);
-  const dataSetAnnotations = R.props(dataSetAnnotIndexes, annotations);
-  const metadataAnnotation = R.find(R.propEq('type', 'METADATA'), dataSetAnnotations);
-  if (!metadataAnnotation) {
-    return null;
-  }
-  return R.pipe(
-    R.propOr('', 'title'),
-    R.split('='),
-    R.last,
-    
-  )(metadataAnnotation);
-};

package/src/rules2/src/getNotDisplayedIds.js

@@ -1,53 +0,0 @@
-import * as R from 'ramda';
-import { getNotDisplayedCombinations } from '@sis-cc/dotstatsuite-sdmxjs';
-
-const getNotDisplayedValues = annot => {
-  if (R.isNil(annot)) {
-    return {};
-  }
-  const ids = R.split(',', annot.title || '');
-  return R.reduce(
-    (acc, entry) => {
-      if (R.isEmpty(entry)) {
-        return acc;
-      }
-      const parsed = R.split('=', entry);
-      const dimensionId = parsed[0];
-      if (R.length(parsed) === 1) {
-        return R.assoc(dimensionId, dimensionId, acc);
-      }
-      const values = R.split('+', parsed[1]);
-      if (R.length(values) === 1 && R.isEmpty(values[0])) {
-        return R.assoc(dimensionId, dimensionId, acc);
-      }
-      return R.reduce(
-        (_acc, val) => {
-          let _val = val
-          if (R.isEmpty(val)) {
-            return _acc;
-          }
-          if (R.test('/[()]/')) {
-            _val = R.replace(/[()]/g, '')(val)
-          }
-          const key = R.isEmpty(_val) ? dimensionId : `${dimensionId}.${_val}`;
-          return R.assoc(key, key, _acc);
-        },
-        acc,
-        values
-      );
-    },
-    {},
-    ids
-  );
-};
-
-export const getNotDisplayedIds = (annotations) => R.pipe(
-  R.find(R.propEq('type', 'NOT_DISPLAYED')),
-  R.converge((hiddenValues, hiddenCombinations) => ({
-    hiddenValues,
-    hiddenCombinations
-  }), [
-    getNotDisplayedValues,
-    (annot={ title: '' }) => getNotDisplayedCombinations(annot) 
-  ])
-)(annotations);

package/src/rules2/src/getOneValueDimensions.js

@@ -1,34 +0,0 @@
-import * as R from 'ramda';
-import { REJECTED_VALUE_IDS } from './constants';
-
-export const getOneValueDimensions = (dimensions, attributes) => {
-  const indexedRelevantAttributes = R.reduce(
-    (acc, attr) => {
-      if (!attr.header || !R.propOr(true, 'display', attr) || R.length(attr.relationship || []) !== 1) {
-        return acc;
-      }
-      const value = R.path(['values', 0], attr);
-      if (R.isNil(value) || !R.propOr(true, 'display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
-        return acc;
-      }
-      const dim = R.head(attr.relationship);
-      return R.over(R.lensProp(dim), (values = {}) => ({
-        ...values,
-        [attr.id]: { ...attr, value },
-      }))(acc);
-    },
-    {},
-    attributes,
-  );
-  return R.reduce(
-    (acc, dim) => {
-      if (!dim.header) {
-        return acc;
-      }
-      const attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);
-      return R.append({ ...dim, attrValues }, acc);
-    },
-    [],
-    dimensions,
-  );
-};

package/src/rules2/src/getSeriesCombinations.js

@@ -1,24 +0,0 @@
-import * as R from 'ramda';
-
-export const getSeriesCombinations = (combinations, oneValuesDimensions) => {
-  const indexedValues =  R.reduce(
-    (acc, dim) => {
-      const value = R.head(dim.values);
-      return R.assoc(dim.id, value, acc);
-    },
-    {},
-    oneValuesDimensions
-  );
-
-  return R.reduce(
-    (acc, comb) => {
-      if (!R.prop('series', comb)) {
-        return acc;
-      }
-      const fixedDimValues = R.pick(comb.concepts, indexedValues);
-      return R.append({ ...comb, fixedDimValues }, acc);
-    },
-    [],
-    combinations
-  );
-};

package/src/rules2/src/hasCellMetadata.js

@@ -1,14 +0,0 @@
-import * as R from 'ramda';
-
-export const hasCellMetadata = (metadataCoordinates, cellCoordinates) => {
-  if (R.propOr('OBS_VALUE', 'OBS_ATTRIBUTES', cellCoordinates) !== 'OBS_VALUE') {
-    return false;
-  }
-  return R.pipe(
-    R.find(coordinates => {
-      const mergedCoord = R.mergeLeft(coordinates, cellCoordinates);
-      return !R.isEmpty(coordinates) && R.equals(mergedCoord, cellCoordinates);
-    }),
-    R.complement(R.isNil)
-  )(metadataCoordinates);
-};

package/src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy2.js

@@ -1,57 +0,0 @@
-import * as R from 'ramda';
-
-const uniq = R.pipe(
-  R.reduce(
-    ({ ids, list }, id) => {
-      if (R.has(id, list)) {
-        return ({ ids, list });
-      }
-      return ({ ids: R.append(id, ids), list: R.assoc(id, id, list) });
-    },
-    { ids: [], list: {} }
-  ),
-  R.prop('ids')
-);
-
-export const refinePartialHierarchy = (hier, indexed) => {
-  const { intact, broken } = R.pipe(
-    R.keys,
-    R.reduce(
-      ({ intact, broken }, key) => {
-        const ids = R.filter(id => R.has(id, indexed), hier[key]);
-        if (key === '#ROOT') {
-          return ({ broken, intact: R.assoc(key, ids, intact) });
-        }
-        const splitKey = R.split('.', key);
-        const filtered = R.takeLastWhile(id => R.has(id, indexed), splitKey);
-        if (R.length(filtered) === R.length(splitKey)) {
-          return ({ broken, intact: R.assoc(key, ids, intact) });
-        }
-        const refinedKey = R.isEmpty(filtered) ? '#ROOT' : R.join('.', filtered);
-        return ({
-          intact,
-          broken: R.over(R.lensProp(refinedKey), R.ifElse(R.isNil, R.always([ids]), R.append(ids)))(broken)
-        });
-      },
-      { intact: {}, broken: {} }
-    )
-  )(hier);
-  const intactIds = R.pipe(R.values, R.unnest)(intact);
-  const refinedBroken = R.pipe(
-    R.omit(intactIds),
-    R.over(
-      R.lensProp('#ROOT'),
-      R.pipe(
-        i => R.isNil(i) ? [] : i,
-        R.unnest,
-        R.reject(R.flip(R.includes)(intactIds)))
-      ),
-    R.map(R.pipe(R.unnest, uniq))
-  )(broken);
-
-  return ({
-    ...refinedBroken,
-    ...intact,
-    '#ROOT': R.concat(refinedBroken['#ROOT'], intact['#ROOT'])
-  })
-};

package/src/rules2/src/hierarchiseDimensionWithNativeHierarchy2.js

@@ -1,35 +0,0 @@
-import * as R from 'ramda';
-
-export const hierarchiseDimensionWithNativeHierarchy = (dimension) => {
-  const values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
-  const indexed = R.indexBy(R.prop('id'), values);
-  const grouped = R.groupBy(val => val.parent && R.has(val.parent, indexed) ? val.parent : '#ROOT', values);
-
-  let index = -1;
-  const getChildren = ({ parentsIndexes, parentId }) => {
-    const childs = R.propOr([], parentId, grouped);
-    return R.reduce(
-      (acc, child) => {
-        index = index + 1;
-        const refined = R.pipe(
-          R.assoc('__indexPosition', index),
-          R.assoc('parents', parentsIndexes),
-          R.assoc('parent', R.isEmpty(parentsIndexes) ? undefined : parentId),
-        )(child);
-        const children = getChildren({
-          parentsIndexes: R.propOr(false, 'isSelected', child)
-           ? R.append(index, parentsIndexes) : parentsIndexes,
-          parentId: child.id
-        });
-        return R.concat(acc, R.prepend(refined, children));
-      },
-      [],
-      childs
-    );
-  }
-
-  return R.set(
-    R.lensProp('values'),
-    getChildren({ parentsIndexes: [], parentId: '#ROOT' })
-  )(dimension);
-};

package/src/rules2/src/index.js

@@ -1,50 +0,0 @@
-export {
-  SDMX_3_0_JSON_DATA_FORMAT,
-  SDMX_3_0_CSV_DATA_FORMAT
-} from './constants';
-
-export { parseMetadataSeries } from './parseMetadataSeries';
-export { sdmx_3_0_DataFormatPatch } from './sdmx3.0DataFormatPatch';
-export { getDataflowTooltipAttributesIds } from './getDataflowTooltipAttributesIds';
-export { getMSDInformations } from './getMSDInformations';
-export { getNotDisplayedIds } from './getNotDisplayedIds';
-export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsInData';
-export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';
-export { getMetadataCoordinates } from './getMetadataCoordinates';
-export { duplicateObs } from './duplicateObservations';
-export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
-export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
-export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
-export { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
-export { refineDimensions } from './refineDimensions';
-export { parseAttributes } from './parseAttributes';
-export { parseCombinations } from './parseCombinations';
-export { refineAttributes } from './refineAttributes';
-export { enhanceObservations } from './enhanceObservations';
-export { getAttributesSeries } from './getAttributesSeries';
-export { getManyValuesDimensions } from './getManyValuesDimensions';
-export { getOneValueDimensions } from './getOneValueDimensions';
-export { getDataflowAttributes } from './getDataflowAttributes';
-export { getHeaderTitle } from './getHeaderTitle';
-export { getHeaderSubtitle } from './getHeaderSubtitle';
-export { getSeriesCombinations } from './getSeriesCombinations';
-export { getHeaderCombinations } from './getHeaderCombinations';
-export { getHeaderCoordinates } from './getHeaderCoordinates';
-export { getLayout } from './table/getLayout';
-export { getSortedLayoutIndexes } from './table/getSortedLayoutIndexes';
-export { refineLayoutSize } from './table/refineLayoutSize2';
-export { getFlagsAndNotes } from './table/getFlagsAndNotes';
-export { getLayoutData } from './table/getLayoutData2';
-export { getCellsAttributesIds } from './table/getCellsAttributesIds';
-export { getCellsMetadataCoordinates } from './table/getCellsMetadataCoordinates';
-export { getIndexedCombinationsByDisplay } from './table/getIndexedCombinationsByDisplay';
-export { getCells } from './table/getCells';
-export { getCuratedCells } from './table/getCuratedCells';
-export { prepareData } from './prepareData';
-export { getTableProps } from './table/getTableProps';
-export { getTableLabelAccessor } from './table/getTableLabelAccessor';
-export { parseValueHierarchy } from './table/parseValueHierarchy';
-export { parseLayoutIndexesHierarchies } from './table/parseSeriesIndexesHierarchies';
-export { getTableLayoutIds, injectCombinationsInLayout } from './table/getTableLayoutIds';
-export { declineObservationsOverAttributes } from './table/declineObservationsOverAttributes';
-export { applyHierarchicalCodesToDim } from './applyHierarchicalCodesToDim';

package/src/rules2/src/parseAttributes.js

@@ -1,41 +0,0 @@
-import * as R from 'ramda';
-import { REPORTING_YEAR_START_DAY, REPYEARSTART } from './constants';
-
-export const parseAttributes = (attributes, dimensions, customAttributes) => {
-  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
-  return R.addIndex(R.map)((attr, index) => {
-    let res = R.assoc('index', index, attr);
-    const displayableValuesCount = R.pipe(
-      R.filter(R.propOr(true, 'display')),
-      R.length,
-    )(attr);
-    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr)
-      || displayableValuesCount < 1 || attr.id === REPORTING_YEAR_START_DAY
-      || attr.id === REPYEARSTART) {
-      return R.assoc('display', false, res);
-    }
-    if (R.propEq('id', customAttributes.prefscale, attr)) {
-      return R.assoc('prefscale', true, res);
-    }
-    if (R.propEq('id', customAttributes.decimals, attr)) {
-      return R.assoc('decimals', true, res);
-    }
-    if (R.hasPath(['relationship', 'none'], attr) || R.hasPath(['relationship', 'dataflow'], attr)) {
-      return { ...res, header: true, relationship: [] };
-    }
-    if (R.hasPath(['relationship', 'primaryMeasure'], attr) || R.hasPath(['relationship', 'observation'], attr)) {
-      return { ...res, series: true, relationship: [] };
-    }
-    const seriesDimensions = R.pipe(
-      R.pathOr([], ['relationship', 'dimensions']),
-      R.filter(id => {
-        const dimension = R.prop(id, indexedDimensions);
-        return !dimension.header && R.length(dimension.values || []) > 1;
-      }),
-    )(attr);
-    if (R.length(seriesDimensions) > 0) {
-      return { ...res, series: true, relationship: seriesDimensions };
-    }
-    return { ...res, header: true, relationship: R.prop('dimensions', attr.relationship || []) };
-  }, attributes);
-};

package/src/rules2/src/parseCombinations.js

@@ -1,102 +0,0 @@
-import * as R from 'ramda';
-import { REJECTED_VALUE_IDS } from './constants';
-
-const getDisplayableValues = (values) =>
-  R.filter(
-    (val) =>
-      !R.includes(R.prop('id', val), REJECTED_VALUE_IDS) &&
-      R.propOr(true, 'display', val),
-    values,
-  );
-
-// invalid concepts:
-// - empty/null/undefined/!array values (so far)
-const hasInvalidValues = R.pipe(
-  R.prop('values'),
-  R.anyPass([R.isNil, R.complement(R.is(Array)), R.isEmpty]),
-);
-const isConceptInvalid = R.anyPass([hasInvalidValues /* add more... */]);
-const filterValidConcepts = R.reject(isConceptInvalid);
-// concepts is an array of ids... (misnamed!)
-const rejectInvalidConceptIds =
-  (concepts = []) =>
-  (combinations = []) => {
-    const validConceptIds = R.pluck('id', filterValidConcepts(concepts));
-    return R.reduce((acc, comb) => {
-      const refinedConcepts = R.intersection(validConceptIds, comb.concepts);
-      if (R.length(refinedConcepts) < 1) {
-        return acc;
-      }
-      return R.append({ ...comb, concepts: refinedConcepts }, acc);
-    }, [], combinations);
-  };
-
-export const parseCombinations = (
-  combinations,
-  parsedAttributes,
-  dimensions,
-) => {
-  const concepts = R.concat(dimensions, parsedAttributes);
-
-  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
-  const indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
-
-  return R.pipe(
-    rejectInvalidConceptIds(concepts),
-    R.reduce((acc, comb) => {
-      let relationship = [];
-      let ids = {};
-      let displayable_values_count = 0;
-      const seriesConcepts = R.filter((concept) => {
-        if (R.has(concept, ids)) {
-          return false;
-        }
-        if (R.has(concept, indexedDimensions)) {
-          const dimension = R.prop(concept, indexedDimensions);
-          relationship = !dimension.header
-            ? R.append(concept, relationship)
-            : relationship;
-          ids = { ...ids, [concept]: concept };
-          displayable_values_count += R.length(dimension.values || []);
-          return !dimension.header;
-        } else if (!R.has(concept, indexedAttributes)) {
-          return false;
-        }
-        const attribute = R.prop(concept, indexedAttributes);
-        const displayableValues = getDisplayableValues(attribute.values || []);
-        const isDisplayable =
-          R.length(displayableValues) !== 0 &&
-          R.propOr(true, 'display', attribute);
-        relationship =
-          attribute.series && isDisplayable
-            ? R.pipe(
-                R.reject((id) => R.has(id, ids)),
-                R.concat(relationship),
-              )(attribute.relationship)
-            : relationship;
-        ids = attribute.series  && isDisplayable
-          ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) }
-          : ids;
-        displayable_values_count = isDisplayable
-          ? displayable_values_count + R.length(displayableValues)
-          : displayable_values_count;
-        return attribute.series && isDisplayable;
-      }, comb.concepts);
-      if (R.isEmpty(seriesConcepts)) {
-        return R.append(
-          { ...comb, header: true, display: displayable_values_count > 0 },
-          acc,
-        );
-      }
-      return R.append(
-        {
-          ...comb,
-          series: true,
-          relationship,
-          display: displayable_values_count > 0,
-        },
-        acc,
-      );
-    }, []),
-  )(combinations);
-};

package/src/rules2/src/parseHierarchicalCodelist.js

@@ -1,48 +0,0 @@
-import * as R from 'ramda';
-
-export const parseHierarchicalCodelist = (sdmxJson, hierarchyId) => {
-  const hCodelist = R.pathOr({}, ['data', 'hierarchicalCodelists', 0], sdmxJson);
-  const hierarchy = R.find(R.propEq('id', hierarchyId), hCodelist.hierarchies || []);
-
-  const getParentedCodes = (codes, parent) => {
-    const ids = R.pluck('codeID', codes);
-
-    const siblings = R.reduce(
-      (acc, code) => {
-        if (R.isEmpty(code.hierarchicalCodes || [])) {
-          return acc;
-        }
-        return R.mergeRight(acc, getParentedCodes(code.hierarchicalCodes, code.id));
-      },
-      {},
-      codes
-    );
-
-    return ({ ...siblings, [parent]: ids });
-  };
-
-  const getChildren = (codes, parents) => {
-    const ids = R.pluck('codeID', codes);
-
-    const children = R.reduce(
-      (acc, code) => {
-        if (R.isEmpty(code.hierarchicalCodes || [])) {
-          return acc;
-        }
-        return ({
-          ...acc,
-          ...getChildren(code.hierarchicalCodes, R.append(code.codeID, parents))
-        });
-      },
-      {},
-      codes
-    );
-    const key = R.isEmpty(parents) ? '#ROOT' : R.join('.', parents);
-    return ({ ...children, [key]: ids });
-  }
-
-  return R.pipe(
-    R.propOr([], 'hierarchicalCodes'),
-    codes => getChildren(codes, []),
-  )(hierarchy);
-};