@kepler.gl/reducers 3.0.0-alpha.0

package/dist/vis-state-merger.js

@@ -0,0 +1,635 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeFilters = mergeFilters;
+exports.createLayerFromConfig = createLayerFromConfig;
+exports.serializeLayer = serializeLayer;
+exports.mergeLayers = mergeLayers;
+exports.insertLayerAtRightOrder = insertLayerAtRightOrder;
+exports.mergeInteractions = mergeInteractions;
+exports.mergeSplitMaps = mergeSplitMaps;
+exports.mergeInteractionTooltipConfig = mergeInteractionTooltipConfig;
+exports.mergeLayerBlending = mergeLayerBlending;
+exports.mergeAnimationConfig = mergeAnimationConfig;
+exports.validateSavedLayerColumns = validateSavedLayerColumns;
+exports.validateColumn = validateColumn;
+exports.validateSavedTextLabel = validateSavedTextLabel;
+exports.validateSavedVisualChannels = validateSavedVisualChannels;
+exports.validateLayersByDatasets = validateLayersByDatasets;
+exports.validateLayerWithData = validateLayerWithData;
+exports.isValidMerger = isValidMerger;
+exports.VIS_STATE_MERGERS = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _lodash = _interopRequireDefault(require("lodash.uniq"));
+
+var _lodash2 = _interopRequireDefault(require("lodash.pick"));
+
+var _lodash3 = _interopRequireDefault(require("lodash.flattendeep"));
+
+var _utils = require("@kepler.gl/utils");
+
+var _constants = require("@kepler.gl/constants");
+
+var _schemas = require("@kepler.gl/schemas");
+
+var _table = require("@kepler.gl/table");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
+ * Merge loaded filters with current state, if no fields or data are loaded
+ * save it for later
+ *
+ */
+function mergeFilters(state, filtersToMerge, fromConfig) {
+  if (!Array.isArray(filtersToMerge) || !filtersToMerge.length) {
+    return state;
+  }
+
+  var _validateFiltersUpdat = (0, _utils.validateFiltersUpdateDatasets)(state, filtersToMerge),
+      validated = _validateFiltersUpdat.validated,
+      failed = _validateFiltersUpdat.failed,
+      updatedDatasets = _validateFiltersUpdat.updatedDatasets; // merge filter with existing
+
+
+  var updatedFilters = [].concat((0, _toConsumableArray2["default"])(state.filters || []), (0, _toConsumableArray2["default"])(validated));
+  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,
+    filterToBeMerged: [].concat((0, _toConsumableArray2["default"])(state.filterToBeMerged), (0, _toConsumableArray2["default"])(failed))
+  });
+}
+
+function createLayerFromConfig(state, layerConfig) {
+  // first validate config against dataset
+  var _validateLayersByData = validateLayersByDatasets(state.datasets, state.layerClasses, [layerConfig]),
+      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;
+}
+
+function serializeLayer(newLayer) {
+  var _visStateSchema$CURRE, _visStateSchema$CURRE2;
+
+  var savedVisState = _schemas.visStateSchema[_schemas.CURRENT_VERSION].save( // @ts-expect-error not all expected properties are provided
+  {
+    layers: [newLayer],
+    layerOrder: [0]
+  }).visState;
+
+  var loadedLayer = (_visStateSchema$CURRE = _schemas.visStateSchema[_schemas.CURRENT_VERSION].load(savedVisState).visState) === null || _visStateSchema$CURRE === void 0 ? void 0 : (_visStateSchema$CURRE2 = _visStateSchema$CURRE.layers) === null || _visStateSchema$CURRE2 === void 0 ? void 0 : _visStateSchema$CURRE2[0]; // @ts-expect-error
+
+  return loadedLayer;
+}
+/**
+ * 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 ? layersToMerge.map(function (l) {
+    return l.id;
+  }) : state.preserveLayerOrder;
+
+  if (!Array.isArray(layersToMerge) || !layersToMerge.length) {
+    return state;
+  }
+
+  var _validateLayersByData2 = validateLayersByDatasets(state.datasets, state.layerClasses, layersToMerge),
+      mergedLayer = _validateLayersByData2.validated,
+      unmerged = _validateLayersByData2.failed; // put new layers in front of current layers
+
+
+  var _insertLayerAtRightOr = insertLayerAtRightOrder(state.layers, mergedLayer, state.layerOrder, // @ts-expect-error
+  preserveLayerOrder),
+      newLayerOrder = _insertLayerAtRightOr.newLayerOrder,
+      newLayers = _insertLayerAtRightOr.newLayers;
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    layers: newLayers,
+    layerOrder: newLayerOrder,
+    preserveLayerOrder: preserveLayerOrder,
+    layerToBeMerged: [].concat((0, _toConsumableArray2["default"])(state.layerToBeMerged), (0, _toConsumableArray2["default"])(unmerged))
+  });
+}
+
+function insertLayerAtRightOrder(currentLayers, layersToInsert, currentOrder) {
+  var preservedOrder = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  // perservedOrder ['a', 'b', 'c'];
+  // layerOrder [1, 0, 3]
+  // layerOrderMap ['a', 'c']
+  var layerOrderQueue = currentOrder.map(function (i) {
+    return currentLayers[i].id;
+  });
+  var newLayers = currentLayers;
+
+  var _iterator = _createForOfIteratorHelper(layersToInsert),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var newLayer = _step.value;
+      // find where to insert it
+      var expectedIdx = preservedOrder.indexOf(newLayer.id); // if cant find place to insert, insert at the front
+
+      var insertAt = 0;
+
+      if (expectedIdx > 0) {
+        // look for layer to insert after
+        var i = expectedIdx + 1;
+        var preceedIdx = -1;
+
+        while (i-- > 0 && preceedIdx < 0) {
+          // keep looking for preceed layer that is already loaded
+          var preceedLayer = preservedOrder[i - 1];
+          preceedIdx = layerOrderQueue.indexOf(preceedLayer);
+        }
+
+        if (preceedIdx > -1) {
+          // if found
+          insertAt = preceedIdx + 1;
+        }
+      }
+
+      layerOrderQueue = (0, _utils.arrayInsert)(layerOrderQueue, insertAt, newLayer.id);
+      newLayers = newLayers.concat(newLayer);
+    } // reconstruct layerOrder after insert
+
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  var newLayerOrder = layerOrderQueue.map(function (id) {
+    return newLayers.findIndex(function (l) {
+      return l.id === id;
+    });
+  });
+  return {
+    newLayerOrder: newLayerOrder,
+    newLayers: newLayers
+  };
+}
+/**
+ * Merge interactions with saved config
+ *
+ */
+
+
+function mergeInteractions(state, interactionToBeMerged, fromConfig) {
+  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, ["enabled"]);
+
+      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))
+      } : {});
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    interactionConfig: _objectSpread(_objectSpread({}, state.interactionConfig), merged),
+    interactionToBeMerged: unmerged
+  });
+}
+/**
+ * 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 fromConfig = arguments.length > 2 ? arguments[2] : undefined;
+  var merged = (0, _toConsumableArray2["default"])(state.splitMaps);
+  var unmerged = [];
+  splitMaps.forEach(function (sm, i) {
+    Object.entries(sm.layers).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] || {
+        layers: pushTo === merged ? (0, _utils.getInitialMapLayersForSplitMap)(state.layers) : []
+      };
+      pushTo[i].layers = _objectSpread(_objectSpread({}, pushTo[i].layers), {}, (0, _defineProperty2["default"])({}, id, value));
+    });
+  });
+  return _objectSpread(_objectSpread({}, state), {}, {
+    splitMaps: merged,
+    splitMapsToBeMerged: [].concat((0, _toConsumableArray2["default"])(state.splitMapsToBeMerged), unmerged)
+  });
+}
+/**
+ * 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
+    };
+  }
+
+  for (var dataId in tooltipConfig.fieldsToShow) {
+    if (!state.datasets[dataId]) {
+      // is not yet loaded
+      unmergedTooltip[dataId] = tooltipConfig.fieldsToShow[dataId];
+    } else {
+      (function () {
+        // 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;
+      })();
+    }
+  }
+
+  return {
+    mergedTooltip: mergedTooltip,
+    unmergedTooltip: unmergedTooltip
+  };
+}
+/**
+ * Merge layerBlending with saved
+ *
+ */
+
+
+function mergeLayerBlending(state, layerBlending, fromConfig) {
+  if (layerBlending && _constants.LAYER_BLENDINGS[layerBlending]) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      layerBlending: layerBlending
+    });
+  }
+
+  return state;
+}
+/**
+ * Merge animation config
+ */
+
+
+function mergeAnimationConfig(state, animation, fromConfig) {
+  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
+ * @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;
+  // Prepare columns for the validator
+  var columns = {};
+
+  var _loop = function _loop() {
+    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++) {
+    _loop();
+  } // find actual column fieldIdx, in case it has changed
+
+
+  var allColFound = Object.keys(columns).every(function (key) {
+    return validateColumn(columns[key], columns, fields);
+  });
+
+  if (allColFound) {
+    return columns;
+  }
+
+  return null;
+}
+
+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
+ * @return {Object} - validated textlabel
+ */
+
+
+function validateSavedTextLabel(fields, _ref5, savedTextLabel) {
+  var _ref6 = (0, _slicedToArray2["default"])(_ref5, 1),
+      layerTextLabel = _ref6[0];
+
+  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;
+    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) {
+  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);
+    }
+  });
+  return newLayer;
+}
+
+function validateLayersByDatasets(datasets, layerClasses) {
+  var layers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  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);
+      }
+    }
+
+    if (validateLayer) {
+      validated.push(validateLayer);
+    } else {
+      // datasets not yet loaded
+      failed.push(layer);
+    }
+  });
+  return {
+    validated: validated,
+    failed: failed
+  };
+}
+/**
+ * Validate saved layer config with new data,
+ * update fieldIdx based on new fields
+ */
+
+
+function validateLayerWithData(_ref10, savedLayer, layerClasses) {
+  var fields = _ref10.fields,
+      dataId = _ref10.id;
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var type = savedLayer.type; // layer doesnt have a valid type
+
+  if (!type || !layerClasses.hasOwnProperty(type) || !savedLayer.config) {
+    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,
+    highlightColor: savedLayer.config.highlightColor
+  }); // find column fieldIdx
+
+  var columnConfig = newLayer.getLayerColumns();
+
+  if (Object.keys(columnConfig).length) {
+    var columns = validateSavedLayerColumns(fields, savedLayer.config.columns, columnConfig);
+
+    if (columns) {
+      newLayer.updateLayerConfig({
+        columns: columns
+      });
+    } else if (!options.allowEmptyColumn) {
+      return null;
+    }
+  } // 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);
+  var textLabel = savedLayer.config.textLabel && newLayer.config.textLabel ? validateSavedTextLabel(fields, newLayer.config.textLabel, savedLayer.config.textLabel) : newLayer.config.textLabel; // copy visConfig over to emptyLayer to make sure it has all the props
+
+  var visConfig = newLayer.copyLayerConfig(newLayer.config.visConfig, savedLayer.config.visConfig || {}, {
+    shallowCopy: ['colorRange', 'strokeColorRange']
+  });
+  newLayer.updateLayerConfig({
+    visConfig: visConfig,
+    textLabel: textLabel
+  });
+  return newLayer;
+}
+
+function isValidMerger(merger) {
+  return (0, _utils.isObject)(merger) && typeof merger.merge === 'function' && typeof merger.prop === 'string';
+}
+
+var VIS_STATE_MERGERS = [{
+  merge: mergeLayers,
+  prop: 'layers',
+  toMergeProp: 'layerToBeMerged'
+}, {
+  merge: mergeFilters,
+  prop: 'filters',
+  toMergeProp: 'filterToBeMerged'
+}, {
+  merge: mergeInteractions,
+  prop: 'interactionConfig',
+  toMergeProp: 'interactionToBeMerged'
+}, {
+  merge: mergeLayerBlending,
+  prop: 'layerBlending'
+}, {
+  merge: mergeSplitMaps,
+  prop: 'splitMaps',
+  toMergeProp: 'splitMapsToBeMerged'
+}, {
+  merge: mergeAnimationConfig,
+  prop: 'animationConfig'
+}];
+exports.VIS_STATE_MERGERS = VIS_STATE_MERGERS;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/vis-state-merger.ts"],"names":["mergeFilters","state","filtersToMerge","fromConfig","Array","isArray","length","validated","failed","updatedDatasets","updatedFilters","filters","datasetsToFilter","map","f","dataId","filtered","layers","datasets","filterToBeMerged","createLayerFromConfig","layerConfig","validateLayersByDatasets","layerClasses","newLayer","updateLayerDomain","serializeLayer","savedVisState","visStateSchema","CURRENT_VERSION","save","layerOrder","visState","loadedLayer","load","mergeLayers","layersToMerge","preserveLayerOrder","l","id","mergedLayer","unmerged","insertLayerAtRightOrder","newLayerOrder","newLayers","layerToBeMerged","currentLayers","layersToInsert","currentOrder","preservedOrder","layerOrderQueue","i","expectedIdx","indexOf","insertAt","preceedIdx","preceedLayer","concat","findIndex","mergeInteractions","interactionToBeMerged","merged","Object","keys","forEach","key","interactionConfig","currentConfig","config","enabled","configSaved","configToMerge","mergeInteractionTooltipConfig","mergedTooltip","unmergedTooltip","fieldsToShow","tooltip","Boolean","mergeSplitMaps","splitMaps","sm","entries","value","pushTo","find","splitMapsToBeMerged","tooltipConfig","allFields","fields","d","name","foundFieldsToShow","filter","field","includes","mergeLayerBlending","layerBlending","LAYER_BLENDINGS","mergeAnimationConfig","animation","currentTime","animationConfig","domain","validateSavedLayerColumns","savedCols","emptyCols","columns","saved","fieldIdx","allColFound","every","validateColumn","column","optional","validator","validateSavedTextLabel","savedTextLabel","layerTextLabel","savedTextLabels","textLabel","fd","reduce","accu","validateSavedVisualChannels","savedLayer","values","visualChannels","scale","foundField","foundChannel","updateLayerConfig","validateVisualChannel","layer","validateLayer","validateLayerWithData","push","options","type","hasOwnProperty","label","color","isVisible","hidden","highlightColor","columnConfig","getLayerColumns","allowEmptyColumn","visConfig","copyLayerConfig","shallowCopy","isValidMerger","merger","merge","prop","VIS_STATE_MERGERS","toMergeProp"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport uniq from 'lodash.uniq';\nimport pick from 'lodash.pick';\nimport flattenDeep from 'lodash.flattendeep';\nimport {\n  isObject,\n  arrayInsert,\n  getInitialMapLayersForSplitMap,\n  applyFiltersToDatasets,\n  validateFiltersUpdateDatasets\n} from '@kepler.gl/utils';\n\nimport {LayerColumns, LayerColumn, Layer} from '@kepler.gl/layers';\nimport {LAYER_BLENDINGS} from '@kepler.gl/constants';\nimport {\n  CURRENT_VERSION,\n  Merger,\n  VisState,\n  VisStateMergers,\n  visStateSchema,\n  ParsedConfig\n} from '@kepler.gl/schemas';\n\nimport {ParsedLayer, SavedInteractionConfig, TooltipInfo} from '@kepler.gl/types';\nimport {KeplerTable, Datasets, assignGpuChannels, resetFilterGpuMode} from '@kepler.gl/table';\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  if (!Array.isArray(filtersToMerge) || !filtersToMerge.length) {\n    return state;\n  }\n\n  const {validated, failed, updatedDatasets} = validateFiltersUpdateDatasets(state, filtersToMerge);\n\n  // merge filter with existing\n  let updatedFilters = [...(state.filters || []), ...validated];\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    filterToBeMerged: [...state.filterToBeMerged, ...failed]\n  };\n}\n\nexport function createLayerFromConfig(state: VisState, layerConfig: any): Layer | null {\n  // first validate config against dataset\n  const {validated, failed} = validateLayersByDatasets(state.datasets, state.layerClasses, [\n    layerConfig\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\nexport function serializeLayer(newLayer): ParsedLayer {\n  const savedVisState = visStateSchema[CURRENT_VERSION].save(\n    // @ts-expect-error not all expected properties are provided\n    {\n      layers: [newLayer],\n      layerOrder: [0]\n    }\n  ).visState;\n  const loadedLayer = visStateSchema[CURRENT_VERSION].load(savedVisState).visState?.layers?.[0];\n  // @ts-expect-error\n  return loadedLayer;\n}\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 ? layersToMerge.map(l => l.id) : state.preserveLayerOrder;\n\n  if (!Array.isArray(layersToMerge) || !layersToMerge.length) {\n    return state;\n  }\n\n  const {validated: mergedLayer, failed: unmerged} = validateLayersByDatasets(\n    state.datasets,\n    state.layerClasses,\n    layersToMerge\n  );\n\n  // put new layers in front of current layers\n  const {newLayerOrder, newLayers} = insertLayerAtRightOrder(\n    state.layers,\n    mergedLayer,\n    state.layerOrder,\n    // @ts-expect-error\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  // perservedOrder ['a', 'b', 'c'];\n  // layerOrder [1, 0, 3]\n  // layerOrderMap ['a', 'c']\n  let layerOrderQueue = currentOrder.map(i => currentLayers[i].id);\n  let newLayers = currentLayers;\n\n  for (const newLayer of layersToInsert) {\n    // find where to insert it\n    const expectedIdx = preservedOrder.indexOf(newLayer.id);\n    // if cant find place to insert, insert at the front\n    let insertAt = 0;\n\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 preceedLayer = preservedOrder[i - 1];\n        preceedIdx = layerOrderQueue.indexOf(preceedLayer);\n      }\n      if (preceedIdx > -1) {\n        // if found\n        insertAt = preceedIdx + 1;\n      }\n    }\n\n    layerOrderQueue = arrayInsert(layerOrderQueue, insertAt, newLayer.id);\n    newLayers = newLayers.concat(newLayer);\n  }\n\n  // reconstruct layerOrder after insert\n  const newLayerOrder = layerOrderQueue.map(id => newLayers.findIndex(l => l.id === id));\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  fromConfig?: boolean\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  return {\n    ...state,\n    interactionConfig: {\n      ...state.interactionConfig,\n      ...merged\n    },\n    interactionToBeMerged: unmerged\n  };\n}\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  fromConfig?: boolean\n): S {\n  const merged = [...state.splitMaps];\n  const unmerged = [];\n  splitMaps.forEach((sm, i) => {\n    Object.entries(sm.layers).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        layers: pushTo === merged ? getInitialMapLayersForSplitMap(state.layers) : []\n      };\n      pushTo[i].layers = {\n        ...pushTo[i].layers,\n        [id]: value\n      };\n    });\n  });\n\n  return {\n    ...state,\n    splitMaps: merged,\n    splitMapsToBeMerged: [...state.splitMapsToBeMerged, ...unmerged]\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]) {\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  fromConfig?: boolean\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 animation config\n */\nexport function mergeAnimationConfig<S extends VisState>(\n  state: S,\n  animation: NonNullable<ParsedConfig['visState']>['animationConfig'],\n  fromConfig?: boolean\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 * @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) {\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  if (allColFound) {\n    return columns;\n  }\n\n  return null;\n}\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 * @return {Object} - validated textlabel\n */\nexport function validateSavedTextLabel(fields, [layerTextLabel], savedTextLabel) {\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    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): null | Layer {\n  Object.values(newLayer.visualChannels).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    }\n  });\n  return newLayer;\n}\n\nexport function validateLayersByDatasets(\n  datasets: Datasets,\n  layerClasses: VisState['layerClasses'],\n  layers: NonNullable<ParsedConfig['visState']>['layers'] = []\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(datasets[layer.config.dataId], layer, layerClasses);\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 * Validate saved layer config with new data,\n * update fieldIdx based on new fields\n */\nexport function validateLayerWithData(\n  {fields, id: dataId}: KeplerTable,\n  savedLayer: ParsedLayer,\n  layerClasses: VisState['layerClasses'],\n  options: {\n    allowEmptyColumn?: boolean;\n  } = {}\n): Layer | null {\n  const {type} = savedLayer;\n  // layer doesnt have a valid type\n  if (!type || !layerClasses.hasOwnProperty(type) || !savedLayer.config) {\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    highlightColor: savedLayer.config.highlightColor\n  });\n\n  // find column fieldIdx\n  const columnConfig = newLayer.getLayerColumns();\n  if (Object.keys(columnConfig).length) {\n    const columns = validateSavedLayerColumns(fields, savedLayer.config.columns, columnConfig);\n    if (columns) {\n      newLayer.updateLayerConfig({columns});\n    } else if (!options.allowEmptyColumn) {\n      return null;\n    }\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);\n\n  const textLabel =\n    savedLayer.config.textLabel && newLayer.config.textLabel\n      ? validateSavedTextLabel(fields, newLayer.config.textLabel, savedLayer.config.textLabel)\n      : newLayer.config.textLabel;\n\n  // copy visConfig over to emptyLayer to make sure it has all the props\n  const visConfig = newLayer.copyLayerConfig(\n    newLayer.config.visConfig,\n    savedLayer.config.visConfig || {},\n    {shallowCopy: ['colorRange', 'strokeColorRange']}\n  );\n\n  newLayer.updateLayerConfig({\n    visConfig,\n    textLabel\n  });\n\n  return newLayer;\n}\n\nexport function isValidMerger(merger: Merger): boolean {\n  return isObject(merger) && typeof merger.merge === 'function' && typeof merger.prop === 'string';\n}\n\nexport const VIS_STATE_MERGERS: VisStateMergers = [\n  {merge: mergeLayers, prop: 'layers', toMergeProp: 'layerToBeMerged'},\n  {merge: mergeFilters, prop: 'filters', toMergeProp: 'filterToBeMerged'},\n  {merge: mergeInteractions, prop: 'interactionConfig', toMergeProp: 'interactionToBeMerged'},\n  {merge: mergeLayerBlending, prop: 'layerBlending'},\n  {merge: mergeSplitMaps, prop: 'splitMaps', toMergeProp: 'splitMapsToBeMerged'},\n  {merge: mergeAnimationConfig, prop: 'animationConfig'}\n];\n"]}