@kepler.gl/utils 3.0.0-alpha.0 → 3.0.0-alpha.1

package/dist/effect-utils.js

@@ -0,0 +1,129 @@
+// Copyright (c) 2023 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.computeDeckEffects = computeDeckEffects;
+exports.mergeEffectParams = mergeEffectParams;
+exports.reorderEffectOrder = reorderEffectOrder;
+exports.fixEffectOrder = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _sortable = require("@dnd-kit/sortable");
+
+var _suncalc = _interopRequireDefault(require("suncalc"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _utils = require("./utils");
+
+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; }
+
+function computeDeckEffects(_ref) {
+  var visState = _ref.visState,
+      mapState = _ref.mapState;
+  var effects = visState.effectOrder.map(function (effectId) {
+    return (0, _utils.findById)(effectId)(visState.effects);
+  }).filter(function (effect) {
+    return Boolean(effect && effect.config.isEnabled && effect.deckEffect);
+  });
+  var lightShadowEffect = effects.find(function (effect) {
+    return effect.type === _constants.LIGHT_AND_SHADOW_EFFECT.type;
+  });
+
+  if (lightShadowEffect) {
+    var timestamp = lightShadowEffect.config.params.timestamp;
+
+    if (!isDaytime(mapState.latitude, mapState.longitude, timestamp)) {
+      // TODO: interpolate for dusk/dawn
+      // TODO: Should we avoid mutating the effect? (didn't work when tried defensive copying)
+      lightShadowEffect.deckEffect.shadowColor[3] = 0;
+    }
+  }
+
+  return effects.map(function (effect) {
+    return effect.deckEffect;
+  });
+}
+
+function mergeEffectParams(params, extraParams) {
+  var p1 = params || {};
+  var p2 = extraParams || {};
+  return _objectSpread(_objectSpread(_objectSpread({}, p1), p2), {}, {
+    // @ts-expect-error
+    config: _objectSpread(_objectSpread({}, p1.config || {}), p2.config || {})
+  });
+}
+/**
+ * Always keep light & shadow effect at the top
+ */
+
+
+var fixEffectOrder = function fixEffectOrder(effects, effectOrder) {
+  var lightShadowEffect = effects.find(function (effect) {
+    return effect.type === _constants.LIGHT_AND_SHADOW_EFFECT.type;
+  });
+
+  if (lightShadowEffect) {
+    var ind = effectOrder.indexOf(lightShadowEffect.id);
+
+    if (ind > 0) {
+      effectOrder.splice(ind, 1);
+      effectOrder.unshift(lightShadowEffect.id);
+    }
+  }
+
+  return effectOrder;
+};
+
+exports.fixEffectOrder = fixEffectOrder;
+
+function reorderEffectOrder(effectOrder, originEffectId, destinationEffectId) {
+  var activeIndex = effectOrder.indexOf(originEffectId);
+  var overIndex = effectOrder.indexOf(destinationEffectId);
+  return (0, _sortable.arrayMove)(effectOrder, activeIndex, overIndex);
+}
+/**
+ * Check if the current time is daytime at the given location
+ * @param {number} lat Latitude
+ * @param {number} lon Longitude
+ * @param {number} timestamp Milliseconds since the Unix Epoch
+ * @returns boolean
+ */
+
+
+function isDaytime(lat, lon, timestamp) {
+  var date = new Date(timestamp);
+
+  var _SunCalc$getTimes = _suncalc["default"].getTimes(date, lat, lon),
+      sunrise = _SunCalc$getTimes.sunrise,
+      sunset = _SunCalc$getTimes.sunset;
+
+  return date >= sunrise && date <= sunset;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9lZmZlY3QtdXRpbHMudHMiXSwibmFtZXMiOlsiY29tcHV0ZURlY2tFZmZlY3RzIiwidmlzU3RhdGUiLCJtYXBTdGF0ZSIsImVmZmVjdHMiLCJlZmZlY3RPcmRlciIsIm1hcCIsImVmZmVjdElkIiwiZmlsdGVyIiwiZWZmZWN0IiwiQm9vbGVhbiIsImNvbmZpZyIsImlzRW5hYmxlZCIsImRlY2tFZmZlY3QiLCJsaWdodFNoYWRvd0VmZmVjdCIsImZpbmQiLCJ0eXBlIiwiTElHSFRfQU5EX1NIQURPV19FRkZFQ1QiLCJ0aW1lc3RhbXAiLCJwYXJhbXMiLCJpc0RheXRpbWUiLCJsYXRpdHVkZSIsImxvbmdpdHVkZSIsInNoYWRvd0NvbG9yIiwibWVyZ2VFZmZlY3RQYXJhbXMiLCJleHRyYVBhcmFtcyIsInAxIiwicDIiLCJmaXhFZmZlY3RPcmRlciIsImluZCIsImluZGV4T2YiLCJpZCIsInNwbGljZSIsInVuc2hpZnQiLCJyZW9yZGVyRWZmZWN0T3JkZXIiLCJvcmlnaW5FZmZlY3RJZCIsImRlc3RpbmF0aW9uRWZmZWN0SWQiLCJhY3RpdmVJbmRleCIsIm92ZXJJbmRleCIsImxhdCIsImxvbiIsImRhdGUiLCJEYXRlIiwiU3VuQ2FsYyIsImdldFRpbWVzIiwic3VucmlzZSIsInN1bnNldCJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7QUFBQTs7QUFDQTs7QUFJQTs7QUFDQTs7Ozs7O0FBSU8sU0FBU0Esa0JBQVQsT0FNaUI7QUFBQSxNQUx0QkMsUUFLc0IsUUFMdEJBLFFBS3NCO0FBQUEsTUFKdEJDLFFBSXNCLFFBSnRCQSxRQUlzQjtBQUN0QixNQUFJQyxPQUFPLEdBQUdGLFFBQVEsQ0FBQ0csV0FBVCxDQUNYQyxHQURXLENBQ1AsVUFBQUMsUUFBUSxFQUFJO0FBQ2YsV0FBTyxxQkFBU0EsUUFBVCxFQUFtQkwsUUFBUSxDQUFDRSxPQUE1QixDQUFQO0FBQ0QsR0FIVyxFQUlYSSxNQUpXLENBSUosVUFBQUMsTUFBTTtBQUFBLFdBQUlDLE9BQU8sQ0FBQ0QsTUFBTSxJQUFJQSxNQUFNLENBQUNFLE1BQVAsQ0FBY0MsU0FBeEIsSUFBcUNILE1BQU0sQ0FBQ0ksVUFBN0MsQ0FBWDtBQUFBLEdBSkYsQ0FBZDtBQU1BLE1BQU1DLGlCQUFpQixHQUFHVixPQUFPLENBQUNXLElBQVIsQ0FBYSxVQUFBTixNQUFNO0FBQUEsV0FBSUEsTUFBTSxDQUFDTyxJQUFQLEtBQWdCQyxtQ0FBd0JELElBQTVDO0FBQUEsR0FBbkIsQ0FBMUI7O0FBQ0EsTUFBSUYsaUJBQUosRUFBdUI7QUFBQSxRQUNkSSxTQURjLEdBQ0RKLGlCQUFpQixDQUFDSCxNQUFsQixDQUF5QlEsTUFEeEIsQ0FDZEQsU0FEYzs7QUFFckIsUUFBSSxDQUFDRSxTQUFTLENBQUNqQixRQUFRLENBQUNrQixRQUFWLEVBQW9CbEIsUUFBUSxDQUFDbUIsU0FBN0IsRUFBd0NKLFNBQXhDLENBQWQsRUFBa0U7QUFDaEU7QUFDQTtBQUNBSixNQUFBQSxpQkFBaUIsQ0FBQ0QsVUFBbEIsQ0FBNkJVLFdBQTdCLENBQXlDLENBQXpDLElBQThDLENBQTlDO0FBQ0Q7QUFDRjs7QUFDRCxTQUFPbkIsT0FBTyxDQUFDRSxHQUFSLENBQVksVUFBQUcsTUFBTTtBQUFBLFdBQUlBLE1BQU0sQ0FBQ0ksVUFBWDtBQUFBLEdBQWxCLENBQVA7QUFDRDs7QUFFTSxTQUFTVyxpQkFBVCxDQUNMTCxNQURLLEVBRUxNLFdBRkssRUFHa0I7QUFDdkIsTUFBTUMsRUFBRSxHQUFHUCxNQUFNLElBQUksRUFBckI7QUFDQSxNQUFNUSxFQUFFLEdBQUdGLFdBQVcsSUFBSSxFQUExQjtBQUNBLHVEQUNLQyxFQURMLEdBRUtDLEVBRkw7QUFHRTtBQUNBaEIsSUFBQUEsTUFBTSxrQ0FDQWUsRUFBRSxDQUFDZixNQUFILElBQWEsRUFEYixHQUVBZ0IsRUFBRSxDQUFDaEIsTUFBSCxJQUFhLEVBRmI7QUFKUjtBQVNEO0FBRUQ7QUFDQTtBQUNBOzs7QUFDTyxJQUFNaUIsY0FBYyxHQUFHLFNBQWpCQSxjQUFpQixDQUFDeEIsT0FBRCxFQUFvQkMsV0FBcEIsRUFBd0Q7QUFDcEYsTUFBTVMsaUJBQWlCLEdBQUdWLE9BQU8sQ0FBQ1csSUFBUixDQUFhLFVBQUFOLE1BQU07QUFBQSxXQUFJQSxNQUFNLENBQUNPLElBQVAsS0FBZ0JDLG1DQUF3QkQsSUFBNUM7QUFBQSxHQUFuQixDQUExQjs7QUFDQSxNQUFJRixpQkFBSixFQUF1QjtBQUNyQixRQUFNZSxHQUFHLEdBQUd4QixXQUFXLENBQUN5QixPQUFaLENBQW9CaEIsaUJBQWlCLENBQUNpQixFQUF0QyxDQUFaOztBQUNBLFFBQUlGLEdBQUcsR0FBRyxDQUFWLEVBQWE7QUFDWHhCLE1BQUFBLFdBQVcsQ0FBQzJCLE1BQVosQ0FBbUJILEdBQW5CLEVBQXdCLENBQXhCO0FBQ0F4QixNQUFBQSxXQUFXLENBQUM0QixPQUFaLENBQW9CbkIsaUJBQWlCLENBQUNpQixFQUF0QztBQUNEO0FBQ0Y7O0FBQ0QsU0FBTzFCLFdBQVA7QUFDRCxDQVZNOzs7O0FBWUEsU0FBUzZCLGtCQUFULENBQ0w3QixXQURLLEVBRUw4QixjQUZLLEVBR0xDLG1CQUhLLEVBSUs7QUFDVixNQUFNQyxXQUFXLEdBQUdoQyxXQUFXLENBQUN5QixPQUFaLENBQW9CSyxjQUFwQixDQUFwQjtBQUNBLE1BQU1HLFNBQVMsR0FBR2pDLFdBQVcsQ0FBQ3lCLE9BQVosQ0FBb0JNLG1CQUFwQixDQUFsQjtBQUNBLFNBQU8seUJBQVUvQixXQUFWLEVBQXVCZ0MsV0FBdkIsRUFBb0NDLFNBQXBDLENBQVA7QUFDRDtBQUVEO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOzs7QUFDQSxTQUFTbEIsU0FBVCxDQUFtQm1CLEdBQW5CLEVBQXdCQyxHQUF4QixFQUE2QnRCLFNBQTdCLEVBQXdDO0FBQ3RDLE1BQU11QixJQUFJLEdBQUcsSUFBSUMsSUFBSixDQUFTeEIsU0FBVCxDQUFiOztBQURzQywwQkFFWnlCLG9CQUFRQyxRQUFSLENBQWlCSCxJQUFqQixFQUF1QkYsR0FBdkIsRUFBNEJDLEdBQTVCLENBRlk7QUFBQSxNQUUvQkssT0FGK0IscUJBRS9CQSxPQUYrQjtBQUFBLE1BRXRCQyxNQUZzQixxQkFFdEJBLE1BRnNCOztBQUd0QyxTQUFPTCxJQUFJLElBQUlJLE9BQVIsSUFBbUJKLElBQUksSUFBSUssTUFBbEM7QUFDRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7YXJyYXlNb3ZlfSBmcm9tICdAZG5kLWtpdC9zb3J0YWJsZSc7XG5pbXBvcnQgU3VuQ2FsYyBmcm9tICdzdW5jYWxjJztcblxuaW1wb3J0IHtQb3N0UHJvY2Vzc0VmZmVjdH0gZnJvbSAnQGRlY2suZ2wvY29yZS90eXBlZCc7XG5cbmltcG9ydCB7TElHSFRfQU5EX1NIQURPV19FRkZFQ1R9IGZyb20gJ0BrZXBsZXIuZ2wvY29uc3RhbnRzJztcbmltcG9ydCB7ZmluZEJ5SWR9IGZyb20gJy4vdXRpbHMnO1xuaW1wb3J0IHtWaXNTdGF0ZX0gZnJvbSAnQGtlcGxlci5nbC9zY2hlbWFzJztcbmltcG9ydCB7TWFwU3RhdGUsIEVmZmVjdFBhcmFtcywgRWZmZWN0fSBmcm9tICdAa2VwbGVyLmdsL3R5cGVzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGNvbXB1dGVEZWNrRWZmZWN0cyh7XG4gIHZpc1N0YXRlLFxuICBtYXBTdGF0ZVxufToge1xuICB2aXNTdGF0ZTogVmlzU3RhdGU7XG4gIG1hcFN0YXRlOiBNYXBTdGF0ZTtcbn0pOiBQb3N0UHJvY2Vzc0VmZmVjdFtdIHtcbiAgbGV0IGVmZmVjdHMgPSB2aXNTdGF0ZS5lZmZlY3RPcmRlclxuICAgIC5tYXAoZWZmZWN0SWQgPT4ge1xuICAgICAgcmV0dXJuIGZpbmRCeUlkKGVmZmVjdElkKSh2aXNTdGF0ZS5lZmZlY3RzKTtcbiAgICB9KVxuICAgIC5maWx0ZXIoZWZmZWN0ID0+IEJvb2xlYW4oZWZmZWN0ICYmIGVmZmVjdC5jb25maWcuaXNFbmFibGVkICYmIGVmZmVjdC5kZWNrRWZmZWN0KSkgYXMgRWZmZWN0W107XG5cbiAgY29uc3QgbGlnaHRTaGFkb3dFZmZlY3QgPSBlZmZlY3RzLmZpbmQoZWZmZWN0ID0+IGVmZmVjdC50eXBlID09PSBMSUdIVF9BTkRfU0hBRE9XX0VGRkVDVC50eXBlKTtcbiAgaWYgKGxpZ2h0U2hhZG93RWZmZWN0KSB7XG4gICAgY29uc3Qge3RpbWVzdGFtcH0gPSBsaWdodFNoYWRvd0VmZmVjdC5jb25maWcucGFyYW1zO1xuICAgIGlmICghaXNEYXl0aW1lKG1hcFN0YXRlLmxhdGl0dWRlLCBtYXBTdGF0ZS5sb25naXR1ZGUsIHRpbWVzdGFtcCkpIHtcbiAgICAgIC8vIFRPRE86IGludGVycG9sYXRlIGZvciBkdXNrL2Rhd25cbiAgICAgIC8vIFRPRE86IFNob3VsZCB3ZSBhdm9pZCBtdXRhdGluZyB0aGUgZWZmZWN0PyAoZGlkbid0IHdvcmsgd2hlbiB0cmllZCBkZWZlbnNpdmUgY29weWluZylcbiAgICAgIGxpZ2h0U2hhZG93RWZmZWN0LmRlY2tFZmZlY3Quc2hhZG93Q29sb3JbM10gPSAwO1xuICAgIH1cbiAgfVxuICByZXR1cm4gZWZmZWN0cy5tYXAoZWZmZWN0ID0+IGVmZmVjdC5kZWNrRWZmZWN0KTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIG1lcmdlRWZmZWN0UGFyYW1zKFxuICBwYXJhbXM6IFBhcnRpYWw8RWZmZWN0UGFyYW1zPixcbiAgZXh0cmFQYXJhbXM6IFBhcnRpYWw8RWZmZWN0UGFyYW1zPlxuKTogUGFydGlhbDxFZmZlY3RQYXJhbXM+IHtcbiAgY29uc3QgcDEgPSBwYXJhbXMgfHwge307XG4gIGNvbnN0IHAyID0gZXh0cmFQYXJhbXMgfHwge307XG4gIHJldHVybiB7XG4gICAgLi4ucDEsXG4gICAgLi4ucDIsXG4gICAgLy8gQHRzLWV4cGVjdC1lcnJvclxuICAgIGNvbmZpZzoge1xuICAgICAgLi4uKHAxLmNvbmZpZyB8fCB7fSksXG4gICAgICAuLi4ocDIuY29uZmlnIHx8IHt9KVxuICAgIH1cbiAgfTtcbn1cblxuLyoqXG4gKiBBbHdheXMga2VlcCBsaWdodCAmIHNoYWRvdyBlZmZlY3QgYXQgdGhlIHRvcFxuICovXG5leHBvcnQgY29uc3QgZml4RWZmZWN0T3JkZXIgPSAoZWZmZWN0czogRWZmZWN0W10sIGVmZmVjdE9yZGVyOiBzdHJpbmdbXSk6IHN0cmluZ1tdID0+IHtcbiAgY29uc3QgbGlnaHRTaGFkb3dFZmZlY3QgPSBlZmZlY3RzLmZpbmQoZWZmZWN0ID0+IGVmZmVjdC50eXBlID09PSBMSUdIVF9BTkRfU0hBRE9XX0VGRkVDVC50eXBlKTtcbiAgaWYgKGxpZ2h0U2hhZG93RWZmZWN0KSB7XG4gICAgY29uc3QgaW5kID0gZWZmZWN0T3JkZXIuaW5kZXhPZihsaWdodFNoYWRvd0VmZmVjdC5pZCk7XG4gICAgaWYgKGluZCA+IDApIHtcbiAgICAgIGVmZmVjdE9yZGVyLnNwbGljZShpbmQsIDEpO1xuICAgICAgZWZmZWN0T3JkZXIudW5zaGlmdChsaWdodFNoYWRvd0VmZmVjdC5pZCk7XG4gICAgfVxuICB9XG4gIHJldHVybiBlZmZlY3RPcmRlcjtcbn07XG5cbmV4cG9ydCBmdW5jdGlvbiByZW9yZGVyRWZmZWN0T3JkZXIoXG4gIGVmZmVjdE9yZGVyOiBzdHJpbmdbXSxcbiAgb3JpZ2luRWZmZWN0SWQ6IHN0cmluZyxcbiAgZGVzdGluYXRpb25FZmZlY3RJZDogc3RyaW5nXG4pOiBzdHJpbmdbXSB7XG4gIGNvbnN0IGFjdGl2ZUluZGV4ID0gZWZmZWN0T3JkZXIuaW5kZXhPZihvcmlnaW5FZmZlY3RJZCk7XG4gIGNvbnN0IG92ZXJJbmRleCA9IGVmZmVjdE9yZGVyLmluZGV4T2YoZGVzdGluYXRpb25FZmZlY3RJZCk7XG4gIHJldHVybiBhcnJheU1vdmUoZWZmZWN0T3JkZXIsIGFjdGl2ZUluZGV4LCBvdmVySW5kZXgpO1xufVxuXG4vKipcbiAqIENoZWNrIGlmIHRoZSBjdXJyZW50IHRpbWUgaXMgZGF5dGltZSBhdCB0aGUgZ2l2ZW4gbG9jYXRpb25cbiAqIEBwYXJhbSB7bnVtYmVyfSBsYXQgTGF0aXR1ZGVcbiAqIEBwYXJhbSB7bnVtYmVyfSBsb24gTG9uZ2l0dWRlXG4gKiBAcGFyYW0ge251bWJlcn0gdGltZXN0YW1wIE1pbGxpc2Vjb25kcyBzaW5jZSB0aGUgVW5peCBFcG9jaFxuICogQHJldHVybnMgYm9vbGVhblxuICovXG5mdW5jdGlvbiBpc0RheXRpbWUobGF0LCBsb24sIHRpbWVzdGFtcCkge1xuICBjb25zdCBkYXRlID0gbmV3IERhdGUodGltZXN0YW1wKTtcbiAgY29uc3Qge3N1bnJpc2UsIHN1bnNldH0gPSBTdW5DYWxjLmdldFRpbWVzKGRhdGUsIGxhdCwgbG9uKTtcbiAgcmV0dXJuIGRhdGUgPj0gc3VucmlzZSAmJiBkYXRlIDw9IHN1bnNldDtcbn1cbiJdfQ==

package/dist/export-map-html.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
+// Copyright (c) 2023 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
@@ -41,4 +41,4 @@ var exportMapToHTML = function exportMapToHTML(options) {
 };
 
 exports.exportMapToHTML = exportMapToHTML;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/export-map-html.ts"],"names":["exportMapToHTML","options","version","KEPLER_GL_VERSION","mapboxApiAccessToken","mode","EXPORT_HTML_MAP_MODES","READ","JSON","stringify","datasets","config"],"mappings":";;;;;;;AAqBA;;AArBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,eAAe,GAAG,SAAlBA,eAAkB,CAACC,OAAD,EAA0C;AAAA,MAAhCC,OAAgC,uEAAtBC,4BAAsB;AACvE,2hFAuCiDD,OAvCjD,qUAkDgCD,OAAO,CAACG,oBAAR,IAAgC,sBAlDhE,4lEA6F4BH,OAAO,CAACI,IAAR,KAAiBC,iCAAsBC,IA7FnE,ipNAgLgBN,OAAO,CAACI,IAAR,KAAiBC,iCAAsBC,IAAvC,GAA8C,YAA9C,GAA6D,EAhL7E,4xCAiN6BC,IAAI,CAACC,SAAL,CAAeR,OAAO,CAACS,QAAvB,CAjN7B,2CAkN2BF,IAAI,CAACC,SAAL,CAAeR,OAAO,CAACU,MAAvB,CAlN3B;AAqOD,CAtOM","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\n// @ts-nocheck\nimport {KEPLER_GL_VERSION, EXPORT_HTML_MAP_MODES} from '@kepler.gl/constants';\n\n/**\n * This method is used to create an html file which will inlcude kepler and map data\n * @param {Object} options Object that collects all necessary data to  create the html file\n * @param {string} options.mapboxApiAccessToken Mapbox token used to fetch mapbox tiles\n * @param {Array<Object>} options.datasets Data to include in the map\n * @param {Object} options.config this object will contain the full kepler.gl instance configuration {mapState, mapStyle, visState}\n * @param {string} version which version of Kepler.gl to load.\n */\nexport const exportMapToHTML = (options, version = KEPLER_GL_VERSION) => {\n  return `\n    <!DOCTYPE html>\n    <html>\n      <head>\n        <meta charset=\"UTF-8\"/>\n        <title>Kepler.gl embedded map</title>\n\n        <!--Uber Font-->\n        <link rel=\"stylesheet\" href=\"https://d1a3f4spazzrp4.cloudfront.net/kepler.gl/uber-fonts/4.0.0/superfine.css\">\n\n        <!--MapBox css-->\n        <link href=\"https://api.tiles.mapbox.com/mapbox-gl-js/v1.1.1/mapbox-gl.css\" rel=\"stylesheet\">\n\n        <!-— facebook open graph tags -->\n        <meta property=\"og:url\" content=\"http://kepler.gl/\" />\n        <meta property=\"og:title\" content=\"Large-scale WebGL-powered Geospatial Data Visualization Tool\" />\n        <meta property=\"og:description\" content=\"Kepler.gl is a powerful web-based geospatial data analysis tool. Built on a high performance rendering engine and designed for large-scale data sets.\" />\n        <meta property=\"og:site_name\" content=\"kepler.gl\" />\n        <meta property=\"og:image\" content=\"https://d1a3f4spazzrp4.cloudfront.net/kepler.gl/kepler.gl-meta-tag.png\" />\n        <meta property=\"og:image:type\" content=\"image/png\" />\n        <meta property=\"og:image:width\" content=\"800\" />\n        <meta property=\"og:image:height\" content=\"800\" />\n\n        <!-— twitter card tags -->\n        <meta name=\"twitter:card\" content=\"summary_large_image\">\n        <meta name=\"twitter:site\" content=\"@uber\">\n        <meta name=\"twitter:creator\" content=\"@uber\">\n        <meta name=\"twitter:title\" content=\"Large-scale WebGL-powered Geospatial Data Visualization Tool\">\n        <meta name=\"twitter:description\" content=\"Kepler.gl is a powerful web-based geospatial data analysis tool. Built on a high performance rendering engine and designed for large-scale data sets.\">\n        <meta name=\"twitter:image\" content=\"https://d1a3f4spazzrp4.cloudfront.net/kepler.gl/kepler.gl-meta-tag.png\" />\n\n        <!-- Load React/Redux -->\n        <script src=\"https://unpkg.com/react@16.8.4/umd/react.production.min.js\" crossorigin></script>\n        <script src=\"https://unpkg.com/react-dom@16.8.4/umd/react-dom.production.min.js\" crossorigin></script>\n        <script src=\"https://unpkg.com/redux@3.7.2/dist/redux.js\" crossorigin></script>\n        <script src=\"https://unpkg.com/react-redux@7.1.3/dist/react-redux.min.js\" crossorigin></script>\n        <script src=\"https://unpkg.com/styled-components@4.1.3/dist/styled-components.min.js\" crossorigin></script>\n\n        <!-- Load Kepler.gl -->\n        <script src=\"https://unpkg.com/kepler.gl@${version}/umd/keplergl.min.js\" crossorigin></script>\n\n        <style type=\"text/css\">\n          body {margin: 0; padding: 0; overflow: hidden;}\n        </style>\n\n        <!--MapBox token-->\n        <script>\n          /**\n           * Provide your MapBox Token\n           **/\n          const MAPBOX_TOKEN = '${options.mapboxApiAccessToken || 'PROVIDE_MAPBOX_TOKEN'}';\n          const WARNING_MESSAGE = 'Please Provide a Mapbox Token in order to use Kepler.gl. Edit this file and fill out MAPBOX_TOKEN with your access key';\n        </script>\n\n        <!-- GA: Delete this as you wish, However to pat ourselves on the back, we only track anonymous pageview to understand how many people are using kepler.gl. -->\n        <script>\n          (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){\n          (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),\n          m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)\n          })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');\n          ga('create', 'UA-64694404-19', {\n            'storage': 'none',\n            'clientId': localStorage.getItem('ga:clientId')\n          });\n          ga(function(tracker) {\n              localStorage.setItem('ga:clientId', tracker.get('clientId'));\n          });\n          ga('set', 'checkProtocolTask', null); // Disable file protocol checking.\n          ga('set', 'checkStorageTask', null); // Disable cookie storage checking.\n          ga('set', 'historyImportTask', null); // Disable history checking (requires reading from cookies).\n          ga('set', 'page', 'keplergl-html');\n          ga('send', 'pageview');\n        </script>\n      </head>\n      <body>\n        <!-- We will put our React component inside this div. -->\n        <div id=\"app\">\n          <!-- Kepler.gl map will be placed here-->\n        </div>\n\n        <!-- Load our React component. -->\n        <script>\n          /* Validate Mapbox Token */\n          if ((MAPBOX_TOKEN || '') === '' || MAPBOX_TOKEN === 'PROVIDE_MAPBOX_TOKEN') {\n            alert(WARNING_MESSAGE);\n          }\n\n          /** STORE **/\n          const reducers = (function createReducers(redux, keplerGl) {\n            return redux.combineReducers({\n              // mount keplerGl reducer\n              keplerGl: keplerGl.keplerGlReducer.initialState({\n                uiState: {\n                  readOnly: ${options.mode === EXPORT_HTML_MAP_MODES.READ},\n                  currentModal: null\n                }\n              })\n            });\n          }(Redux, KeplerGl));\n\n          const middleWares = (function createMiddlewares(keplerGl) {\n            return keplerGl.enhanceReduxMiddleware([\n              // Add other middlewares here\n            ]);\n          }(KeplerGl));\n\n          const enhancers = (function craeteEnhancers(redux, middles) {\n            return redux.applyMiddleware(...middles);\n          }(Redux, middleWares));\n\n          const store = (function createStore(redux, enhancers) {\n            const initialState = {};\n\n            return redux.createStore(\n              reducers,\n              initialState,\n              redux.compose(enhancers)\n            );\n          }(Redux, enhancers));\n          /** END STORE **/\n\n          /** COMPONENTS **/\n          var KeplerElement = (function makeKeplerElement(react, keplerGl, mapboxToken) {\n            var LogoSvg = function LogoSvg() {\n              return react.createElement(\n                \"div\",\n                { className: \"logo-container\", style: {position: 'fixed', zIndex: 10000, padding: '4px'} },\n                  react.createElement(\n                    \"svg\",\n                    {\n                      className: \"kepler_gl__logo\",\n                      width: \"107px\",\n                      height: \"21px\",\n                      viewBox: \"0 0 124 24\"\n                    },\n                    react.createElement(\n                      \"g\",\n                      { transform: \"translate(13.500000, 13.500000) rotate(45.000000) translate(-13.500000, -13.500000) translate(4.000000, 4.000000)\" },\n                      react.createElement(\"rect\", { x: \"0\", y: \"6\", transform: \"matrix(2.535181e-06 1 -1 2.535181e-06 18.1107 6.0369)\", fill: \"#535C6C\", width: \"12.1\", height: \"12.1\" }),\n                      react.createElement(\"rect\", { x: \"6\", y: \"0\", transform: \"matrix(2.535182e-06 1 -1 2.535182e-06 18.1107 -6.0369)\", fill:\"#1FBAD6\", width: \"12.1\", height: \"12.1\" })\n                    ),\n                    react.createElement(\n                      \"g\",\n                      {},\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M39,8.7h2.2l-2.8,4.2l2.9,5.1H39l-2.4-4.2h-1.3V18h-2V5l2-0.1v7.3h1.3L39,8.7z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M42.4,13.3c0-1.5,0.4-2.7,1.1-3.5s1.8-1.2,3.1-1.2c1.3,0,2.2,0.4,2.8,1.1c0.6,0.7,0.9,1.8,0.9,3.3 c0,0.4,0,0.8,0,1.1h-5.8c0,1.6,0.8,2.4,2.4,2.4c1,0,2-0.2,2.9-0.6l0.2,1.7c-0.4,0.2-0.9,0.4-1.4,0.5s-1.1,0.2-1.7,0.2 c-1.5,0-2.6-0.4-3.3-1.2C42.8,16.1,42.4,14.9,42.4,13.3z M46.6,10.1c-0.7,0-1.2,0.2-1.5,0.5c-0.4,0.4-0.6,0.9-0.6,1.7h4 c0-0.8-0.2-1.4-0.5-1.7S47.2,10.1,46.6,10.1z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M57.1,18.2c-1,0-1.8-0.3-2.3-0.9l0,0l0,1.3v2.5h-2V8.7h1.5l0.3,0.9h0c0.3-0.3,0.7-0.6,1.2-0.7 c0.4-0.2,0.9-0.3,1.4-0.3c1.2,0,2.1,0.4,2.7,1.1c0.6,0.7,0.9,2,0.9,3.7c0,1.6-0.3,2.8-1,3.7C59.2,17.8,58.3,18.2,57.1,18.2z M56.7,10.3c-0.4,0-0.8,0.1-1.1,0.2c-0.3,0.2-0.6,0.4-0.8,0.7v4.3c0.2,0.3,0.4,0.5,0.7,0.7c0.3,0.2,0.7,0.3,1.1,0.3 c0.7,0,1.2-0.2,1.6-0.7c0.4-0.5,0.5-1.3,0.5-2.5c0-0.8-0.1-1.4-0.2-1.8s-0.4-0.7-0.7-0.9C57.6,10.4,57.2,10.3,56.7,10.3z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M63.2,16V5l2-0.1v10.8c0,0.3,0.1,0.5,0.2,0.6c0.1,0.1,0.3,0.2,0.6,0.2c0.3,0,0.6,0,0.9-0.1V18 c-0.4,0.1-1,0.2-1.6,0.2c-0.8,0-1.3-0.2-1.7-0.5S63.2,16.8,63.2,16z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M68.2,13.3c0-1.5,0.4-2.7,1.1-3.5c0.7-0.8,1.8-1.2,3.1-1.2c1.3,0,2.2,0.4,2.8,1.1c0.6,0.7,0.9,1.8,0.9,3.3 c0,0.4,0,0.8,0,1.1h-5.8c0,1.6,0.8,2.4,2.4,2.4c1,0,2-0.2,2.9-0.6l0.2,1.7c-0.4,0.2-0.9,0.4-1.4,0.5s-1.1,0.2-1.7,0.2 c-1.5,0-2.6-0.4-3.3-1.2C68.6,16.1,68.2,14.9,68.2,13.3z M72.4,10.1c-0.7,0-1.2,0.2-1.5,0.5c-0.4,0.4-0.6,0.9-0.6,1.7h4 c0-0.8-0.2-1.4-0.5-1.7S73,10.1,72.4,10.1z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M80.2,8.7l0.1,1.7h0c0.3-0.6,0.7-1.1,1.1-1.4c0.4-0.3,1-0.5,1.6-0.5c0.4,0,0.7,0,1,0.1l-0.1,2 c-0.3-0.1-0.7-0.2-1-0.2c-0.7,0-1.3,0.3-1.7,0.8c-0.4,0.5-0.7,1.2-0.7,2.1V18h-2V8.7H80.2z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M83.8,17c0-0.8,0.4-1.2,1.2-1.2c0.8,0,1.2,0.4,1.2,1.2c0,0.8-0.4,1.1-1.2,1.1C84.2,18.2,83.8,17.8,83.8,17z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M88.5,18.7c0-0.8,0.4-1.4,1.2-1.8c-0.6-0.3-0.9-0.8-0.9-1.5c0-0.7,0.4-1.2,1.1-1.6c-0.3-0.3-0.6-0.6-0.7-0.9 c-0.2-0.4-0.2-0.8-0.2-1.3c0-1,0.3-1.8,0.9-2.3c0.6-0.5,1.6-0.8,2.8-0.8c0.5,0,1,0,1.4,0.1c0.4,0.1,0.8,0.2,1.1,0.4l2.4-0.2v1.5 h-1.5c0.2,0.4,0.2,0.8,0.2,1.3c0,1-0.3,1.7-0.9,2.2s-1.5,0.8-2.7,0.8c-0.7,0-1.2-0.1-1.6-0.2c-0.1,0.1-0.2,0.2-0.3,0.3 c-0.1,0.1-0.1,0.2-0.1,0.4c0,0.2,0.1,0.3,0.2,0.4c0.1,0.1,0.3,0.2,0.6,0.2l2.7,0.2c1,0.1,1.7,0.3,2.2,0.6c0.5,0.3,0.8,0.9,0.8,1.7 c0,0.6-0.2,1.1-0.5,1.5c-0.4,0.4-0.9,0.8-1.5,1c-0.7,0.2-1.5,0.4-2.4,0.4c-1.3,0-2.3-0.2-3-0.6C88.8,20.1,88.5,19.5,88.5,18.7z M95.1,18.4c0-0.3-0.1-0.5-0.3-0.7s-0.6-0.2-1.1-0.3l-2.7-0.3c-0.2,0.1-0.4,0.3-0.5,0.5c-0.1,0.2-0.2,0.4-0.2,0.6 c0,0.4,0.2,0.8,0.5,1c0.4,0.2,1,0.3,1.8,0.3C94.2,19.5,95.1,19.2,95.1,18.4z M94.3,11.5c0-0.6-0.1-1-0.4-1.2 c-0.3-0.2-0.7-0.3-1.3-0.3c-0.7,0-1.1,0.1-1.4,0.3c-0.3,0.2-0.4,0.6-0.4,1.2s0.1,1,0.4,1.2c0.3,0.2,0.7,0.3,1.4,0.3 c0.6,0,1.1-0.1,1.3-0.4S94.3,12,94.3,11.5z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M99.4,16V5l2-0.1v10.8c0,0.3,0.1,0.5,0.2,0.6c0.1,0.1,0.3,0.2,0.6,0.2c0.3,0,0.6,0,0.9-0.1V18 c-0.4,0.1-1,0.2-1.6,0.2c-0.8,0-1.3-0.2-1.7-0.5S99.4,16.8,99.4,16z\" })\n                    )\n                  )\n                );\n              };\n\n            return function App() {\n              var rootElm = react.useRef(null);\n              var _useState = react.useState({\n                width: window.innerWidth,\n                height: window.innerHeight\n              });\n              var windowDimension = _useState[0];\n              var setDimension = _useState[1];\n              react.useEffect(function sideEffect(){\n                function handleResize() {\n                  setDimension({width: window.innerWidth, height: window.innerHeight});\n                };\n                window.addEventListener('resize', handleResize);\n                return function() {window.removeEventListener('resize', handleResize);};\n              }, []);\n              return react.createElement(\n                'div',\n                {style: {position: 'absolute', left: 0, width: '100vw', height: '100vh'}},\n                ${options.mode === EXPORT_HTML_MAP_MODES.READ ? 'LogoSvg(),' : ''}\n                react.createElement(keplerGl.KeplerGl, {\n                  mapboxApiAccessToken: mapboxToken,\n                  id: \"map\",\n                  width: windowDimension.width,\n                  height: windowDimension.height\n                })\n              )\n            }\n          }(React, KeplerGl, MAPBOX_TOKEN));\n\n          const app = (function createReactReduxProvider(react, reactRedux, KeplerElement) {\n            return react.createElement(\n              reactRedux.Provider,\n              {store},\n              react.createElement(KeplerElement, null)\n            )\n          }(React, ReactRedux, KeplerElement));\n          /** END COMPONENTS **/\n\n          /** Render **/\n          (function render(react, reactDOM, app) {\n            reactDOM.render(app, document.getElementById('app'));\n          }(React, ReactDOM, app));\n        </script>\n        <!-- The next script will show how to interact directly with Kepler map store -->\n        <script>\n          /**\n           * Customize map.\n           * In the following section you can use the store object to dispatch Kepler.gl actions\n           * to add new data and customize behavior\n           */\n          (function customize(keplerGl, store) {\n            const datasets = ${JSON.stringify(options.datasets)};\n            const config = ${JSON.stringify(options.config)};\n\n            const loadedData = keplerGl.KeplerGlSchema.load(\n              datasets,\n              config\n            );\n\n            store.dispatch(keplerGl.addDataToMap({\n              datasets: loadedData.datasets,\n              config: loadedData.config,\n              options: {\n                centerMap: false\n              }\n            }));\n          }(KeplerGl, store))\n        </script>\n      </body>\n    </html>\n  `;\n};\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/export-map-html.ts"],"names":["exportMapToHTML","options","version","KEPLER_GL_VERSION","mapboxApiAccessToken","mode","EXPORT_HTML_MAP_MODES","READ","JSON","stringify","datasets","config"],"mappings":";;;;;;;AAqBA;;AArBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,eAAe,GAAG,SAAlBA,eAAkB,CAACC,OAAD,EAA0C;AAAA,MAAhCC,OAAgC,uEAAtBC,4BAAsB;AACvE,2hFAuCiDD,OAvCjD,qUAkDgCD,OAAO,CAACG,oBAAR,IAAgC,sBAlDhE,4lEA6F4BH,OAAO,CAACI,IAAR,KAAiBC,iCAAsBC,IA7FnE,ipNAgLgBN,OAAO,CAACI,IAAR,KAAiBC,iCAAsBC,IAAvC,GAA8C,YAA9C,GAA6D,EAhL7E,4xCAiN6BC,IAAI,CAACC,SAAL,CAAeR,OAAO,CAACS,QAAvB,CAjN7B,2CAkN2BF,IAAI,CAACC,SAAL,CAAeR,OAAO,CAACU,MAAvB,CAlN3B;AAqOD,CAtOM","sourcesContent":["// Copyright (c) 2023 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\n// @ts-nocheck\nimport {KEPLER_GL_VERSION, EXPORT_HTML_MAP_MODES} from '@kepler.gl/constants';\n\n/**\n * This method is used to create an html file which will inlcude kepler and map data\n * @param {Object} options Object that collects all necessary data to  create the html file\n * @param {string} options.mapboxApiAccessToken Mapbox token used to fetch mapbox tiles\n * @param {Array<Object>} options.datasets Data to include in the map\n * @param {Object} options.config this object will contain the full kepler.gl instance configuration {mapState, mapStyle, visState}\n * @param {string} version which version of Kepler.gl to load.\n */\nexport const exportMapToHTML = (options, version = KEPLER_GL_VERSION) => {\n  return `\n    <!DOCTYPE html>\n    <html>\n      <head>\n        <meta charset=\"UTF-8\"/>\n        <title>Kepler.gl embedded map</title>\n\n        <!--Uber Font-->\n        <link rel=\"stylesheet\" href=\"https://d1a3f4spazzrp4.cloudfront.net/kepler.gl/uber-fonts/4.0.0/superfine.css\">\n\n        <!--MapBox css-->\n        <link href=\"https://api.tiles.mapbox.com/mapbox-gl-js/v1.1.1/mapbox-gl.css\" rel=\"stylesheet\">\n\n        <!-— facebook open graph tags -->\n        <meta property=\"og:url\" content=\"http://kepler.gl/\" />\n        <meta property=\"og:title\" content=\"Large-scale WebGL-powered Geospatial Data Visualization Tool\" />\n        <meta property=\"og:description\" content=\"Kepler.gl is a powerful web-based geospatial data analysis tool. Built on a high performance rendering engine and designed for large-scale data sets.\" />\n        <meta property=\"og:site_name\" content=\"kepler.gl\" />\n        <meta property=\"og:image\" content=\"https://d1a3f4spazzrp4.cloudfront.net/kepler.gl/kepler.gl-meta-tag.png\" />\n        <meta property=\"og:image:type\" content=\"image/png\" />\n        <meta property=\"og:image:width\" content=\"800\" />\n        <meta property=\"og:image:height\" content=\"800\" />\n\n        <!-— twitter card tags -->\n        <meta name=\"twitter:card\" content=\"summary_large_image\">\n        <meta name=\"twitter:site\" content=\"@uber\">\n        <meta name=\"twitter:creator\" content=\"@uber\">\n        <meta name=\"twitter:title\" content=\"Large-scale WebGL-powered Geospatial Data Visualization Tool\">\n        <meta name=\"twitter:description\" content=\"Kepler.gl is a powerful web-based geospatial data analysis tool. Built on a high performance rendering engine and designed for large-scale data sets.\">\n        <meta name=\"twitter:image\" content=\"https://d1a3f4spazzrp4.cloudfront.net/kepler.gl/kepler.gl-meta-tag.png\" />\n\n        <!-- Load React/Redux -->\n        <script src=\"https://unpkg.com/react@16.8.4/umd/react.production.min.js\" crossorigin></script>\n        <script src=\"https://unpkg.com/react-dom@16.8.4/umd/react-dom.production.min.js\" crossorigin></script>\n        <script src=\"https://unpkg.com/redux@3.7.2/dist/redux.js\" crossorigin></script>\n        <script src=\"https://unpkg.com/react-redux@7.1.3/dist/react-redux.min.js\" crossorigin></script>\n        <script src=\"https://unpkg.com/styled-components@4.1.3/dist/styled-components.min.js\" crossorigin></script>\n\n        <!-- Load Kepler.gl -->\n        <script src=\"https://unpkg.com/kepler.gl@${version}/umd/keplergl.min.js\" crossorigin></script>\n\n        <style type=\"text/css\">\n          body {margin: 0; padding: 0; overflow: hidden;}\n        </style>\n\n        <!--MapBox token-->\n        <script>\n          /**\n           * Provide your MapBox Token\n           **/\n          const MAPBOX_TOKEN = '${options.mapboxApiAccessToken || 'PROVIDE_MAPBOX_TOKEN'}';\n          const WARNING_MESSAGE = 'Please Provide a Mapbox Token in order to use Kepler.gl. Edit this file and fill out MAPBOX_TOKEN with your access key';\n        </script>\n\n        <!-- GA: Delete this as you wish, However to pat ourselves on the back, we only track anonymous pageview to understand how many people are using kepler.gl. -->\n        <script>\n          (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){\n          (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),\n          m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)\n          })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');\n          ga('create', 'UA-64694404-19', {\n            'storage': 'none',\n            'clientId': localStorage.getItem('ga:clientId')\n          });\n          ga(function(tracker) {\n              localStorage.setItem('ga:clientId', tracker.get('clientId'));\n          });\n          ga('set', 'checkProtocolTask', null); // Disable file protocol checking.\n          ga('set', 'checkStorageTask', null); // Disable cookie storage checking.\n          ga('set', 'historyImportTask', null); // Disable history checking (requires reading from cookies).\n          ga('set', 'page', 'keplergl-html');\n          ga('send', 'pageview');\n        </script>\n      </head>\n      <body>\n        <!-- We will put our React component inside this div. -->\n        <div id=\"app\">\n          <!-- Kepler.gl map will be placed here-->\n        </div>\n\n        <!-- Load our React component. -->\n        <script>\n          /* Validate Mapbox Token */\n          if ((MAPBOX_TOKEN || '') === '' || MAPBOX_TOKEN === 'PROVIDE_MAPBOX_TOKEN') {\n            alert(WARNING_MESSAGE);\n          }\n\n          /** STORE **/\n          const reducers = (function createReducers(redux, keplerGl) {\n            return redux.combineReducers({\n              // mount keplerGl reducer\n              keplerGl: keplerGl.keplerGlReducer.initialState({\n                uiState: {\n                  readOnly: ${options.mode === EXPORT_HTML_MAP_MODES.READ},\n                  currentModal: null\n                }\n              })\n            });\n          }(Redux, KeplerGl));\n\n          const middleWares = (function createMiddlewares(keplerGl) {\n            return keplerGl.enhanceReduxMiddleware([\n              // Add other middlewares here\n            ]);\n          }(KeplerGl));\n\n          const enhancers = (function craeteEnhancers(redux, middles) {\n            return redux.applyMiddleware(...middles);\n          }(Redux, middleWares));\n\n          const store = (function createStore(redux, enhancers) {\n            const initialState = {};\n\n            return redux.createStore(\n              reducers,\n              initialState,\n              redux.compose(enhancers)\n            );\n          }(Redux, enhancers));\n          /** END STORE **/\n\n          /** COMPONENTS **/\n          var KeplerElement = (function makeKeplerElement(react, keplerGl, mapboxToken) {\n            var LogoSvg = function LogoSvg() {\n              return react.createElement(\n                \"div\",\n                { className: \"logo-container\", style: {position: 'fixed', zIndex: 10000, padding: '4px'} },\n                  react.createElement(\n                    \"svg\",\n                    {\n                      className: \"kepler_gl__logo\",\n                      width: \"107px\",\n                      height: \"21px\",\n                      viewBox: \"0 0 124 24\"\n                    },\n                    react.createElement(\n                      \"g\",\n                      { transform: \"translate(13.500000, 13.500000) rotate(45.000000) translate(-13.500000, -13.500000) translate(4.000000, 4.000000)\" },\n                      react.createElement(\"rect\", { x: \"0\", y: \"6\", transform: \"matrix(2.535181e-06 1 -1 2.535181e-06 18.1107 6.0369)\", fill: \"#535C6C\", width: \"12.1\", height: \"12.1\" }),\n                      react.createElement(\"rect\", { x: \"6\", y: \"0\", transform: \"matrix(2.535182e-06 1 -1 2.535182e-06 18.1107 -6.0369)\", fill:\"#1FBAD6\", width: \"12.1\", height: \"12.1\" })\n                    ),\n                    react.createElement(\n                      \"g\",\n                      {},\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M39,8.7h2.2l-2.8,4.2l2.9,5.1H39l-2.4-4.2h-1.3V18h-2V5l2-0.1v7.3h1.3L39,8.7z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M42.4,13.3c0-1.5,0.4-2.7,1.1-3.5s1.8-1.2,3.1-1.2c1.3,0,2.2,0.4,2.8,1.1c0.6,0.7,0.9,1.8,0.9,3.3 c0,0.4,0,0.8,0,1.1h-5.8c0,1.6,0.8,2.4,2.4,2.4c1,0,2-0.2,2.9-0.6l0.2,1.7c-0.4,0.2-0.9,0.4-1.4,0.5s-1.1,0.2-1.7,0.2 c-1.5,0-2.6-0.4-3.3-1.2C42.8,16.1,42.4,14.9,42.4,13.3z M46.6,10.1c-0.7,0-1.2,0.2-1.5,0.5c-0.4,0.4-0.6,0.9-0.6,1.7h4 c0-0.8-0.2-1.4-0.5-1.7S47.2,10.1,46.6,10.1z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M57.1,18.2c-1,0-1.8-0.3-2.3-0.9l0,0l0,1.3v2.5h-2V8.7h1.5l0.3,0.9h0c0.3-0.3,0.7-0.6,1.2-0.7 c0.4-0.2,0.9-0.3,1.4-0.3c1.2,0,2.1,0.4,2.7,1.1c0.6,0.7,0.9,2,0.9,3.7c0,1.6-0.3,2.8-1,3.7C59.2,17.8,58.3,18.2,57.1,18.2z M56.7,10.3c-0.4,0-0.8,0.1-1.1,0.2c-0.3,0.2-0.6,0.4-0.8,0.7v4.3c0.2,0.3,0.4,0.5,0.7,0.7c0.3,0.2,0.7,0.3,1.1,0.3 c0.7,0,1.2-0.2,1.6-0.7c0.4-0.5,0.5-1.3,0.5-2.5c0-0.8-0.1-1.4-0.2-1.8s-0.4-0.7-0.7-0.9C57.6,10.4,57.2,10.3,56.7,10.3z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M63.2,16V5l2-0.1v10.8c0,0.3,0.1,0.5,0.2,0.6c0.1,0.1,0.3,0.2,0.6,0.2c0.3,0,0.6,0,0.9-0.1V18 c-0.4,0.1-1,0.2-1.6,0.2c-0.8,0-1.3-0.2-1.7-0.5S63.2,16.8,63.2,16z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M68.2,13.3c0-1.5,0.4-2.7,1.1-3.5c0.7-0.8,1.8-1.2,3.1-1.2c1.3,0,2.2,0.4,2.8,1.1c0.6,0.7,0.9,1.8,0.9,3.3 c0,0.4,0,0.8,0,1.1h-5.8c0,1.6,0.8,2.4,2.4,2.4c1,0,2-0.2,2.9-0.6l0.2,1.7c-0.4,0.2-0.9,0.4-1.4,0.5s-1.1,0.2-1.7,0.2 c-1.5,0-2.6-0.4-3.3-1.2C68.6,16.1,68.2,14.9,68.2,13.3z M72.4,10.1c-0.7,0-1.2,0.2-1.5,0.5c-0.4,0.4-0.6,0.9-0.6,1.7h4 c0-0.8-0.2-1.4-0.5-1.7S73,10.1,72.4,10.1z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M80.2,8.7l0.1,1.7h0c0.3-0.6,0.7-1.1,1.1-1.4c0.4-0.3,1-0.5,1.6-0.5c0.4,0,0.7,0,1,0.1l-0.1,2 c-0.3-0.1-0.7-0.2-1-0.2c-0.7,0-1.3,0.3-1.7,0.8c-0.4,0.5-0.7,1.2-0.7,2.1V18h-2V8.7H80.2z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M83.8,17c0-0.8,0.4-1.2,1.2-1.2c0.8,0,1.2,0.4,1.2,1.2c0,0.8-0.4,1.1-1.2,1.1C84.2,18.2,83.8,17.8,83.8,17z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M88.5,18.7c0-0.8,0.4-1.4,1.2-1.8c-0.6-0.3-0.9-0.8-0.9-1.5c0-0.7,0.4-1.2,1.1-1.6c-0.3-0.3-0.6-0.6-0.7-0.9 c-0.2-0.4-0.2-0.8-0.2-1.3c0-1,0.3-1.8,0.9-2.3c0.6-0.5,1.6-0.8,2.8-0.8c0.5,0,1,0,1.4,0.1c0.4,0.1,0.8,0.2,1.1,0.4l2.4-0.2v1.5 h-1.5c0.2,0.4,0.2,0.8,0.2,1.3c0,1-0.3,1.7-0.9,2.2s-1.5,0.8-2.7,0.8c-0.7,0-1.2-0.1-1.6-0.2c-0.1,0.1-0.2,0.2-0.3,0.3 c-0.1,0.1-0.1,0.2-0.1,0.4c0,0.2,0.1,0.3,0.2,0.4c0.1,0.1,0.3,0.2,0.6,0.2l2.7,0.2c1,0.1,1.7,0.3,2.2,0.6c0.5,0.3,0.8,0.9,0.8,1.7 c0,0.6-0.2,1.1-0.5,1.5c-0.4,0.4-0.9,0.8-1.5,1c-0.7,0.2-1.5,0.4-2.4,0.4c-1.3,0-2.3-0.2-3-0.6C88.8,20.1,88.5,19.5,88.5,18.7z M95.1,18.4c0-0.3-0.1-0.5-0.3-0.7s-0.6-0.2-1.1-0.3l-2.7-0.3c-0.2,0.1-0.4,0.3-0.5,0.5c-0.1,0.2-0.2,0.4-0.2,0.6 c0,0.4,0.2,0.8,0.5,1c0.4,0.2,1,0.3,1.8,0.3C94.2,19.5,95.1,19.2,95.1,18.4z M94.3,11.5c0-0.6-0.1-1-0.4-1.2 c-0.3-0.2-0.7-0.3-1.3-0.3c-0.7,0-1.1,0.1-1.4,0.3c-0.3,0.2-0.4,0.6-0.4,1.2s0.1,1,0.4,1.2c0.3,0.2,0.7,0.3,1.4,0.3 c0.6,0,1.1-0.1,1.3-0.4S94.3,12,94.3,11.5z\" }),\n                      react.createElement(\"path\", { fill:\"#1FBAD6\", d: \"M99.4,16V5l2-0.1v10.8c0,0.3,0.1,0.5,0.2,0.6c0.1,0.1,0.3,0.2,0.6,0.2c0.3,0,0.6,0,0.9-0.1V18 c-0.4,0.1-1,0.2-1.6,0.2c-0.8,0-1.3-0.2-1.7-0.5S99.4,16.8,99.4,16z\" })\n                    )\n                  )\n                );\n              };\n\n            return function App() {\n              var rootElm = react.useRef(null);\n              var _useState = react.useState({\n                width: window.innerWidth,\n                height: window.innerHeight\n              });\n              var windowDimension = _useState[0];\n              var setDimension = _useState[1];\n              react.useEffect(function sideEffect(){\n                function handleResize() {\n                  setDimension({width: window.innerWidth, height: window.innerHeight});\n                };\n                window.addEventListener('resize', handleResize);\n                return function() {window.removeEventListener('resize', handleResize);};\n              }, []);\n              return react.createElement(\n                'div',\n                {style: {position: 'absolute', left: 0, width: '100vw', height: '100vh'}},\n                ${options.mode === EXPORT_HTML_MAP_MODES.READ ? 'LogoSvg(),' : ''}\n                react.createElement(keplerGl.KeplerGl, {\n                  mapboxApiAccessToken: mapboxToken,\n                  id: \"map\",\n                  width: windowDimension.width,\n                  height: windowDimension.height\n                })\n              )\n            }\n          }(React, KeplerGl, MAPBOX_TOKEN));\n\n          const app = (function createReactReduxProvider(react, reactRedux, KeplerElement) {\n            return react.createElement(\n              reactRedux.Provider,\n              {store},\n              react.createElement(KeplerElement, null)\n            )\n          }(React, ReactRedux, KeplerElement));\n          /** END COMPONENTS **/\n\n          /** Render **/\n          (function render(react, reactDOM, app) {\n            reactDOM.render(app, document.getElementById('app'));\n          }(React, ReactDOM, app));\n        </script>\n        <!-- The next script will show how to interact directly with Kepler map store -->\n        <script>\n          /**\n           * Customize map.\n           * In the following section you can use the store object to dispatch Kepler.gl actions\n           * to add new data and customize behavior\n           */\n          (function customize(keplerGl, store) {\n            const datasets = ${JSON.stringify(options.datasets)};\n            const config = ${JSON.stringify(options.config)};\n\n            const loadedData = keplerGl.KeplerGlSchema.load(\n              datasets,\n              config\n            );\n\n            store.dispatch(keplerGl.addDataToMap({\n              datasets: loadedData.datasets,\n              config: loadedData.config,\n              options: {\n                centerMap: false\n              }\n            }));\n          }(KeplerGl, store))\n        </script>\n      </body>\n    </html>\n  `;\n};\n"]}

package/dist/export-utils.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
+// Copyright (c) 2023 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
@@ -171,9 +171,17 @@ function downloadFile(fileBlob, fileName) {
     link.setAttribute('href', url);
     link.setAttribute('download', fileName);
 
-    _window.document.body.appendChild(link);
+    _window.document.body.appendChild(link); // in some cases where maps are embedded, e.g. need to
+    // create and dispatch an event so that the browser downloads
+    // the file instead of navigating to the url
 
-    link.click();
+
+    var evt = new MouseEvent('click', {
+      view: window,
+      bubbles: false,
+      cancelable: true
+    });
+    link.dispatchEvent(evt);
 
     _window.document.body.removeChild(link);
 
@@ -229,6 +237,7 @@ function getMapJSON(state) {
 function exportJson(state) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var map = getMapJSON(state, options);
+  map.info.source = 'kepler.gl';
   var fileBlob = new _window.Blob([exportToJsonString(map)], {
     type: 'application/json'
   });
@@ -270,4 +279,4 @@ var exporters = {
 };
 var _default = exporters;
 exports["default"] = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/export-utils.ts"],"names":["DEFAULT_IMAGE_NAME","DEFAULT_HTML_NAME","DEFAULT_JSON_NAME","DEFAULT_DATA_NAME","DEFAULT_EXPORT_JSON_SETTINGS","hasData","defaultResolution","OneXResolutionOption","defaultRatio","FourByThreeRatioOption","isMSEdge","window","Boolean","navigator","msSaveOrOpenBlob","getScaleFromImageSize","imageW","imageH","mapW","mapH","some","d","base","mapBase","calculateExportImageSize","ratio","resolution","ratioItem","EXPORT_IMG_RATIO_OPTIONS","find","op","id","resolutionItem","EXPORT_IMG_RESOLUTION_OPTIONS","getSize","scaledWidth","width","scaledHeight","height","EXPORT_IMG_RATIOS","CUSTOM","scale","undefined","convertToPng","sourceElem","options","domtoimage","toPng","dataURItoBlob","dataURI","binary","split","mimeString","ab","ArrayBuffer","length","ia","Uint8Array","i","charCodeAt","Blob","type","downloadFile","fileBlob","fileName","url","URL","createObjectURL","link","document","createElement","setAttribute","body","appendChild","click","removeChild","revokeObjectURL","exportImage","uiStateExportImage","filename","imageDataUri","file","exportToJsonString","data","JSON","stringify","e","TypeError","message","description","getMapJSON","state","schema","visState","getConfigToSave","mapToSave","save","title","exportJson","map","appName","exportHtml","userMapboxToken","exportMapboxAccessToken","mode","mapboxApiAccessToken","exportMap","uiState","thumbnail","exporters"],"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 {Blob, URL, atob, Uint8Array, ArrayBuffer, document} from 'global/window';\nimport get from 'lodash.get';\n\nimport {\n  EXPORT_IMG_RESOLUTION_OPTIONS,\n  EXPORT_IMG_RATIO_OPTIONS,\n  RESOLUTIONS,\n  EXPORT_IMG_RATIOS,\n  FourByThreeRatioOption,\n  OneXResolutionOption,\n  ExportImage\n} from '@kepler.gl/constants';\nimport domtoimage from './dom-to-image';\nimport {generateHashId, set} from './utils';\nimport {exportMapToHTML} from './export-map-html';\n\n/**\n * Default file names\n */\nexport const DEFAULT_IMAGE_NAME = 'kepler.gl.png';\nexport const DEFAULT_HTML_NAME = 'kepler.gl.html';\nexport const DEFAULT_JSON_NAME = 'kepler.gl.json';\nexport const DEFAULT_DATA_NAME = 'kepler.gl';\n\n/**\n * Default json export settings\n */\nexport const DEFAULT_EXPORT_JSON_SETTINGS = {\n  hasData: true\n};\n\nconst defaultResolution = OneXResolutionOption;\n\nconst defaultRatio = FourByThreeRatioOption;\n\nexport function isMSEdge(window: Window): boolean {\n  // @ts-ignore msSaveOrOpenBlob was a proprietary addition to the Navigator object, added by Microsoft for Internet Explorer.\n  return Boolean(window.navigator && window.navigator.msSaveOrOpenBlob);\n}\n\nexport function getScaleFromImageSize(imageW = 0, imageH = 0, mapW = 0, mapH = 0) {\n  if ([imageW, imageH, mapW, mapH].some(d => d <= 0)) {\n    return 1;\n  }\n\n  const base = imageW / imageH > 1 ? imageW : imageH;\n  const mapBase = imageW / imageH > 1 ? mapW : mapH;\n  return base / mapBase;\n}\n\nexport function calculateExportImageSize({\n  mapW,\n  mapH,\n  ratio,\n  resolution\n}: {\n  mapW: number;\n  mapH: number;\n  ratio: keyof typeof EXPORT_IMG_RATIOS;\n  resolution: keyof typeof RESOLUTIONS;\n}) {\n  if (mapW <= 0 || mapH <= 0) {\n    return null;\n  }\n\n  const ratioItem = EXPORT_IMG_RATIO_OPTIONS.find(op => op.id === ratio) || defaultRatio;\n\n  const resolutionItem =\n    EXPORT_IMG_RESOLUTION_OPTIONS.find(op => op.id === resolution) || defaultResolution;\n\n  const {width: scaledWidth, height: scaledHeight} = resolutionItem.getSize(mapW, mapH);\n\n  const {width: imageW, height: imageH} = ratioItem.getSize(scaledWidth, scaledHeight);\n\n  const {scale} = ratioItem.id === EXPORT_IMG_RATIOS.CUSTOM ? {scale: undefined} : resolutionItem;\n\n  return {\n    scale,\n    imageW,\n    imageH\n  };\n}\n\nexport function convertToPng(sourceElem: HTMLElement, options) {\n  return domtoimage.toPng(sourceElem, options);\n}\n\nexport function dataURItoBlob(dataURI: string): Blob {\n  const binary = atob(dataURI.split(',')[1]);\n\n  // separate out the mime component\n  const mimeString = dataURI\n    .split(',')[0]\n    .split(':')[1]\n    .split(';')[0];\n\n  // write the bytes of the string to an ArrayBuffer\n  const ab = new ArrayBuffer(binary.length);\n\n  // create a view into the buffer\n  const ia = new Uint8Array(ab);\n\n  for (let i = 0; i < binary.length; i++) {\n    ia[i] = binary.charCodeAt(i);\n  }\n\n  return new Blob([ab], {type: mimeString});\n}\n\nexport function downloadFile(fileBlob: Blob, fileName: string) {\n  if (isMSEdge(window)) {\n    (window.navigator as any).msSaveOrOpenBlob(fileBlob, fileName);\n  } else {\n    const url = URL.createObjectURL(fileBlob);\n\n    const link = document.createElement('a');\n    link.setAttribute('href', url);\n    link.setAttribute('download', fileName);\n\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n    URL.revokeObjectURL(url);\n  }\n}\n\n/**\n * Whether color is rgb\n * @returns\n */\nexport function exportImage(uiStateExportImage: ExportImage, filename = DEFAULT_IMAGE_NAME) {\n  const {imageDataUri} = uiStateExportImage;\n  if (imageDataUri) {\n    const file = dataURItoBlob(imageDataUri);\n    downloadFile(file, filename);\n  }\n}\n\nexport function exportToJsonString(data) {\n  try {\n    return JSON.stringify(data);\n  } catch (e) {\n    if (e instanceof TypeError) return e.message;\n    // Non-Standard Error Object Property\n    return (e as any).description;\n  }\n}\n\nexport function getMapJSON(state, options = DEFAULT_EXPORT_JSON_SETTINGS) {\n  const {hasData} = options;\n  const schema = state.visState.schema;\n\n  if (!hasData) {\n    return schema.getConfigToSave(state);\n  }\n\n  let mapToSave = schema.save(state);\n  // add file name if title is not provided\n  const title = get(mapToSave, ['info', 'title']);\n  if (!title || !title.length) {\n    mapToSave = set(['info', 'title'], `keplergl_${generateHashId(6)}`, mapToSave);\n  }\n  return mapToSave;\n}\n\nexport function exportJson(state, options: any = {}) {\n  const map = getMapJSON(state, options);\n\n  const fileBlob = new Blob([exportToJsonString(map)], {type: 'application/json'});\n  const fileName = state.appName ? `${state.appName}.json` : DEFAULT_JSON_NAME;\n  downloadFile(fileBlob, fileName);\n}\n\nexport function exportHtml(state, options) {\n  const {userMapboxToken, exportMapboxAccessToken, mode} = options;\n\n  const data = {\n    ...getMapJSON(state),\n    mapboxApiAccessToken:\n      (userMapboxToken || '') !== '' ? userMapboxToken : exportMapboxAccessToken,\n    mode\n  };\n\n  const fileBlob = new Blob([exportMapToHTML(data)], {type: 'text/html'});\n  downloadFile(fileBlob, state.appName ? `${state.appName}.html` : DEFAULT_HTML_NAME);\n}\n\nexport function exportMap(state, options = DEFAULT_EXPORT_JSON_SETTINGS) {\n  const {imageDataUri} = state.uiState.exportImage;\n  const thumbnail: Blob | null = imageDataUri ? dataURItoBlob(imageDataUri) : null;\n  const mapToSave = getMapJSON(state, options);\n\n  return {\n    map: mapToSave,\n    thumbnail\n  };\n}\n\nconst exporters = {\n  exportImage,\n  exportJson,\n  exportHtml\n};\n\nexport default exporters;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/export-utils.ts"],"names":["DEFAULT_IMAGE_NAME","DEFAULT_HTML_NAME","DEFAULT_JSON_NAME","DEFAULT_DATA_NAME","DEFAULT_EXPORT_JSON_SETTINGS","hasData","defaultResolution","OneXResolutionOption","defaultRatio","FourByThreeRatioOption","isMSEdge","window","Boolean","navigator","msSaveOrOpenBlob","getScaleFromImageSize","imageW","imageH","mapW","mapH","some","d","base","mapBase","calculateExportImageSize","ratio","resolution","ratioItem","EXPORT_IMG_RATIO_OPTIONS","find","op","id","resolutionItem","EXPORT_IMG_RESOLUTION_OPTIONS","getSize","scaledWidth","width","scaledHeight","height","EXPORT_IMG_RATIOS","CUSTOM","scale","undefined","convertToPng","sourceElem","options","domtoimage","toPng","dataURItoBlob","dataURI","binary","split","mimeString","ab","ArrayBuffer","length","ia","Uint8Array","i","charCodeAt","Blob","type","downloadFile","fileBlob","fileName","url","URL","createObjectURL","link","document","createElement","setAttribute","body","appendChild","evt","MouseEvent","view","bubbles","cancelable","dispatchEvent","removeChild","revokeObjectURL","exportImage","uiStateExportImage","filename","imageDataUri","file","exportToJsonString","data","JSON","stringify","e","TypeError","message","description","getMapJSON","state","schema","visState","getConfigToSave","mapToSave","save","title","exportJson","map","info","source","appName","exportHtml","userMapboxToken","exportMapboxAccessToken","mode","mapboxApiAccessToken","exportMap","uiState","thumbnail","exporters"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAoBA;;AACA;;AAEA;;AASA;;AACA;;AACA;;;;;;AAEA;AACA;AACA;AACO,IAAMA,kBAAkB,GAAG,eAA3B;;AACA,IAAMC,iBAAiB,GAAG,gBAA1B;;AACA,IAAMC,iBAAiB,GAAG,gBAA1B;;AACA,IAAMC,iBAAiB,GAAG,WAA1B;AAEP;AACA;AACA;;;AACO,IAAMC,4BAA4B,GAAG;AAC1CC,EAAAA,OAAO,EAAE;AADiC,CAArC;;AAIP,IAAMC,iBAAiB,GAAGC,+BAA1B;AAEA,IAAMC,YAAY,GAAGC,iCAArB;;AAEO,SAASC,QAAT,CAAkBC,MAAlB,EAA2C;AAChD;AACA,SAAOC,OAAO,CAACD,MAAM,CAACE,SAAP,IAAoBF,MAAM,CAACE,SAAP,CAAiBC,gBAAtC,CAAd;AACD;;AAEM,SAASC,qBAAT,GAA2E;AAAA,MAA5CC,MAA4C,uEAAnC,CAAmC;AAAA,MAAhCC,MAAgC,uEAAvB,CAAuB;AAAA,MAApBC,IAAoB,uEAAb,CAAa;AAAA,MAAVC,IAAU,uEAAH,CAAG;;AAChF,MAAI,CAACH,MAAD,EAASC,MAAT,EAAiBC,IAAjB,EAAuBC,IAAvB,EAA6BC,IAA7B,CAAkC,UAAAC,CAAC;AAAA,WAAIA,CAAC,IAAI,CAAT;AAAA,GAAnC,CAAJ,EAAoD;AAClD,WAAO,CAAP;AACD;;AAED,MAAMC,IAAI,GAAGN,MAAM,GAAGC,MAAT,GAAkB,CAAlB,GAAsBD,MAAtB,GAA+BC,MAA5C;AACA,MAAMM,OAAO,GAAGP,MAAM,GAAGC,MAAT,GAAkB,CAAlB,GAAsBC,IAAtB,GAA6BC,IAA7C;AACA,SAAOG,IAAI,GAAGC,OAAd;AACD;;AAEM,SAASC,wBAAT,OAUJ;AAAA,MATDN,IASC,QATDA,IASC;AAAA,MARDC,IAQC,QARDA,IAQC;AAAA,MAPDM,KAOC,QAPDA,KAOC;AAAA,MANDC,UAMC,QANDA,UAMC;;AACD,MAAIR,IAAI,IAAI,CAAR,IAAaC,IAAI,IAAI,CAAzB,EAA4B;AAC1B,WAAO,IAAP;AACD;;AAED,MAAMQ,SAAS,GAAGC,oCAAyBC,IAAzB,CAA8B,UAAAC,EAAE;AAAA,WAAIA,EAAE,CAACC,EAAH,KAAUN,KAAd;AAAA,GAAhC,KAAwDjB,YAA1E;AAEA,MAAMwB,cAAc,GAClBC,yCAA8BJ,IAA9B,CAAmC,UAAAC,EAAE;AAAA,WAAIA,EAAE,CAACC,EAAH,KAAUL,UAAd;AAAA,GAArC,KAAkEpB,iBADpE;;AAPC,8BAUkD0B,cAAc,CAACE,OAAf,CAAuBhB,IAAvB,EAA6BC,IAA7B,CAVlD;AAAA,MAUagB,WAVb,yBAUMC,KAVN;AAAA,MAUkCC,YAVlC,yBAU0BC,MAV1B;;AAAA,2BAYuCX,SAAS,CAACO,OAAV,CAAkBC,WAAlB,EAA+BE,YAA/B,CAZvC;AAAA,MAYarB,MAZb,sBAYMoB,KAZN;AAAA,MAY6BnB,MAZ7B,sBAYqBqB,MAZrB;;AAAA,cAceX,SAAS,CAACI,EAAV,KAAiBQ,6BAAkBC,MAAnC,GAA4C;AAACC,IAAAA,KAAK,EAAEC;AAAR,GAA5C,GAAiEV,cAdhF;AAAA,MAcMS,KAdN,SAcMA,KAdN;;AAgBD,SAAO;AACLA,IAAAA,KAAK,EAALA,KADK;AAELzB,IAAAA,MAAM,EAANA,MAFK;AAGLC,IAAAA,MAAM,EAANA;AAHK,GAAP;AAKD;;AAEM,SAAS0B,YAAT,CAAsBC,UAAtB,EAA+CC,OAA/C,EAAwD;AAC7D,SAAOC,uBAAWC,KAAX,CAAiBH,UAAjB,EAA6BC,OAA7B,CAAP;AACD;;AAEM,SAASG,aAAT,CAAuBC,OAAvB,EAA8C;AACnD,MAAMC,MAAM,GAAG,kBAAKD,OAAO,CAACE,KAAR,CAAc,GAAd,EAAmB,CAAnB,CAAL,CAAf,CADmD,CAGnD;;AACA,MAAMC,UAAU,GAAGH,OAAO,CACvBE,KADgB,CACV,GADU,EACL,CADK,EAEhBA,KAFgB,CAEV,GAFU,EAEL,CAFK,EAGhBA,KAHgB,CAGV,GAHU,EAGL,CAHK,CAAnB,CAJmD,CASnD;;AACA,MAAME,EAAE,GAAG,IAAIC,mBAAJ,CAAgBJ,MAAM,CAACK,MAAvB,CAAX,CAVmD,CAYnD;;AACA,MAAMC,EAAE,GAAG,IAAIC,kBAAJ,CAAeJ,EAAf,CAAX;;AAEA,OAAK,IAAIK,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGR,MAAM,CAACK,MAA3B,EAAmCG,CAAC,EAApC,EAAwC;AACtCF,IAAAA,EAAE,CAACE,CAAD,CAAF,GAAQR,MAAM,CAACS,UAAP,CAAkBD,CAAlB,CAAR;AACD;;AAED,SAAO,IAAIE,YAAJ,CAAS,CAACP,EAAD,CAAT,EAAe;AAACQ,IAAAA,IAAI,EAAET;AAAP,GAAf,CAAP;AACD;;AAEM,SAASU,YAAT,CAAsBC,QAAtB,EAAsCC,QAAtC,EAAwD;AAC7D,MAAItD,QAAQ,CAACC,MAAD,CAAZ,EAAsB;AACnBA,IAAAA,MAAM,CAACE,SAAR,CAA0BC,gBAA1B,CAA2CiD,QAA3C,EAAqDC,QAArD;AACD,GAFD,MAEO;AACL,QAAMC,GAAG,GAAGC,YAAIC,eAAJ,CAAoBJ,QAApB,CAAZ;;AAEA,QAAMK,IAAI,GAAGC,iBAASC,aAAT,CAAuB,GAAvB,CAAb;;AACAF,IAAAA,IAAI,CAACG,YAAL,CAAkB,MAAlB,EAA0BN,GAA1B;AACAG,IAAAA,IAAI,CAACG,YAAL,CAAkB,UAAlB,EAA8BP,QAA9B;;AAEAK,qBAASG,IAAT,CAAcC,WAAd,CAA0BL,IAA1B,EAPK,CAQL;AACA;AACA;;;AACA,QAAMM,GAAG,GAAG,IAAIC,UAAJ,CAAe,OAAf,EAAwB;AAClCC,MAAAA,IAAI,EAAEjE,MAD4B;AAElCkE,MAAAA,OAAO,EAAE,KAFyB;AAGlCC,MAAAA,UAAU,EAAE;AAHsB,KAAxB,CAAZ;AAKAV,IAAAA,IAAI,CAACW,aAAL,CAAmBL,GAAnB;;AACAL,qBAASG,IAAT,CAAcQ,WAAd,CAA0BZ,IAA1B;;AACAF,gBAAIe,eAAJ,CAAoBhB,GAApB;AACD;AACF;AAED;AACA;AACA;AACA;;;AACO,SAASiB,WAAT,CAAqBC,kBAArB,EAAqF;AAAA,MAA/BC,QAA+B,uEAApBpF,kBAAoB;AAAA,MACnFqF,YADmF,GACnEF,kBADmE,CACnFE,YADmF;;AAE1F,MAAIA,YAAJ,EAAkB;AAChB,QAAMC,IAAI,GAAGtC,aAAa,CAACqC,YAAD,CAA1B;AACAvB,IAAAA,YAAY,CAACwB,IAAD,EAAOF,QAAP,CAAZ;AACD;AACF;;AAEM,SAASG,kBAAT,CAA4BC,IAA5B,EAAkC;AACvC,MAAI;AACF,WAAOC,IAAI,CAACC,SAAL,CAAeF,IAAf,CAAP;AACD,GAFD,CAEE,OAAOG,CAAP,EAAU;AACV,QAAIA,CAAC,YAAYC,SAAjB,EAA4B,OAAOD,CAAC,CAACE,OAAT,CADlB,CAEV;;AACA,WAAQF,CAAD,CAAWG,WAAlB;AACD;AACF;;AAEM,SAASC,UAAT,CAAoBC,KAApB,EAAmE;AAAA,MAAxCnD,OAAwC,uEAA9BzC,4BAA8B;AAAA,MACjEC,OADiE,GACtDwC,OADsD,CACjExC,OADiE;AAExE,MAAM4F,MAAM,GAAGD,KAAK,CAACE,QAAN,CAAeD,MAA9B;;AAEA,MAAI,CAAC5F,OAAL,EAAc;AACZ,WAAO4F,MAAM,CAACE,eAAP,CAAuBH,KAAvB,CAAP;AACD;;AAED,MAAII,SAAS,GAAGH,MAAM,CAACI,IAAP,CAAYL,KAAZ,CAAhB,CARwE,CASxE;;AACA,MAAMM,KAAK,GAAG,wBAAIF,SAAJ,EAAe,CAAC,MAAD,EAAS,OAAT,CAAf,CAAd;;AACA,MAAI,CAACE,KAAD,IAAU,CAACA,KAAK,CAAC/C,MAArB,EAA6B;AAC3B6C,IAAAA,SAAS,GAAG,gBAAI,CAAC,MAAD,EAAS,OAAT,CAAJ,qBAAmC,2BAAe,CAAf,CAAnC,GAAwDA,SAAxD,CAAZ;AACD;;AACD,SAAOA,SAAP;AACD;;AAEM,SAASG,UAAT,CAAoBP,KAApB,EAA8C;AAAA,MAAnBnD,OAAmB,uEAAJ,EAAI;AACnD,MAAM2D,GAAG,GAAGT,UAAU,CAACC,KAAD,EAAQnD,OAAR,CAAtB;AACA2D,EAAAA,GAAG,CAACC,IAAJ,CAASC,MAAT,GAAkB,WAAlB;AACA,MAAM3C,QAAQ,GAAG,IAAIH,YAAJ,CAAS,CAAC2B,kBAAkB,CAACiB,GAAD,CAAnB,CAAT,EAAoC;AAAC3C,IAAAA,IAAI,EAAE;AAAP,GAApC,CAAjB;AACA,MAAMG,QAAQ,GAAGgC,KAAK,CAACW,OAAN,aAAmBX,KAAK,CAACW,OAAzB,aAA0CzG,iBAA3D;AACA4D,EAAAA,YAAY,CAACC,QAAD,EAAWC,QAAX,CAAZ;AACD;;AAEM,SAAS4C,UAAT,CAAoBZ,KAApB,EAA2BnD,OAA3B,EAAoC;AAAA,MAClCgE,eADkC,GACgBhE,OADhB,CAClCgE,eADkC;AAAA,MACjBC,uBADiB,GACgBjE,OADhB,CACjBiE,uBADiB;AAAA,MACQC,IADR,GACgBlE,OADhB,CACQkE,IADR;;AAGzC,MAAMvB,IAAI,mCACLO,UAAU,CAACC,KAAD,CADL;AAERgB,IAAAA,oBAAoB,EAClB,CAACH,eAAe,IAAI,EAApB,MAA4B,EAA5B,GAAiCA,eAAjC,GAAmDC,uBAH7C;AAIRC,IAAAA,IAAI,EAAJA;AAJQ,IAAV;;AAOA,MAAMhD,QAAQ,GAAG,IAAIH,YAAJ,CAAS,CAAC,oCAAgB4B,IAAhB,CAAD,CAAT,EAAkC;AAAC3B,IAAAA,IAAI,EAAE;AAAP,GAAlC,CAAjB;AACAC,EAAAA,YAAY,CAACC,QAAD,EAAWiC,KAAK,CAACW,OAAN,aAAmBX,KAAK,CAACW,OAAzB,aAA0C1G,iBAArD,CAAZ;AACD;;AAEM,SAASgH,SAAT,CAAmBjB,KAAnB,EAAkE;AAAA,MAAxCnD,OAAwC,uEAA9BzC,4BAA8B;AAAA,MAChEiF,YADgE,GAChDW,KAAK,CAACkB,OAAN,CAAchC,WADkC,CAChEG,YADgE;AAEvE,MAAM8B,SAAsB,GAAG9B,YAAY,GAAGrC,aAAa,CAACqC,YAAD,CAAhB,GAAiC,IAA5E;AACA,MAAMe,SAAS,GAAGL,UAAU,CAACC,KAAD,EAAQnD,OAAR,CAA5B;AAEA,SAAO;AACL2D,IAAAA,GAAG,EAAEJ,SADA;AAELe,IAAAA,SAAS,EAATA;AAFK,GAAP;AAID;;AAED,IAAMC,SAAS,GAAG;AAChBlC,EAAAA,WAAW,EAAXA,WADgB;AAEhBqB,EAAAA,UAAU,EAAVA,UAFgB;AAGhBK,EAAAA,UAAU,EAAVA;AAHgB,CAAlB;eAMeQ,S","sourcesContent":["// Copyright (c) 2023 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 {Blob, URL, atob, Uint8Array, ArrayBuffer, document} from 'global/window';\nimport get from 'lodash.get';\n\nimport {\n  EXPORT_IMG_RESOLUTION_OPTIONS,\n  EXPORT_IMG_RATIO_OPTIONS,\n  RESOLUTIONS,\n  EXPORT_IMG_RATIOS,\n  FourByThreeRatioOption,\n  OneXResolutionOption,\n  ExportImage\n} from '@kepler.gl/constants';\nimport domtoimage from './dom-to-image';\nimport {generateHashId, set} from './utils';\nimport {exportMapToHTML} from './export-map-html';\n\n/**\n * Default file names\n */\nexport const DEFAULT_IMAGE_NAME = 'kepler.gl.png';\nexport const DEFAULT_HTML_NAME = 'kepler.gl.html';\nexport const DEFAULT_JSON_NAME = 'kepler.gl.json';\nexport const DEFAULT_DATA_NAME = 'kepler.gl';\n\n/**\n * Default json export settings\n */\nexport const DEFAULT_EXPORT_JSON_SETTINGS = {\n  hasData: true\n};\n\nconst defaultResolution = OneXResolutionOption;\n\nconst defaultRatio = FourByThreeRatioOption;\n\nexport function isMSEdge(window: Window): boolean {\n  // @ts-ignore msSaveOrOpenBlob was a proprietary addition to the Navigator object, added by Microsoft for Internet Explorer.\n  return Boolean(window.navigator && window.navigator.msSaveOrOpenBlob);\n}\n\nexport function getScaleFromImageSize(imageW = 0, imageH = 0, mapW = 0, mapH = 0) {\n  if ([imageW, imageH, mapW, mapH].some(d => d <= 0)) {\n    return 1;\n  }\n\n  const base = imageW / imageH > 1 ? imageW : imageH;\n  const mapBase = imageW / imageH > 1 ? mapW : mapH;\n  return base / mapBase;\n}\n\nexport function calculateExportImageSize({\n  mapW,\n  mapH,\n  ratio,\n  resolution\n}: {\n  mapW: number;\n  mapH: number;\n  ratio: keyof typeof EXPORT_IMG_RATIOS;\n  resolution: keyof typeof RESOLUTIONS;\n}) {\n  if (mapW <= 0 || mapH <= 0) {\n    return null;\n  }\n\n  const ratioItem = EXPORT_IMG_RATIO_OPTIONS.find(op => op.id === ratio) || defaultRatio;\n\n  const resolutionItem =\n    EXPORT_IMG_RESOLUTION_OPTIONS.find(op => op.id === resolution) || defaultResolution;\n\n  const {width: scaledWidth, height: scaledHeight} = resolutionItem.getSize(mapW, mapH);\n\n  const {width: imageW, height: imageH} = ratioItem.getSize(scaledWidth, scaledHeight);\n\n  const {scale} = ratioItem.id === EXPORT_IMG_RATIOS.CUSTOM ? {scale: undefined} : resolutionItem;\n\n  return {\n    scale,\n    imageW,\n    imageH\n  };\n}\n\nexport function convertToPng(sourceElem: HTMLElement, options) {\n  return domtoimage.toPng(sourceElem, options);\n}\n\nexport function dataURItoBlob(dataURI: string): Blob {\n  const binary = atob(dataURI.split(',')[1]);\n\n  // separate out the mime component\n  const mimeString = dataURI\n    .split(',')[0]\n    .split(':')[1]\n    .split(';')[0];\n\n  // write the bytes of the string to an ArrayBuffer\n  const ab = new ArrayBuffer(binary.length);\n\n  // create a view into the buffer\n  const ia = new Uint8Array(ab);\n\n  for (let i = 0; i < binary.length; i++) {\n    ia[i] = binary.charCodeAt(i);\n  }\n\n  return new Blob([ab], {type: mimeString});\n}\n\nexport function downloadFile(fileBlob: Blob, fileName: string) {\n  if (isMSEdge(window)) {\n    (window.navigator as any).msSaveOrOpenBlob(fileBlob, fileName);\n  } else {\n    const url = URL.createObjectURL(fileBlob);\n\n    const link = document.createElement('a');\n    link.setAttribute('href', url);\n    link.setAttribute('download', fileName);\n\n    document.body.appendChild(link);\n    // in some cases where maps are embedded, e.g. need to\n    // create and dispatch an event so that the browser downloads\n    // the file instead of navigating to the url\n    const evt = new MouseEvent('click', {\n      view: window,\n      bubbles: false,\n      cancelable: true\n    });\n    link.dispatchEvent(evt);\n    document.body.removeChild(link);\n    URL.revokeObjectURL(url);\n  }\n}\n\n/**\n * Whether color is rgb\n * @returns\n */\nexport function exportImage(uiStateExportImage: ExportImage, filename = DEFAULT_IMAGE_NAME) {\n  const {imageDataUri} = uiStateExportImage;\n  if (imageDataUri) {\n    const file = dataURItoBlob(imageDataUri);\n    downloadFile(file, filename);\n  }\n}\n\nexport function exportToJsonString(data) {\n  try {\n    return JSON.stringify(data);\n  } catch (e) {\n    if (e instanceof TypeError) return e.message;\n    // Non-Standard Error Object Property\n    return (e as any).description;\n  }\n}\n\nexport function getMapJSON(state, options = DEFAULT_EXPORT_JSON_SETTINGS) {\n  const {hasData} = options;\n  const schema = state.visState.schema;\n\n  if (!hasData) {\n    return schema.getConfigToSave(state);\n  }\n\n  let mapToSave = schema.save(state);\n  // add file name if title is not provided\n  const title = get(mapToSave, ['info', 'title']);\n  if (!title || !title.length) {\n    mapToSave = set(['info', 'title'], `keplergl_${generateHashId(6)}`, mapToSave);\n  }\n  return mapToSave;\n}\n\nexport function exportJson(state, options: any = {}) {\n  const map = getMapJSON(state, options);\n  map.info.source = 'kepler.gl';\n  const fileBlob = new Blob([exportToJsonString(map)], {type: 'application/json'});\n  const fileName = state.appName ? `${state.appName}.json` : DEFAULT_JSON_NAME;\n  downloadFile(fileBlob, fileName);\n}\n\nexport function exportHtml(state, options) {\n  const {userMapboxToken, exportMapboxAccessToken, mode} = options;\n\n  const data = {\n    ...getMapJSON(state),\n    mapboxApiAccessToken:\n      (userMapboxToken || '') !== '' ? userMapboxToken : exportMapboxAccessToken,\n    mode\n  };\n\n  const fileBlob = new Blob([exportMapToHTML(data)], {type: 'text/html'});\n  downloadFile(fileBlob, state.appName ? `${state.appName}.html` : DEFAULT_HTML_NAME);\n}\n\nexport function exportMap(state, options = DEFAULT_EXPORT_JSON_SETTINGS) {\n  const {imageDataUri} = state.uiState.exportImage;\n  const thumbnail: Blob | null = imageDataUri ? dataURItoBlob(imageDataUri) : null;\n  const mapToSave = getMapJSON(state, options);\n\n  return {\n    map: mapToSave,\n    thumbnail\n  };\n}\n\nconst exporters = {\n  exportImage,\n  exportJson,\n  exportHtml\n};\n\nexport default exporters;\n"]}

package/dist/filter-utils.d.ts

@@ -1,3 +1,4 @@
+import { VisState } from '@kepler.gl/schemas';
 import { Millisecond, Field, ParsedFilter, Filter, FilterBase, PolygonFilter, FieldDomain, TimeRangeFieldDomain, HistogramBin, Feature, FeatureValue, LineChart, TimeRangeFilter, RangeFieldDomain, FilterDatasetOpt, FilterRecord } from '@kepler.gl/types';
 import { DataContainerInterface } from './data-container-interface';
 export declare const durationSecond = 1000;
@@ -43,8 +44,9 @@ export declare const DEFAULT_FILTER_STRUCTURE: {
     dataId: never[];
     freeze: boolean;
     id: null;
+    enabled: boolean;
     fixedDomain: boolean;
-    enlarged: boolean;
+    view: "side";
     isAnimating: boolean;
     animationWindow: "free";
     speed: number;
@@ -63,7 +65,10 @@ export declare const LAYER_FILTERS: "polygon"[];
 /**
  * Generates a filter with a dataset id as dataId
  */
-export declare function getDefaultFilter(dataId: string | null | string[]): FilterBase<LineChart>;
+export declare function getDefaultFilter({ dataId, id }?: {
+    dataId?: string | null | string[];
+    id?: string;
+}): FilterBase<LineChart>;
 /**
  * Check if a filter is valid based on the given dataId
  * @param  filter to validate
@@ -148,7 +153,7 @@ export declare function getFilterFunction<L extends {
     };
     id: string;
 }>(field: Field | null, dataId: string, filter: Filter, layers: L[], dataContainer: DataContainerInterface): filterFunction;
-export declare function updateFilterDataId(dataId: string): FilterBase<LineChart>;
+export declare function updateFilterDataId(dataId: string | string[]): FilterBase<LineChart>;
 export declare function filterDataByFilterTypes({ dynamicDomainFilters, cpuFilters, filterFuncs }: {
     dynamicDomainFilters: Filter[] | null;
     cpuFilters: Filter[] | null;
@@ -295,12 +300,8 @@ export declare function filterDatasetCPU<T extends StateType<K, L>, K extends Ke
 /**
  * Validate parsed filters with datasets and add filterProps to field
  */
-export declare function validateFiltersUpdateDatasets<S extends {
-    datasets: {
-        [id: string]: K;
-    };
-    layers: L[];
-}, K extends KeplerTableModel<K, L>, L extends {
+declare type MinVisStateForFilter = Pick<VisState, 'layers' | 'datasets' | 'isMergingDatasets'>;
+export declare function validateFiltersUpdateDatasets<S extends MinVisStateForFilter, K extends KeplerTableModel<K, L>, L extends {
     config: {
         dataId: string | null;
         label: string;
@@ -321,4 +322,5 @@ export declare function getFilterPlot<K extends KeplerTableModel<K, L>, L>(filte
 export declare function getIntervalBins(filter: TimeRangeFilter): any;
 export declare function isValidTimeDomain(domain: any): boolean;
 export declare function getTimeWidgetHintFormatter(domain: [number, number]): string | undefined;
+export declare function isSideFilter(filter: Filter): boolean;
 export {};