export function mergeFilters()

in src/reducers/vis-state-merger.js [44:133]
72 lines of code
10 McCabe index (conditional complexity)

export function mergeFilters(state, filtersToMerge) {
  const merged = [];
  const unmerged = [];
  const {datasets} = state;
  let updatedDatasets = datasets;

  if (!Array.isArray(filtersToMerge) || !filtersToMerge.length) {
    return state;
  }

  // merge filters
  filtersToMerge.forEach(filter => {
    // we can only look for datasets define in the filter dataId
    const datasetIds = toArray(filter.dataId);

    // we can merge a filter only if all datasets in filter.dataId are loaded
    if (datasetIds.every(d => datasets[d])) {
      // all datasetIds in filter must be present the state datasets
      const {filter: validatedFilter, applyToDatasets, augmentedDatasets} = datasetIds.reduce(
        (acc, datasetId) => {
          const dataset = updatedDatasets[datasetId];
          const layers = state.layers.filter(l => l.config.dataId === dataset.id);
          const {filter: updatedFilter, dataset: updatedDataset} = validateFilterWithData(
            acc.augmentedDatasets[datasetId] || dataset,
            filter,
            layers
          );

          if (updatedFilter) {
            return {
              ...acc,
              // merge filter props
              filter: acc.filter
                ? {
                    ...acc.filter,
                    ...mergeFilterDomainStep(acc, updatedFilter)
                  }
                : updatedFilter,

              applyToDatasets: [...acc.applyToDatasets, datasetId],

              augmentedDatasets: {
                ...acc.augmentedDatasets,
                [datasetId]: updatedDataset
              }
            };
          }

          return acc;
        },
        {
          filter: null,
          applyToDatasets: [],
          augmentedDatasets: {}
        }
      );

      if (validatedFilter && isEqual(datasetIds, applyToDatasets)) {
        merged.push(validatedFilter);
        updatedDatasets = {
          ...updatedDatasets,
          ...augmentedDatasets
        };
      }
    } else {
      unmerged.push(filter);
    }
  });

  // merge filter with existing
  let updatedFilters = [...(state.filters || []), ...merged];
  updatedFilters = resetFilterGpuMode(updatedFilters);
  updatedFilters = assignGpuChannels(updatedFilters);
  // filter data
  const datasetsToFilter = uniq(flattenDeep(merged.map(f => f.dataId)));

  const filtered = applyFiltersToDatasets(
    datasetsToFilter,
    updatedDatasets,
    updatedFilters,
    state.layers
  );

  return {
    ...state,
    filters: updatedFilters,
    datasets: filtered,
    filterToBeMerged: [...state.filterToBeMerged, ...unmerged]
  };
}