@kepler.gl/reducers 3.1.0-alpha.1 → 3.1.0-alpha.3

package/dist/vis-state-merger.js

@@ -0,0 +1,812 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VIS_STATE_MERGERS = void 0;
+exports.createLayerFromConfig = createLayerFromConfig;
+exports.insertLayerAtRightOrder = insertLayerAtRightOrder;
+exports.isSavedLayerConfigV1 = isSavedLayerConfigV1;
+exports.mergeAnimationConfig = mergeAnimationConfig;
+exports.mergeDatasetsByOrder = mergeDatasetsByOrder;
+exports.mergeEditor = mergeEditor;
+exports.mergeEffects = mergeEffects;
+exports.mergeFilters = mergeFilters;
+exports.mergeInteractionTooltipConfig = mergeInteractionTooltipConfig;
+exports.mergeInteractions = mergeInteractions;
+exports.mergeLayerBlending = mergeLayerBlending;
+exports.mergeLayers = mergeLayers;
+exports.mergeOverlayBlending = mergeOverlayBlending;
+exports.mergeSplitMaps = mergeSplitMaps;
+exports.parseLayerConfig = parseLayerConfig;
+exports.replaceFilterDatasetIds = replaceFilterDatasetIds;
+exports.serializeEffect = serializeEffect;
+exports.serializeLayer = serializeLayer;
+exports.serializeVisState = serializeVisState;
+exports.validateColumn = validateColumn;
+exports.validateLayerWithData = validateLayerWithData;
+exports.validateLayersByDatasets = validateLayersByDatasets;
+exports.validateSavedLayerColumns = validateSavedLayerColumns;
+exports.validateSavedTextLabel = validateSavedTextLabel;
+exports.validateSavedVisualChannels = validateSavedVisualChannels;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _lodash = _interopRequireDefault(require("lodash.uniq"));
+var _lodash2 = _interopRequireDefault(require("lodash.pick"));
+var _lodash3 = _interopRequireDefault(require("lodash.flattendeep"));
+var _deepmerge = _interopRequireDefault(require("deepmerge"));
+var _utils = require("@kepler.gl/utils");
+var _effects = require("@kepler.gl/effects");
+var _constants = require("@kepler.gl/constants");
+var _schemas = require("@kepler.gl/schemas");
+var _table = require("@kepler.gl/table");
+var _layerUtils = require("./layer-utils");
+var _excluded = ["enabled"];
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+/**
+ * Merge loaded filters with current state, if no fields or data are loaded
+ * save it for later
+ *
+ */
+function mergeFilters(state, filtersToMerge, fromConfig) {
+  var preserveFilterOrder = fromConfig ? filtersToMerge === null || filtersToMerge === void 0 ? void 0 : filtersToMerge.map(function (l) {
+    return l.id;
+  }) : state.preserveFilterOrder;
+  if (!Array.isArray(filtersToMerge) || !filtersToMerge.length) {
+    return state;
+  }
+  var _validateFiltersUpdat = (0, _utils.validateFiltersUpdateDatasets)(state, filtersToMerge),
+    validated = _validateFiltersUpdat.validated,
+    failed = _validateFiltersUpdat.failed,
+    updatedDatasets = _validateFiltersUpdat.updatedDatasets;
+  var updatedFilters = insertItemBasedOnPreservedOrder(state.filters, validated, preserveFilterOrder);
+
+  // merge filter with existing
+  updatedFilters = (0, _table.resetFilterGpuMode)(updatedFilters);
+  updatedFilters = (0, _table.assignGpuChannels)(updatedFilters);
+  // filter data
+  var datasetsToFilter = (0, _lodash["default"])((0, _lodash3["default"])(validated.map(function (f) {
+    return f.dataId;
+  })));
+  var filtered = (0, _utils.applyFiltersToDatasets)(datasetsToFilter, updatedDatasets, updatedFilters, state.layers);
+  return _objectSpread(_objectSpread({}, state), {}, {
+    filters: updatedFilters,
+    datasets: filtered,
+    preserveFilterOrder: preserveFilterOrder,
+    filterToBeMerged: [].concat((0, _toConsumableArray2["default"])(state.filterToBeMerged), (0, _toConsumableArray2["default"])(failed))
+  });
+}
+
+// replace dataId in saved Filter
+function replaceFilterDatasetIds(savedFilter, dataId, dataIdToUse) {
+  var replaced = [];
+  savedFilter.forEach(function (filter) {
+    if (filter.dataId.includes(dataId)) {
+      var newDataId = filter.dataId.map(function (d) {
+        return d === dataId ? dataIdToUse : d;
+      });
+      replaced.push(_objectSpread(_objectSpread({}, filter), {}, {
+        dataId: newDataId
+      }));
+    }
+  });
+  return replaced.length ? replaced : null;
+}
+function isSavedLayerConfigV1(layerConfig) {
+  // exported layer configuration contains visualChannels property
+  return layerConfig === null || layerConfig === void 0 ? void 0 : layerConfig.visualChannels;
+}
+function parseLayerConfig(schema, layerConfig) {
+  var _schema$parseSavedCon;
+  // assume the layer config is current version
+  var savedConfig = {
+    version: _schemas.CURRENT_VERSION,
+    config: {
+      visState: {
+        layers: [layerConfig],
+        layerOrder: [layerConfig.id]
+      }
+    }
+  };
+  return (_schema$parseSavedCon = schema.parseSavedConfig(savedConfig)) === null || _schema$parseSavedCon === void 0 || (_schema$parseSavedCon = _schema$parseSavedCon.visState) === null || _schema$parseSavedCon === void 0 || (_schema$parseSavedCon = _schema$parseSavedCon.layers) === null || _schema$parseSavedCon === void 0 ? void 0 : _schema$parseSavedCon[0];
+}
+function insertItemBasedOnPreservedOrder(currentItems, items) {
+  var preservedOrder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var defaultStart = arguments.length > 3 ? arguments[3] : undefined;
+  var newItems = (0, _toConsumableArray2["default"])(currentItems);
+  var _iterator = _createForOfIteratorHelper(items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var expectedIdx = preservedOrder.indexOf(item.id);
+      // insertAt the end by default
+      var insertAt = defaultStart ? 0 : newItems.length;
+      if (expectedIdx > 0) {
+        // look for layer to insert after
+        var i = expectedIdx + 1;
+        var preceedIdx = -1;
+        var _loop = function _loop() {
+          // keep looking for preceed layer that is already loaded
+          var preceedItemId = preservedOrder[i - 1];
+          preceedIdx = newItems.findIndex(function (d) {
+            return d.id === preceedItemId;
+          });
+        };
+        while (i-- > 0 && preceedIdx < 0) {
+          _loop();
+        }
+        if (preceedIdx > -1) {
+          // if found
+          insertAt = preceedIdx + 1;
+        }
+      }
+      newItems = (0, _utils.arrayInsert)(newItems, insertAt, item);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return newItems;
+}
+function createLayerFromConfig(state, layerConfig) {
+  // check if the layer config is parsed
+  var parsedLayerConfig = isSavedLayerConfigV1(layerConfig) ? parseLayerConfig(state.schema, layerConfig) : layerConfig;
+  if (!parsedLayerConfig) {
+    return null;
+  }
+  // first validate config against dataset
+  var _validateLayersByData = validateLayersByDatasets(state.datasets, state.layerClasses, [parsedLayerConfig], {
+      allowEmptyColumn: true
+    }),
+    validated = _validateLayersByData.validated,
+    failed = _validateLayersByData.failed;
+  if (failed !== null && failed !== void 0 && failed.length || !validated.length) {
+    // failed
+    return null;
+  }
+  var newLayer = validated[0];
+  newLayer.updateLayerDomain(state.datasets);
+  return newLayer;
+}
+
+/**
+ * Get loaded layer from state
+ */
+function serializeLayer(newLayer, schema) {
+  var _serializedVisState$l;
+  var serializedVisState = serializeVisState({
+    layers: [newLayer],
+    layerOrder: [newLayer.id]
+  }, schema);
+  return serializedVisState === null || serializedVisState === void 0 || (_serializedVisState$l = serializedVisState.layers) === null || _serializedVisState$l === void 0 ? void 0 : _serializedVisState$l[0];
+}
+
+/**
+ * Get loaded effect from state
+ */
+function serializeEffect(newEffect, schema) {
+  var _serializedVisState$e;
+  var serializedVisState = serializeVisState({
+    effects: [newEffect],
+    effectOrder: [newEffect.id]
+  }, schema);
+  return serializedVisState === null || serializedVisState === void 0 || (_serializedVisState$e = serializedVisState.effects) === null || _serializedVisState$e === void 0 ? void 0 : _serializedVisState$e[0];
+}
+
+/**
+ * Get vis state config
+ */
+function serializeVisState(visState, schema) {
+  var _schema$parseSavedCon2;
+  var savedState = schema.getConfigToSave({
+    visState: visState
+  });
+  return savedState ? (_schema$parseSavedCon2 = schema.parseSavedConfig(savedState)) === null || _schema$parseSavedCon2 === void 0 ? void 0 : _schema$parseSavedCon2.visState : undefined;
+}
+/**
+ * Merge layers from de-serialized state, if no fields or data are loaded
+ * save it for later
+ *
+ */
+function mergeLayers(state) {
+  var layersToMerge = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var fromConfig = arguments.length > 2 ? arguments[2] : undefined;
+  var preserveLayerOrder = fromConfig ? (0, _layerUtils.getLayerOrderFromLayers)(layersToMerge) : state.preserveLayerOrder;
+  if (!Array.isArray(layersToMerge) || !layersToMerge.length) {
+    return state;
+  }
+  // don't merge layer if dataset is being merged
+  var unmerged = [];
+  var toMerge = [];
+  layersToMerge.forEach(function (l) {
+    var _l$config;
+    if (l !== null && l !== void 0 && (_l$config = l.config) !== null && _l$config !== void 0 && _l$config.dataId && state.isMergingDatasets[l.config.dataId]) {
+      unmerged.push(l);
+    } else {
+      toMerge.push(l);
+    }
+  });
+  var _validateLayersByData2 = validateLayersByDatasets(state.datasets, state.layerClasses, toMerge),
+    mergedLayer = _validateLayersByData2.validated,
+    failed = _validateLayersByData2.failed;
+  unmerged.push.apply(unmerged, (0, _toConsumableArray2["default"])(failed));
+  // put new layers in front of current layers
+  var _insertLayerAtRightOr = insertLayerAtRightOrder(state.layers, mergedLayer, state.layerOrder, preserveLayerOrder),
+    newLayerOrder = _insertLayerAtRightOr.newLayerOrder,
+    newLayers = _insertLayerAtRightOr.newLayers;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    layers: newLayers,
+    layerOrder: newLayerOrder,
+    preserveLayerOrder: preserveLayerOrder,
+    layerToBeMerged: [].concat((0, _toConsumableArray2["default"])(state.layerToBeMerged), unmerged)
+  });
+}
+function insertLayerAtRightOrder(currentLayers, layersToInsert, currentOrder) {
+  var preservedOrder = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  if (!(layersToInsert !== null && layersToInsert !== void 0 && layersToInsert.length)) {
+    return {
+      newLayers: currentLayers,
+      newLayerOrder: currentOrder
+    };
+  }
+  // perservedOrder ['a', 'b', 'c'];
+  // layerOrder ['a', 'b', 'c']
+  var currentLayerQueue = currentOrder.map(function (id) {
+    return (0, _utils.findById)(id)(currentLayers);
+  }).filter(function (layer) {
+    return Boolean(layer);
+  });
+  var newLayers = currentLayers.concat(layersToInsert);
+  var newLayerOrderQueue = insertItemBasedOnPreservedOrder(currentLayerQueue, layersToInsert, preservedOrder, true);
+
+  // reconstruct layerOrder after insert
+  var newLayerOrder = (0, _layerUtils.getLayerOrderFromLayers)(newLayerOrderQueue);
+  return {
+    newLayerOrder: newLayerOrder,
+    newLayers: newLayers
+  };
+}
+
+/**
+ * Merge interactions with saved config
+ *
+ */
+function mergeInteractions(state, interactionToBeMerged) {
+  var merged = {};
+  var unmerged = {};
+  if (interactionToBeMerged) {
+    Object.keys(interactionToBeMerged).forEach(function (key) {
+      if (!state.interactionConfig[key]) {
+        return;
+      }
+      var currentConfig = key === 'tooltip' || key === 'brush' ? state.interactionConfig[key].config : null;
+      var _ref = interactionToBeMerged[key] || {},
+        enabled = _ref.enabled,
+        configSaved = (0, _objectWithoutProperties2["default"])(_ref, _excluded);
+      var configToMerge = configSaved;
+      if (key === 'tooltip') {
+        var _mergeInteractionTool = mergeInteractionTooltipConfig(state, configSaved),
+          mergedTooltip = _mergeInteractionTool.mergedTooltip,
+          unmergedTooltip = _mergeInteractionTool.unmergedTooltip;
+
+        // merge new dataset tooltips with original dataset tooltips
+        configToMerge = {
+          fieldsToShow: _objectSpread(_objectSpread({}, currentConfig.fieldsToShow), mergedTooltip)
+        };
+        if (Object.keys(unmergedTooltip).length) {
+          // @ts-expect-error
+          unmerged.tooltip = {
+            fieldsToShow: unmergedTooltip,
+            enabled: Boolean(enabled)
+          };
+        }
+      }
+      merged[key] = _objectSpread(_objectSpread({}, state.interactionConfig[key]), {}, {
+        enabled: Boolean(enabled)
+      }, currentConfig ? {
+        config: (0, _lodash2["default"])(_objectSpread(_objectSpread({}, currentConfig), configToMerge), Object.keys(currentConfig))
+      } : {});
+    });
+  }
+  var nextState = _objectSpread(_objectSpread({}, state), {}, {
+    interactionConfig: _objectSpread(_objectSpread({}, state.interactionConfig), merged),
+    interactionToBeMerged: savedUnmergedInteraction(state, unmerged)
+  });
+  return nextState;
+}
+function savedUnmergedInteraction(state, unmerged) {
+  var _unmerged$tooltip, _unmerged$tooltip2, _state$interactionToB, _unmerged$tooltip3;
+  if (!(unmerged !== null && unmerged !== void 0 && (_unmerged$tooltip = unmerged.tooltip) !== null && _unmerged$tooltip !== void 0 && _unmerged$tooltip.fieldsToShow)) {
+    return state.interactionToBeMerged;
+  }
+  return {
+    tooltip: _objectSpread(_objectSpread(_objectSpread({}, state.interactionToBeMerged.tooltip), typeof (unmerged === null || unmerged === void 0 || (_unmerged$tooltip2 = unmerged.tooltip) === null || _unmerged$tooltip2 === void 0 ? void 0 : _unmerged$tooltip2.enabled) === 'boolean' ? {
+      enabled: unmerged.tooltip.enabled
+    } : {}), {}, {
+      fieldsToShow: _objectSpread(_objectSpread({}, (_state$interactionToB = state.interactionToBeMerged) === null || _state$interactionToB === void 0 || (_state$interactionToB = _state$interactionToB.tooltip) === null || _state$interactionToB === void 0 ? void 0 : _state$interactionToB.fieldsToShow), unmerged === null || unmerged === void 0 || (_unmerged$tooltip3 = unmerged.tooltip) === null || _unmerged$tooltip3 === void 0 ? void 0 : _unmerged$tooltip3.fieldsToShow)
+    })
+  };
+}
+function replaceInteractionDatasetIds(interactionConfig, dataId, dataIdToReplace) {
+  var _interactionConfig$to;
+  if (interactionConfig !== null && interactionConfig !== void 0 && (_interactionConfig$to = interactionConfig.tooltip) !== null && _interactionConfig$to !== void 0 && _interactionConfig$to.fieldsToShow[dataId]) {
+    var _interactionConfig$to2;
+    return _objectSpread(_objectSpread({}, interactionConfig), {}, {
+      tooltip: _objectSpread(_objectSpread({}, interactionConfig.tooltip), {}, {
+        fieldsToShow: (0, _defineProperty2["default"])({}, dataIdToReplace, interactionConfig === null || interactionConfig === void 0 || (_interactionConfig$to2 = interactionConfig.tooltip) === null || _interactionConfig$to2 === void 0 ? void 0 : _interactionConfig$to2.fieldsToShow[dataId])
+      })
+    });
+  }
+  return null;
+}
+/**
+ * Merge splitMaps config with current visStete.
+ * 1. if current map is split, but splitMap DOESNOT contain maps
+ *    : don't merge anything
+ * 2. if current map is NOT split, but splitMaps contain maps
+ *    : add to splitMaps, and add current layers to splitMaps
+ */
+function mergeSplitMaps(state) {
+  var splitMaps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var merged = (0, _toConsumableArray2["default"])(state.splitMaps);
+  var unmerged = [];
+  splitMaps.forEach(function (sm, i) {
+    var entries = Object.entries(sm.layers);
+    if (entries.length > 0) {
+      entries.forEach(function (_ref2) {
+        var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
+          id = _ref3[0],
+          value = _ref3[1];
+        // check if layer exists
+        var pushTo = state.layers.find(function (l) {
+          return l.id === id;
+        }) ? merged : unmerged;
+
+        // create map panel if current map is not split
+        pushTo[i] = pushTo[i] || _objectSpread(_objectSpread({}, sm), {}, {
+          layers: pushTo === merged ? (0, _utils.getInitialMapLayersForSplitMap)(state.layers) : []
+        });
+        pushTo[i].layers = _objectSpread(_objectSpread({}, pushTo[i].layers), {}, (0, _defineProperty2["default"])({}, id, value));
+      });
+    } else {
+      // We are merging if there are no layers in both split map
+      merged.push(sm);
+    }
+  });
+  return _objectSpread(_objectSpread({}, state), {}, {
+    splitMaps: merged,
+    splitMapsToBeMerged: [].concat((0, _toConsumableArray2["default"])(state.splitMapsToBeMerged), unmerged)
+  });
+}
+
+/**
+ * Merge effects with saved config
+ */
+function mergeEffects(state, effects, fromConfig) {
+  var newEffects = [].concat((0, _toConsumableArray2["default"])(state.effects), (0, _toConsumableArray2["default"])((effects || []).map(function (effect) {
+    return fromConfig ? (0, _effects.createEffect)(_deepmerge["default"].all([effect, {
+      // collapse all panels when loading effects
+      isConfigActive: false
+    }])) : effect;
+  }).filter(function (effect) {
+    return Boolean(effect && effect.isValidToSave());
+  })));
+  return _objectSpread(_objectSpread({}, state), {}, {
+    effects: newEffects,
+    effectOrder: newEffects.map(function (effect) {
+      return effect.id;
+    })
+  });
+}
+
+/**
+ * Merge interactionConfig.tooltip with saved config,
+ * validate fieldsToShow
+ *
+ * @param state
+ * @param tooltipConfig
+ * @return - {mergedTooltip: {}, unmergedTooltip: {}}
+ */
+function mergeInteractionTooltipConfig(state) {
+  var tooltipConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var unmergedTooltip = {};
+  var mergedTooltip = {};
+  if (!tooltipConfig || !tooltipConfig.fieldsToShow || !Object.keys(tooltipConfig.fieldsToShow).length) {
+    return {
+      mergedTooltip: mergedTooltip,
+      unmergedTooltip: unmergedTooltip
+    };
+  }
+  var _loop2 = function _loop2() {
+    if (!state.datasets[dataId] || state.isMergingDatasets[dataId]) {
+      // is not yet loaded
+      unmergedTooltip[dataId] = tooltipConfig.fieldsToShow[dataId];
+    } else {
+      // if dataset is loaded
+      var allFields = state.datasets[dataId].fields.map(function (d) {
+        return d.name;
+      });
+      var foundFieldsToShow = tooltipConfig.fieldsToShow[dataId].filter(function (field) {
+        return allFields.includes(field.name);
+      });
+      mergedTooltip[dataId] = foundFieldsToShow;
+    }
+  };
+  for (var dataId in tooltipConfig.fieldsToShow) {
+    _loop2();
+  }
+  return {
+    mergedTooltip: mergedTooltip,
+    unmergedTooltip: unmergedTooltip
+  };
+}
+/**
+ * Merge layerBlending with saved
+ *
+ */
+function mergeLayerBlending(state, layerBlending) {
+  if (layerBlending && _constants.LAYER_BLENDINGS[layerBlending]) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      layerBlending: layerBlending
+    });
+  }
+  return state;
+}
+
+/**
+ * Merge overlayBlending with saved
+ */
+function mergeOverlayBlending(state, overlayBlending) {
+  if (overlayBlending && _constants.OVERLAY_BLENDINGS[overlayBlending]) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      overlayBlending: overlayBlending
+    });
+  }
+  return state;
+}
+
+/**
+ * Merge animation config
+ */
+function mergeAnimationConfig(state, animation) {
+  if (animation && animation.currentTime) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      animationConfig: _objectSpread(_objectSpread(_objectSpread({}, state.animationConfig), animation), {}, {
+        domain: null
+      })
+    });
+  }
+  return state;
+}
+
+/**
+ * Validate saved layer columns with new data,
+ * update fieldIdx based on new fields
+ *
+ * @param fields
+ * @param savedCols
+ * @param emptyCols
+ * @param options
+ * @return - validated columns or null
+ */
+
+function validateSavedLayerColumns(fields) {
+  var savedCols = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var emptyCols = arguments.length > 2 ? arguments[2] : undefined;
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  // Prepare columns for the validator
+  var columns = {};
+  var _loop3 = function _loop3() {
+    var key = _Object$keys[_i];
+    columns[key] = _objectSpread({}, emptyCols[key]);
+    var saved = savedCols[key];
+    if (saved) {
+      var fieldIdx = fields.findIndex(function (_ref4) {
+        var name = _ref4.name;
+        return name === saved;
+      });
+      if (fieldIdx > -1) {
+        // update found columns
+        columns[key].fieldIdx = fieldIdx;
+        columns[key].value = saved;
+      }
+    }
+  };
+  for (var _i = 0, _Object$keys = Object.keys(emptyCols); _i < _Object$keys.length; _i++) {
+    _loop3();
+  }
+
+  // find actual column fieldIdx, in case it has changed
+  var allColFound = Object.keys(columns).every(function (key) {
+    return validateColumn(columns[key], columns, fields);
+  });
+  var rv = allColFound ? columns : null;
+  if (options.throwOnError) {
+    var requiredColumns = Object.keys(emptyCols).filter(function (k) {
+      return !emptyCols[k].optional;
+    });
+    var missingColumns = requiredColumns.filter(function (k) {
+      return !(columns !== null && columns !== void 0 && columns[k].value);
+    });
+    if (missingColumns.length) {
+      throw new Error("Layer has missing or invalid columns: ".concat(missingColumns.join(', ')));
+    }
+    var configColumns = Object.keys(savedCols);
+    var invalidColumns = configColumns.filter(function (k) {
+      var _columns$k;
+      return !(columns !== null && columns !== void 0 && (_columns$k = columns[k]) !== null && _columns$k !== void 0 && _columns$k.value);
+    });
+    if (invalidColumns.length) {
+      throw new Error("Layer has invalid columns: ".concat(invalidColumns.join(', ')));
+    }
+  }
+  return rv;
+}
+
+/**
+ * Validate layer column
+ */
+function validateColumn(column, columns, allFields) {
+  if (column.optional || column.value) {
+    return true;
+  }
+  if (column.validator) {
+    return column.validator(column, columns, allFields);
+  }
+  return false;
+}
+
+/**
+ * Validate saved text label config with new data
+ * refer to vis-state-schema.js TextLabelSchemaV1
+ *
+ * @param {Array<Object>} fields
+ * @param {Object} savedTextLabel
+ * @param {Object} options
+ * @return {Object} - validated textlabel
+ */
+function validateSavedTextLabel(fields, _ref5, savedTextLabel) {
+  var _ref6 = (0, _slicedToArray2["default"])(_ref5, 1),
+    layerTextLabel = _ref6[0];
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var savedTextLabels = Array.isArray(savedTextLabel) ? savedTextLabel : [savedTextLabel];
+
+  // validate field
+  return savedTextLabels.map(function (textLabel) {
+    var field = textLabel.field ? fields.find(function (fd) {
+      return Object.keys(textLabel.field).every(function (key) {
+        return textLabel.field[key] === fd[key];
+      });
+    }) : null;
+    if (field === undefined && options.throwOnError) {
+      throw new Error("Layer has invalid text label field: ".concat(JSON.stringify(textLabel.field)));
+    }
+    return Object.keys(layerTextLabel).reduce(function (accu, key) {
+      return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, key, key === 'field' ? field : textLabel[key] || layerTextLabel[key]));
+    }, {});
+  });
+}
+
+/**
+ * Validate saved visual channels config with new data,
+ * refer to vis-state-schema.js VisualChannelSchemaV1
+ */
+function validateSavedVisualChannels(fields, newLayer, savedLayer) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  Object.values(newLayer.visualChannels).forEach(function (_ref7) {
+    var field = _ref7.field,
+      scale = _ref7.scale,
+      key = _ref7.key;
+    var foundField;
+    if (savedLayer.config) {
+      if (savedLayer.config[field]) {
+        foundField = fields.find(function (fd) {
+          return savedLayer.config && fd.name === savedLayer.config[field].name;
+        });
+      }
+      var foundChannel = _objectSpread(_objectSpread({}, foundField ? (0, _defineProperty2["default"])({}, field, foundField) : {}), savedLayer.config[scale] ? (0, _defineProperty2["default"])({}, scale, savedLayer.config[scale]) : {});
+      if (Object.keys(foundChannel).length) {
+        newLayer.updateLayerConfig(foundChannel);
+      }
+      newLayer.validateVisualChannel(key);
+      if (options.throwOnError) {
+        var _savedLayer$config, _newLayer$config$fiel;
+        var fieldName = (_savedLayer$config = savedLayer.config) === null || _savedLayer$config === void 0 || (_savedLayer$config = _savedLayer$config[field]) === null || _savedLayer$config === void 0 ? void 0 : _savedLayer$config.name;
+        if (fieldName && fieldName !== ((_newLayer$config$fiel = newLayer.config[field]) === null || _newLayer$config$fiel === void 0 ? void 0 : _newLayer$config$fiel.name)) {
+          throw new Error("Layer has invalid visual channel field: ".concat(field));
+        }
+      }
+    }
+  });
+  return newLayer;
+}
+function validateLayersByDatasets(datasets, layerClasses) {
+  var layers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var options = arguments.length > 3 ? arguments[3] : undefined;
+  var validated = [];
+  var failed = [];
+  layers.forEach(function (layer) {
+    var _layer$config;
+    var validateLayer = null;
+    if (layer !== null && layer !== void 0 && (_layer$config = layer.config) !== null && _layer$config !== void 0 && _layer$config.dataId) {
+      if (datasets[layer.config.dataId]) {
+        // datasets are already loaded
+        validateLayer = validateLayerWithData(datasets[layer.config.dataId], layer, layerClasses, options);
+      }
+    }
+    if (validateLayer) {
+      validated.push(validateLayer);
+    } else {
+      // datasets not yet loaded
+      failed.push(layer);
+    }
+  });
+  return {
+    validated: validated,
+    failed: failed
+  };
+}
+
+/**
+ * Get required columns for validation based on column mode
+ */
+function _getColumnConfigForValidation(newLayer) {
+  // find column fieldIdx
+  var columnConfig = newLayer.getLayerColumns();
+  // if columnMode is defined, find column mode config
+  var colModeConfig = newLayer.config.columnMode ? (newLayer.supportedColumnModes || []).find(function (colMode) {
+    return colMode.key === newLayer.config.columnMode;
+  }) : null;
+  if (colModeConfig) {
+    // only validate columns in column mode
+    columnConfig = [].concat((0, _toConsumableArray2["default"])(colModeConfig.requiredColumns || []), (0, _toConsumableArray2["default"])(colModeConfig.optionalColumns || [])).reduce(function (accu, key) {
+      return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, key, columnConfig[key]));
+    }, {});
+  }
+  return columnConfig;
+}
+
+/**
+ * Validate saved layer config with new data,
+ * update fieldIdx based on new fields
+ */
+// eslint-disable-next-line complexity
+function validateLayerWithData(dataset, savedLayer, layerClasses) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var fields = dataset.fields,
+    dataId = dataset.id;
+  var type = savedLayer.type;
+  var throwOnError = options.throwOnError;
+  // layer doesnt have a valid type
+  if (!type || !Object.prototype.hasOwnProperty.call(layerClasses, type) || !savedLayer.config) {
+    if (throwOnError) {
+      throw new Error("Layer has invalid type \"".concat(type, "\" or config is missing"));
+    }
+    return null;
+  }
+  var newLayer = new layerClasses[type]({
+    id: savedLayer.id,
+    dataId: dataId,
+    label: savedLayer.config.label,
+    color: savedLayer.config.color,
+    isVisible: savedLayer.config.isVisible,
+    hidden: savedLayer.config.hidden,
+    columnMode: savedLayer.config.columnMode,
+    highlightColor: savedLayer.config.highlightColor
+  });
+  var columnConfig = _getColumnConfigForValidation(newLayer);
+  if (Object.keys(columnConfig)) {
+    var columns = validateSavedLayerColumns(fields, savedLayer.config.columns, columnConfig, options);
+    if (columns) {
+      newLayer.updateLayerConfig({
+        columns: _objectSpread(_objectSpread({}, newLayer.config.columns), columns)
+      });
+    } else if (!options.allowEmptyColumn) {
+      return null;
+    }
+  }
+  var textLabel = savedLayer.config.textLabel && newLayer.config.textLabel ? validateSavedTextLabel(fields, newLayer.config.textLabel, savedLayer.config.textLabel, options) : newLayer.config.textLabel;
+
+  // copy visConfig over to emptyLayer to make sure it has all the props
+  var copiedVisConfig = newLayer.copyLayerConfig(newLayer.config.visConfig, savedLayer.config.visConfig || {}, {
+    shallowCopy: ['colorRange', 'strokeColorRange']
+  });
+
+  // call layer methods to validate visConfig when switching dataset
+  var visConfig = newLayer.validateVisConfig ? newLayer.validateVisConfig(dataset, copiedVisConfig) : copiedVisConfig;
+  newLayer.updateLayerConfig({
+    visConfig: visConfig,
+    textLabel: textLabel
+  });
+
+  // visual channel field is saved to be {name, type}
+  // find visual channel field by matching both name and type
+  // refer to vis-state-schema.js VisualChannelSchemaV1
+  newLayer = validateSavedVisualChannels(fields, newLayer, savedLayer, options);
+  if (throwOnError) {
+    if (!newLayer.isValidToSave()) {
+      throw new Error("Layer is not valid to save: ".concat(newLayer.id));
+    }
+  }
+  return newLayer;
+}
+function mergeEditor(state, savedEditor) {
+  var _savedEditor$visible;
+  if (!savedEditor) {
+    return state;
+  }
+  return _objectSpread(_objectSpread({}, state), {}, {
+    editor: _objectSpread(_objectSpread({}, state.editor), {}, {
+      features: [].concat((0, _toConsumableArray2["default"])(state.editor.features), (0, _toConsumableArray2["default"])(savedEditor.features || [])),
+      // if savedEditor.visible is undefined keep state.editor.visible
+      visible: (_savedEditor$visible = savedEditor.visible) !== null && _savedEditor$visible !== void 0 ? _savedEditor$visible : state.editor.visible
+    })
+  });
+}
+
+/**
+ * Validate saved layer config with new data,
+ * update fieldIdx based on new fields
+ */
+function mergeDatasetsByOrder(state, newDataEntries) {
+  var merged = _objectSpread(_objectSpread({}, state.datasets), newDataEntries);
+  if (Array.isArray(state.preserveDatasetOrder)) {
+    // preserveDatasetOrder  might not include the  new datasets
+    var newDatasetIds = Object.keys(merged).filter(function (id) {
+      var _state$preserveDatase;
+      return !((_state$preserveDatase = state.preserveDatasetOrder) !== null && _state$preserveDatase !== void 0 && _state$preserveDatase.includes(id));
+    });
+    return [].concat((0, _toConsumableArray2["default"])(state.preserveDatasetOrder), (0, _toConsumableArray2["default"])(newDatasetIds)).reduce(function (accu, dataId) {
+      return _objectSpread(_objectSpread({}, accu), merged[dataId] ? (0, _defineProperty2["default"])({}, dataId, merged[dataId]) : {});
+    }, {});
+  }
+  return merged;
+}
+var VIS_STATE_MERGERS = exports.VIS_STATE_MERGERS = [{
+  merge: mergeLayers,
+  prop: 'layers',
+  toMergeProp: 'layerToBeMerged',
+  preserveOrder: 'preserveLayerOrder'
+}, {
+  merge: mergeFilters,
+  prop: 'filters',
+  toMergeProp: 'filterToBeMerged',
+  preserveOrder: 'preserveFilterOrder',
+  replaceParentDatasetIds: replaceFilterDatasetIds
+}, {
+  merge: mergeEffects,
+  prop: 'effects'
+}, {
+  merge: mergeInteractions,
+  prop: 'interactionConfig',
+  toMergeProp: 'interactionToBeMerged',
+  replaceParentDatasetIds: replaceInteractionDatasetIds,
+  saveUnmerged: savedUnmergedInteraction
+}, {
+  merge: mergeLayerBlending,
+  prop: 'layerBlending'
+}, {
+  merge: mergeOverlayBlending,
+  prop: 'overlayBlending'
+}, {
+  merge: mergeSplitMaps,
+  prop: 'splitMaps',
+  toMergeProp: 'splitMapsToBeMerged'
+}, {
+  merge: mergeAnimationConfig,
+  prop: 'animationConfig'
+}, {
+  merge: mergeEditor,
+  prop: 'editor'
+}];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_lodash2","_lodash3","_deepmerge","_utils","_effects","_constants","_schemas","_table","_layerUtils","_excluded","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","ownKeys","Object","keys","getOwnPropertySymbols","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","mergeFilters","state","filtersToMerge","fromConfig","preserveFilterOrder","map","l","id","_validateFiltersUpdat","validateFiltersUpdateDatasets","validated","failed","updatedDatasets","updatedFilters","insertItemBasedOnPreservedOrder","filters","resetFilterGpuMode","assignGpuChannels","datasetsToFilter","uniq","flattenDeep","dataId","filtered","applyFiltersToDatasets","layers","datasets","filterToBeMerged","concat","_toConsumableArray2","replaceFilterDatasetIds","savedFilter","dataIdToUse","replaced","includes","newDataId","d","isSavedLayerConfigV1","layerConfig","visualChannels","parseLayerConfig","schema","_schema$parseSavedCon","savedConfig","version","CURRENT_VERSION","config","visState","layerOrder","parseSavedConfig","currentItems","items","preservedOrder","undefined","defaultStart","newItems","_iterator","_step","item","expectedIdx","indexOf","insertAt","i","preceedIdx","_loop","preceedItemId","findIndex","arrayInsert","err","createLayerFromConfig","parsedLayerConfig","_validateLayersByData","validateLayersByDatasets","layerClasses","allowEmptyColumn","newLayer","updateLayerDomain","serializeLayer","_serializedVisState$l","serializedVisState","serializeVisState","serializeEffect","newEffect","_serializedVisState$e","effects","effectOrder","_schema$parseSavedCon2","savedState","getConfigToSave","mergeLayers","layersToMerge","preserveLayerOrder","getLayerOrderFromLayers","unmerged","toMerge","_l$config","isMergingDatasets","_validateLayersByData2","mergedLayer","_insertLayerAtRightOr","insertLayerAtRightOrder","newLayerOrder","newLayers","layerToBeMerged","currentLayers","layersToInsert","currentOrder","currentLayerQueue","findById","layer","Boolean","newLayerOrderQueue","mergeInteractions","interactionToBeMerged","merged","key","interactionConfig","currentConfig","_ref","enabled","configSaved","_objectWithoutProperties2","configToMerge","_mergeInteractionTool","mergeInteractionTooltipConfig","mergedTooltip","unmergedTooltip","fieldsToShow","tooltip","pick","nextState","savedUnmergedInteraction","_unmerged$tooltip","_unmerged$tooltip2","_state$interactionToB","_unmerged$tooltip3","replaceInteractionDatasetIds","dataIdToReplace","_interactionConfig$to","_interactionConfig$to2","mergeSplitMaps","splitMaps","sm","entries","_ref2","_ref3","_slicedToArray2","pushTo","find","getInitialMapLayersForSplitMap","splitMapsToBeMerged","mergeEffects","newEffects","effect","createEffect","deepmerge","all","isConfigActive","isValidToSave","tooltipConfig","_loop2","allFields","fields","foundFieldsToShow","field","mergeLayerBlending","layerBlending","LAYER_BLENDINGS","mergeOverlayBlending","overlayBlending","OVERLAY_BLENDINGS","mergeAnimationConfig","animation","currentTime","animationConfig","domain","validateSavedLayerColumns","savedCols","emptyCols","options","columns","_loop3","_Object$keys","_i","saved","fieldIdx","_ref4","allColFound","every","validateColumn","rv","throwOnError","requiredColumns","k","optional","missingColumns","Error","join","configColumns","invalidColumns","_columns$k","column","validator","validateSavedTextLabel","_ref5","savedTextLabel","_ref6","layerTextLabel","savedTextLabels","textLabel","fd","JSON","stringify","reduce","accu","validateSavedVisualChannels","savedLayer","values","_ref7","scale","foundField","foundChannel","updateLayerConfig","validateVisualChannel","_savedLayer$config","_newLayer$config$fiel","fieldName","_layer$config","validateLayer","validateLayerWithData","_getColumnConfigForValidation","columnConfig","getLayerColumns","colModeConfig","columnMode","supportedColumnModes","colMode","optionalColumns","dataset","type","prototype","hasOwnProperty","label","color","isVisible","hidden","highlightColor","copiedVisConfig","copyLayerConfig","visConfig","shallowCopy","validateVisConfig","mergeEditor","savedEditor","_savedEditor$visible","editor","features","visible","mergeDatasetsByOrder","newDataEntries","preserveDatasetOrder","newDatasetIds","_state$preserveDatase","VIS_STATE_MERGERS","exports","merge","prop","toMergeProp","preserveOrder","replaceParentDatasetIds","saveUnmerged"],"sources":["../src/vis-state-merger.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport uniq from 'lodash.uniq';\nimport pick from 'lodash.pick';\nimport flattenDeep from 'lodash.flattendeep';\nimport deepmerge from 'deepmerge';\nimport {\n  arrayInsert,\n  getInitialMapLayersForSplitMap,\n  applyFiltersToDatasets,\n  validateFiltersUpdateDatasets,\n  findById\n} from '@kepler.gl/utils';\n\nimport {Layer, VisualChannel} from '@kepler.gl/layers';\nimport {createEffect} from '@kepler.gl/effects';\nimport {LAYER_BLENDINGS, OVERLAY_BLENDINGS} from '@kepler.gl/constants';\nimport {CURRENT_VERSION, VisState, VisStateMergers, KeplerGLSchemaClass} from '@kepler.gl/schemas';\n\nimport {\n  ParsedLayer,\n  ParsedVisState,\n  SavedInteractionConfig,\n  TooltipInfo,\n  SavedEditor,\n  ParsedConfig,\n  Filter,\n  Effect as EffectType,\n  ParsedEffect,\n  LayerColumns,\n  LayerColumn\n} from '@kepler.gl/types';\nimport {KeplerTable, Datasets, assignGpuChannels, resetFilterGpuMode} from '@kepler.gl/table';\n\nimport {getLayerOrderFromLayers} from './layer-utils';\n\n/**\n * Merge loaded filters with current state, if no fields or data are loaded\n * save it for later\n *\n */\nexport function mergeFilters<S extends VisState>(\n  state: S,\n  filtersToMerge: NonNullable<ParsedConfig['visState']>['filters'],\n  fromConfig?: boolean\n): S {\n  const preserveFilterOrder = fromConfig\n    ? filtersToMerge?.map(l => l.id)\n    : state.preserveFilterOrder;\n\n  if (!Array.isArray(filtersToMerge) || !filtersToMerge.length) {\n    return state;\n  }\n\n  const {validated, failed, updatedDatasets} = validateFiltersUpdateDatasets(state, filtersToMerge);\n  let updatedFilters = insertItemBasedOnPreservedOrder(\n    state.filters,\n    validated,\n    preserveFilterOrder\n  );\n\n  // merge filter with existing\n  updatedFilters = resetFilterGpuMode(updatedFilters);\n  updatedFilters = assignGpuChannels(updatedFilters);\n  // filter data\n  const datasetsToFilter = uniq(flattenDeep(validated.map(f => f.dataId)));\n\n  const filtered = applyFiltersToDatasets(\n    datasetsToFilter,\n    updatedDatasets,\n    updatedFilters,\n    state.layers\n  );\n\n  return {\n    ...state,\n    filters: updatedFilters,\n    datasets: filtered,\n    preserveFilterOrder,\n    filterToBeMerged: [...state.filterToBeMerged, ...failed]\n  };\n}\n\n// replace dataId in saved Filter\nexport function replaceFilterDatasetIds(\n  savedFilter: Filter[],\n  dataId: string,\n  dataIdToUse: string\n) {\n  const replaced: Filter[] = [];\n  savedFilter.forEach(filter => {\n    if (filter.dataId.includes(dataId)) {\n      const newDataId = filter.dataId.map(d => (d === dataId ? dataIdToUse : d));\n      replaced.push({\n        ...filter,\n        dataId: newDataId\n      });\n    }\n  });\n  return replaced.length ? replaced : null;\n}\n\nexport function isSavedLayerConfigV1(layerConfig: any): boolean {\n  // exported layer configuration contains visualChannels property\n  return layerConfig?.visualChannels;\n}\n\nexport function parseLayerConfig(\n  schema: KeplerGLSchemaClass,\n  layerConfig: any\n): ParsedLayer | undefined {\n  // assume the layer config is current version\n  const savedConfig = {\n    version: CURRENT_VERSION,\n    config: {\n      visState: {layers: [layerConfig], layerOrder: [layerConfig.id]}\n    }\n  };\n\n  return schema.parseSavedConfig(savedConfig)?.visState?.layers?.[0];\n}\n\nfunction insertItemBasedOnPreservedOrder(\n  currentItems: Filter[],\n  items: Filter[],\n  preservedOrder: any[] = [],\n  defaultStart?: boolean\n) {\n  let newItems = [...currentItems];\n\n  for (const item of items) {\n    const expectedIdx = preservedOrder.indexOf(item.id);\n    // insertAt the end by default\n    let insertAt = defaultStart ? 0 : newItems.length;\n    if (expectedIdx > 0) {\n      // look for layer to insert after\n      let i = expectedIdx + 1;\n      let preceedIdx = -1;\n      while (i-- > 0 && preceedIdx < 0) {\n        // keep looking for preceed layer that is already loaded\n        const preceedItemId = preservedOrder[i - 1];\n        preceedIdx = newItems.findIndex(d => d.id === preceedItemId);\n      }\n      if (preceedIdx > -1) {\n        // if found\n        insertAt = preceedIdx + 1;\n      }\n    }\n    newItems = arrayInsert(newItems, insertAt, item);\n  }\n  return newItems;\n}\n\nexport function createLayerFromConfig(state: VisState, layerConfig: any): Layer | null {\n  // check if the layer config is parsed\n  const parsedLayerConfig = isSavedLayerConfigV1(layerConfig)\n    ? parseLayerConfig(state.schema, layerConfig)\n    : layerConfig;\n\n  if (!parsedLayerConfig) {\n    return null;\n  }\n  // first validate config against dataset\n  const {validated, failed} = validateLayersByDatasets(\n    state.datasets,\n    state.layerClasses,\n    [parsedLayerConfig],\n    {allowEmptyColumn: true}\n  );\n\n  if (failed?.length || !validated.length) {\n    // failed\n    return null;\n  }\n\n  const newLayer = validated[0];\n  newLayer.updateLayerDomain(state.datasets);\n  return newLayer;\n}\n\n/**\n * Get loaded layer from state\n */\nexport function serializeLayer(\n  newLayer: Layer,\n  schema: KeplerGLSchemaClass\n): ParsedLayer | undefined {\n  const serializedVisState = serializeVisState(\n    {layers: [newLayer], layerOrder: [newLayer.id]},\n    schema\n  );\n  return serializedVisState?.layers?.[0];\n}\n\n/**\n * Get loaded effect from state\n */\nexport function serializeEffect(\n  newEffect: EffectType,\n  schema: KeplerGLSchemaClass\n): ParsedEffect | undefined {\n  const serializedVisState = serializeVisState(\n    {effects: [newEffect], effectOrder: [newEffect.id]},\n    schema\n  );\n  return serializedVisState?.effects?.[0];\n}\n\n/**\n * Get vis state config\n */\nexport function serializeVisState(\n  visState: Partial<VisState>,\n  schema: KeplerGLSchemaClass\n): ParsedVisState | undefined {\n  const savedState = schema.getConfigToSave({\n    visState\n  });\n  return savedState ? schema.parseSavedConfig(savedState)?.visState : undefined;\n}\n/**\n * Merge layers from de-serialized state, if no fields or data are loaded\n * save it for later\n *\n */\nexport function mergeLayers<S extends VisState>(\n  state: S,\n  layersToMerge: NonNullable<ParsedConfig['visState']>['layers'] = [],\n  fromConfig?: boolean\n): S {\n  const preserveLayerOrder = fromConfig\n    ? getLayerOrderFromLayers(layersToMerge)\n    : state.preserveLayerOrder;\n  if (!Array.isArray(layersToMerge) || !layersToMerge.length) {\n    return state;\n  }\n  // don't merge layer if dataset is being merged\n  const unmerged: ParsedLayer[] = [];\n  const toMerge: ParsedLayer[] = [];\n  layersToMerge.forEach((l: ParsedLayer) => {\n    if (l?.config?.dataId && state.isMergingDatasets[l.config.dataId]) {\n      unmerged.push(l);\n    } else {\n      toMerge.push(l);\n    }\n  });\n\n  const {validated: mergedLayer, failed} = validateLayersByDatasets(\n    state.datasets,\n    state.layerClasses,\n    toMerge\n  );\n  unmerged.push(...failed);\n  // put new layers in front of current layers\n  const {newLayerOrder, newLayers} = insertLayerAtRightOrder(\n    state.layers,\n    mergedLayer,\n    state.layerOrder,\n    preserveLayerOrder\n  );\n\n  return {\n    ...state,\n    layers: newLayers,\n    layerOrder: newLayerOrder,\n    preserveLayerOrder,\n    layerToBeMerged: [...state.layerToBeMerged, ...unmerged]\n  };\n}\n\nexport function insertLayerAtRightOrder(\n  currentLayers,\n  layersToInsert,\n  currentOrder,\n  preservedOrder: string[] = []\n) {\n  if (!layersToInsert?.length) {\n    return {newLayers: currentLayers, newLayerOrder: currentOrder};\n  }\n  // perservedOrder ['a', 'b', 'c'];\n  // layerOrder ['a', 'b', 'c']\n  const currentLayerQueue = currentOrder\n    .map(id => findById(id)(currentLayers))\n    .filter(layer => Boolean(layer));\n  const newLayers = currentLayers.concat(layersToInsert);\n  const newLayerOrderQueue = insertItemBasedOnPreservedOrder(\n    currentLayerQueue,\n    layersToInsert,\n    preservedOrder,\n    true\n  );\n\n  // reconstruct layerOrder after insert\n  const newLayerOrder = getLayerOrderFromLayers(newLayerOrderQueue);\n\n  return {\n    newLayerOrder,\n    newLayers\n  };\n}\n\n/**\n * Merge interactions with saved config\n *\n */\nexport function mergeInteractions<S extends VisState>(\n  state: S,\n  interactionToBeMerged: Partial<SavedInteractionConfig> | undefined\n): S {\n  const merged: Partial<SavedInteractionConfig> = {};\n  const unmerged: Partial<SavedInteractionConfig> = {};\n\n  if (interactionToBeMerged) {\n    (Object.keys(interactionToBeMerged) as Array<keyof SavedInteractionConfig>).forEach(key => {\n      if (!state.interactionConfig[key]) {\n        return;\n      }\n\n      const currentConfig =\n        key === 'tooltip' || key === 'brush' ? state.interactionConfig[key].config : null;\n\n      const {enabled, ...configSaved} = interactionToBeMerged[key] || {};\n\n      let configToMerge = configSaved;\n\n      if (key === 'tooltip') {\n        const {mergedTooltip, unmergedTooltip} = mergeInteractionTooltipConfig(\n          state,\n          configSaved as SavedInteractionConfig['tooltip']\n        );\n\n        // merge new dataset tooltips with original dataset tooltips\n        configToMerge = {\n          fieldsToShow: {\n            ...(currentConfig as TooltipInfo['config']).fieldsToShow,\n            ...mergedTooltip\n          }\n        };\n\n        if (Object.keys(unmergedTooltip).length) {\n          // @ts-expect-error\n          unmerged.tooltip = {fieldsToShow: unmergedTooltip, enabled: Boolean(enabled)};\n        }\n      }\n\n      merged[key] = {\n        ...state.interactionConfig[key],\n        enabled: Boolean(enabled),\n        ...(currentConfig\n          ? {\n              config: pick(\n                {\n                  ...currentConfig,\n                  ...configToMerge\n                },\n                Object.keys(currentConfig)\n              )\n            }\n          : {})\n      };\n    });\n  }\n\n  const nextState = {\n    ...state,\n    interactionConfig: {\n      ...state.interactionConfig,\n      ...merged\n    },\n    interactionToBeMerged: savedUnmergedInteraction(state, unmerged)\n  };\n  return nextState;\n}\n\nfunction savedUnmergedInteraction<S extends VisState>(\n  state: S,\n  unmerged: Partial<SavedInteractionConfig>\n) {\n  if (!unmerged?.tooltip?.fieldsToShow) {\n    return state.interactionToBeMerged;\n  }\n  return {\n    tooltip: {\n      ...state.interactionToBeMerged.tooltip,\n      ...(typeof unmerged?.tooltip?.enabled === 'boolean'\n        ? {enabled: unmerged.tooltip.enabled}\n        : {}),\n      fieldsToShow: {\n        ...state.interactionToBeMerged?.tooltip?.fieldsToShow,\n        ...unmerged?.tooltip?.fieldsToShow\n      }\n    }\n  };\n}\n\nfunction replaceInteractionDatasetIds(interactionConfig, dataId: string, dataIdToReplace: string) {\n  if (interactionConfig?.tooltip?.fieldsToShow[dataId]) {\n    return {\n      ...interactionConfig,\n      tooltip: {\n        ...interactionConfig.tooltip,\n        fieldsToShow: {\n          [dataIdToReplace]: interactionConfig?.tooltip?.fieldsToShow[dataId]\n        }\n      }\n    };\n  }\n  return null;\n}\n/**\n * Merge splitMaps config with current visStete.\n * 1. if current map is split, but splitMap DOESNOT contain maps\n *    : don't merge anything\n * 2. if current map is NOT split, but splitMaps contain maps\n *    : add to splitMaps, and add current layers to splitMaps\n */\nexport function mergeSplitMaps<S extends VisState>(\n  state: S,\n  splitMaps: NonNullable<ParsedConfig['visState']>['splitMaps'] = []\n): S {\n  const merged = [...state.splitMaps];\n  const unmerged = [];\n  splitMaps.forEach((sm, i) => {\n    const entries = Object.entries(sm.layers);\n    if (entries.length > 0) {\n      entries.forEach(([id, value]) => {\n        // check if layer exists\n        const pushTo = state.layers.find(l => l.id === id) ? merged : unmerged;\n\n        // create map panel if current map is not split\n        pushTo[i] = pushTo[i] || {\n          // keep id\n          ...sm,\n          layers: pushTo === merged ? getInitialMapLayersForSplitMap(state.layers) : []\n        };\n        pushTo[i].layers = {\n          ...pushTo[i].layers,\n          [id]: value\n        };\n      });\n    } else {\n      // We are merging if there are no layers in both split map\n      merged.push(sm);\n    }\n  });\n\n  return {\n    ...state,\n    splitMaps: merged,\n    splitMapsToBeMerged: [...state.splitMapsToBeMerged, ...unmerged]\n  };\n}\n\n/**\n * Merge effects with saved config\n */\nexport function mergeEffects<S extends VisState>(\n  state: S,\n  effects: NonNullable<ParsedConfig['visState']>['effects'],\n  fromConfig?: boolean\n): S {\n  const newEffects = [\n    ...state.effects,\n    ...(effects || [])\n      .map(effect => {\n        return fromConfig\n          ? createEffect(\n              deepmerge.all([\n                effect,\n                {\n                  // collapse all panels when loading effects\n                  isConfigActive: false\n                }\n              ])\n            )\n          : (effect as EffectType);\n      })\n      .filter(effect => {\n        return Boolean(effect && effect.isValidToSave());\n      })\n  ];\n  return {\n    ...state,\n    effects: newEffects,\n    effectOrder: newEffects.map(effect => effect.id)\n  };\n}\n\n/**\n * Merge interactionConfig.tooltip with saved config,\n * validate fieldsToShow\n *\n * @param state\n * @param tooltipConfig\n * @return - {mergedTooltip: {}, unmergedTooltip: {}}\n */\nexport function mergeInteractionTooltipConfig(\n  state: VisState,\n  tooltipConfig: Pick<TooltipInfo['config'], 'fieldsToShow'> | null = null\n) {\n  const unmergedTooltip: TooltipInfo['config']['fieldsToShow'] = {};\n  const mergedTooltip: TooltipInfo['config']['fieldsToShow'] = {};\n\n  if (\n    !tooltipConfig ||\n    !tooltipConfig.fieldsToShow ||\n    !Object.keys(tooltipConfig.fieldsToShow).length\n  ) {\n    return {mergedTooltip, unmergedTooltip};\n  }\n\n  for (const dataId in tooltipConfig.fieldsToShow) {\n    if (!state.datasets[dataId] || state.isMergingDatasets[dataId]) {\n      // is not yet loaded\n      unmergedTooltip[dataId] = tooltipConfig.fieldsToShow[dataId];\n    } else {\n      // if dataset is loaded\n      const allFields = state.datasets[dataId].fields.map(d => d.name);\n      const foundFieldsToShow = tooltipConfig.fieldsToShow[dataId].filter(field =>\n        allFields.includes(field.name)\n      );\n\n      mergedTooltip[dataId] = foundFieldsToShow;\n    }\n  }\n\n  return {mergedTooltip, unmergedTooltip};\n}\n/**\n * Merge layerBlending with saved\n *\n */\nexport function mergeLayerBlending<S extends VisState>(\n  state: S,\n  layerBlending: NonNullable<ParsedConfig['visState']>['layerBlending']\n): S {\n  if (layerBlending && LAYER_BLENDINGS[layerBlending]) {\n    return {\n      ...state,\n      layerBlending\n    };\n  }\n\n  return state;\n}\n\n/**\n * Merge overlayBlending with saved\n */\nexport function mergeOverlayBlending<S extends VisState>(\n  state: S,\n  overlayBlending: NonNullable<ParsedConfig['visState']>['overlayBlending']\n): S {\n  if (overlayBlending && OVERLAY_BLENDINGS[overlayBlending]) {\n    return {\n      ...state,\n      overlayBlending\n    };\n  }\n\n  return state;\n}\n\n/**\n * Merge animation config\n */\nexport function mergeAnimationConfig<S extends VisState>(\n  state: S,\n  animation: NonNullable<ParsedConfig['visState']>['animationConfig']\n): S {\n  if (animation && animation.currentTime) {\n    return {\n      ...state,\n      animationConfig: {\n        ...state.animationConfig,\n        ...animation,\n        domain: null\n      }\n    };\n  }\n\n  return state;\n}\n\n/**\n * Validate saved layer columns with new data,\n * update fieldIdx based on new fields\n *\n * @param fields\n * @param savedCols\n * @param emptyCols\n * @param options\n * @return - validated columns or null\n */\n\nexport function validateSavedLayerColumns(\n  fields: KeplerTable['fields'],\n  savedCols: {\n    [key: string]: string;\n  } = {},\n  emptyCols: LayerColumns,\n  options: {throwOnError?: boolean} = {}\n) {\n  // Prepare columns for the validator\n  const columns: typeof emptyCols = {};\n  for (const key of Object.keys(emptyCols)) {\n    columns[key] = {...emptyCols[key]};\n\n    const saved = savedCols[key];\n    if (saved) {\n      const fieldIdx = fields.findIndex(({name}) => name === saved);\n\n      if (fieldIdx > -1) {\n        // update found columns\n        columns[key].fieldIdx = fieldIdx;\n        columns[key].value = saved;\n      }\n    }\n  }\n\n  // find actual column fieldIdx, in case it has changed\n  const allColFound = Object.keys(columns).every(key =>\n    validateColumn(columns[key], columns, fields)\n  );\n\n  const rv = allColFound ? columns : null;\n  if (options.throwOnError) {\n    const requiredColumns = Object.keys(emptyCols).filter(k => !emptyCols[k].optional);\n    const missingColumns = requiredColumns.filter(k => !columns?.[k].value);\n    if (missingColumns.length) {\n      throw new Error(`Layer has missing or invalid columns: ${missingColumns.join(', ')}`);\n    }\n    const configColumns = Object.keys(savedCols);\n    const invalidColumns = configColumns.filter(k => !columns?.[k]?.value);\n    if (invalidColumns.length) {\n      throw new Error(`Layer has invalid columns: ${invalidColumns.join(', ')}`);\n    }\n  }\n\n  return rv;\n}\n\n/**\n * Validate layer column\n */\nexport function validateColumn(\n  column: LayerColumn & {validator?: typeof validateColumn},\n  columns: LayerColumns,\n  allFields: KeplerTable['fields']\n): boolean {\n  if (column.optional || column.value) {\n    return true;\n  }\n  if (column.validator) {\n    return column.validator(column, columns, allFields);\n  }\n  return false;\n}\n\n/**\n * Validate saved text label config with new data\n * refer to vis-state-schema.js TextLabelSchemaV1\n *\n * @param {Array<Object>} fields\n * @param {Object} savedTextLabel\n * @param {Object} options\n * @return {Object} - validated textlabel\n */\nexport function validateSavedTextLabel(\n  fields,\n  [layerTextLabel],\n  savedTextLabel,\n  options: {throwOnError?: boolean} = {}\n) {\n  const savedTextLabels = Array.isArray(savedTextLabel) ? savedTextLabel : [savedTextLabel];\n\n  // validate field\n  return savedTextLabels.map(textLabel => {\n    const field = textLabel.field\n      ? fields.find(fd =>\n          Object.keys(textLabel.field).every(key => textLabel.field[key] === fd[key])\n        )\n      : null;\n\n    if (field === undefined && options.throwOnError) {\n      throw new Error(`Layer has invalid text label field: ${JSON.stringify(textLabel.field)}`);\n    }\n\n    return Object.keys(layerTextLabel).reduce(\n      (accu, key) => ({\n        ...accu,\n        [key]: key === 'field' ? field : textLabel[key] || layerTextLabel[key]\n      }),\n      {}\n    );\n  });\n}\n\n/**\n * Validate saved visual channels config with new data,\n * refer to vis-state-schema.js VisualChannelSchemaV1\n */\nexport function validateSavedVisualChannels(\n  fields: KeplerTable['fields'],\n  newLayer: Layer,\n  savedLayer: ParsedLayer,\n  options: {throwOnError?: boolean} = {}\n): null | Layer {\n  (Object.values(newLayer.visualChannels) as VisualChannel[]).forEach(({field, scale, key}) => {\n    let foundField;\n    if (savedLayer.config) {\n      if (savedLayer.config[field]) {\n        foundField = fields.find(\n          fd => savedLayer.config && fd.name === savedLayer.config[field].name\n        );\n      }\n\n      const foundChannel = {\n        ...(foundField ? {[field]: foundField} : {}),\n        ...(savedLayer.config[scale] ? {[scale]: savedLayer.config[scale]} : {})\n      };\n      if (Object.keys(foundChannel).length) {\n        newLayer.updateLayerConfig(foundChannel);\n      }\n\n      newLayer.validateVisualChannel(key);\n      if (options.throwOnError) {\n        const fieldName = savedLayer.config?.[field]?.name;\n        if (fieldName && fieldName !== newLayer.config[field]?.name) {\n          throw new Error(`Layer has invalid visual channel field: ${field}`);\n        }\n      }\n    }\n  });\n  return newLayer;\n}\n\ntype ValidateLayerOption = {\n  allowEmptyColumn?: boolean;\n  throwOnError?: boolean;\n};\n\nexport function validateLayersByDatasets(\n  datasets: Datasets,\n  layerClasses: VisState['layerClasses'],\n  layers: NonNullable<ParsedConfig['visState']>['layers'] = [],\n  options?: ValidateLayerOption\n) {\n  const validated: Layer[] = [];\n  const failed: NonNullable<ParsedConfig['visState']>['layers'] = [];\n\n  layers.forEach(layer => {\n    let validateLayer: Layer | null = null;\n\n    if (layer?.config?.dataId) {\n      if (datasets[layer.config.dataId]) {\n        // datasets are already loaded\n        validateLayer = validateLayerWithData(\n          datasets[layer.config.dataId],\n          layer,\n          layerClasses,\n          options\n        );\n      }\n    }\n\n    if (validateLayer) {\n      validated.push(validateLayer);\n    } else {\n      // datasets not yet loaded\n      failed.push(layer);\n    }\n  });\n\n  return {validated, failed};\n}\n\n/**\n * Get required columns for validation based on column mode\n */\nfunction _getColumnConfigForValidation(newLayer) {\n  // find column fieldIdx\n  let columnConfig = newLayer.getLayerColumns();\n  // if columnMode is defined, find column mode config\n  const colModeConfig = newLayer.config.columnMode\n    ? (newLayer.supportedColumnModes || []).find(\n        colMode => colMode.key === newLayer.config.columnMode\n      )\n    : null;\n\n  if (colModeConfig) {\n    // only validate columns in column mode\n    columnConfig = [\n      ...(colModeConfig.requiredColumns || []),\n      ...(colModeConfig.optionalColumns || [])\n    ].reduce(\n      (accu, key) => ({\n        ...accu,\n        [key]: columnConfig[key]\n      }),\n      {}\n    );\n  }\n\n  return columnConfig;\n}\n\n/**\n * Validate saved layer config with new data,\n * update fieldIdx based on new fields\n */\n// eslint-disable-next-line complexity\nexport function validateLayerWithData(\n  dataset: KeplerTable,\n  savedLayer: ParsedLayer,\n  layerClasses: VisState['layerClasses'],\n  options: ValidateLayerOption = {}\n): Layer | null {\n  const {fields, id: dataId} = dataset;\n  const {type} = savedLayer;\n  const {throwOnError} = options;\n  // layer doesnt have a valid type\n  if (!type || !Object.prototype.hasOwnProperty.call(layerClasses, type) || !savedLayer.config) {\n    if (throwOnError) {\n      throw new Error(`Layer has invalid type \"${type}\" or config is missing`);\n    }\n    return null;\n  }\n\n  let newLayer = new layerClasses[type]({\n    id: savedLayer.id,\n    dataId,\n    label: savedLayer.config.label,\n    color: savedLayer.config.color,\n    isVisible: savedLayer.config.isVisible,\n    hidden: savedLayer.config.hidden,\n    columnMode: savedLayer.config.columnMode,\n    highlightColor: savedLayer.config.highlightColor\n  });\n\n  const columnConfig = _getColumnConfigForValidation(newLayer);\n\n  if (Object.keys(columnConfig)) {\n    const columns = validateSavedLayerColumns(\n      fields,\n      savedLayer.config.columns,\n      columnConfig,\n      options\n    );\n    if (columns) {\n      newLayer.updateLayerConfig({\n        columns: {\n          ...newLayer.config.columns,\n          ...columns\n        }\n      });\n    } else if (!options.allowEmptyColumn) {\n      return null;\n    }\n  }\n\n  const textLabel =\n    savedLayer.config.textLabel && newLayer.config.textLabel\n      ? validateSavedTextLabel(\n          fields,\n          newLayer.config.textLabel,\n          savedLayer.config.textLabel,\n          options\n        )\n      : newLayer.config.textLabel;\n\n  // copy visConfig over to emptyLayer to make sure it has all the props\n  const copiedVisConfig = newLayer.copyLayerConfig(\n    newLayer.config.visConfig,\n    savedLayer.config.visConfig || {},\n    {\n      shallowCopy: ['colorRange', 'strokeColorRange']\n    }\n  );\n\n  // call layer methods to validate visConfig when switching dataset\n  const visConfig = newLayer.validateVisConfig\n    ? newLayer.validateVisConfig(dataset, copiedVisConfig)\n    : copiedVisConfig;\n\n  newLayer.updateLayerConfig({\n    visConfig,\n    textLabel\n  });\n\n  // visual channel field is saved to be {name, type}\n  // find visual channel field by matching both name and type\n  // refer to vis-state-schema.js VisualChannelSchemaV1\n  newLayer = validateSavedVisualChannels(fields, newLayer, savedLayer, options);\n\n  if (throwOnError) {\n    if (!newLayer.isValidToSave()) {\n      throw new Error(`Layer is not valid to save: ${newLayer.id}`);\n    }\n  }\n\n  return newLayer;\n}\n\nexport function mergeEditor<S extends VisState>(state: S, savedEditor: SavedEditor) {\n  if (!savedEditor) {\n    return state;\n  }\n  return {\n    ...state,\n    editor: {\n      ...state.editor,\n      features: [...state.editor.features, ...(savedEditor.features || [])],\n      // if savedEditor.visible is undefined keep state.editor.visible\n      visible: savedEditor.visible ?? state.editor.visible\n    }\n  };\n}\n\n/**\n * Validate saved layer config with new data,\n * update fieldIdx based on new fields\n */\nexport function mergeDatasetsByOrder(state: VisState, newDataEntries: Datasets): Datasets {\n  const merged = {\n    ...state.datasets,\n    ...newDataEntries\n  };\n\n  if (Array.isArray(state.preserveDatasetOrder)) {\n    // preserveDatasetOrder  might not include the  new datasets\n    const newDatasetIds = Object.keys(merged).filter(\n      id => !state.preserveDatasetOrder?.includes(id)\n    );\n    return [...state.preserveDatasetOrder, ...newDatasetIds].reduce(\n      (accu, dataId) => ({\n        ...accu,\n        ...(merged[dataId] ? {[dataId]: merged[dataId]} : {})\n      }),\n      {}\n    );\n  }\n\n  return merged;\n}\n\nexport const VIS_STATE_MERGERS: VisStateMergers<any> = [\n  {\n    merge: mergeLayers,\n    prop: 'layers',\n    toMergeProp: 'layerToBeMerged',\n    preserveOrder: 'preserveLayerOrder'\n  },\n  {\n    merge: mergeFilters,\n    prop: 'filters',\n    toMergeProp: 'filterToBeMerged',\n    preserveOrder: 'preserveFilterOrder',\n    replaceParentDatasetIds: replaceFilterDatasetIds\n  },\n  {\n    merge: mergeEffects,\n    prop: 'effects'\n  },\n  {\n    merge: mergeInteractions,\n    prop: 'interactionConfig',\n    toMergeProp: 'interactionToBeMerged',\n    replaceParentDatasetIds: replaceInteractionDatasetIds,\n    saveUnmerged: savedUnmergedInteraction\n  },\n  {merge: mergeLayerBlending, prop: 'layerBlending'},\n  {merge: mergeOverlayBlending, prop: 'overlayBlending'},\n  {merge: mergeSplitMaps, prop: 'splitMaps', toMergeProp: 'splitMapsToBeMerged'},\n  {merge: mergeAnimationConfig, prop: 'animationConfig'},\n  {merge: mergeEditor, prop: 'editor'}\n];\n"],"mappings":"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","ignoreList":[]}