@carto/kepler.gl 0.1.0-alpha.0 → 0.1.0-next.0

package/dist/cloud-providers/provider.js

@@ -0,0 +1,346 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.FILE_CONFLICT_MSG = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _icons = require("../components/common/icons");
+// 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.
+
+var NAME = 'cloud-provider';
+var DISPLAY_NAME = 'Cloud Provider';
+var THUMBNAIL = {
+  width: 300,
+  height: 200
+};
+var ICON = _icons.Upload;
+var FILE_CONFLICT_MSG = exports.FILE_CONFLICT_MSG = 'file_conflict';
+/**
+ * The default provider class
+ * @param {object} props
+ * @param {string} props.name
+ * @param {string} props.displayName
+ * @param {React.Component} props.icon - React element
+ * @param {object} props.thumbnail - thumbnail size object
+ * @param {number} props.thumbnail.width - thumbnail width in pixels
+ * @param {number} props.thumbnail.height - thumbnail height in pixels
+ * @public
+ * @example
+ *
+ * const myProvider = new Provider({
+ *  name: 'foo',
+ *  displayName: 'Foo Storage'
+ *  icon: Icon,
+ *  thumbnail: {width: 300, height: 200}
+ * })
+ */
+var Provider = exports["default"] = /*#__PURE__*/function () {
+  function Provider(props) {
+    (0, _classCallCheck2["default"])(this, Provider);
+    this.name = props.name || NAME;
+    this.displayName = props.displayName || DISPLAY_NAME;
+    this.icon = props.icon || ICON;
+    this.thumbnail = props.thumbnail || THUMBNAIL;
+  }
+
+  /**
+   * Whether this provider support upload map to a private storage. If truthy, user will be displayed with the storage save icon on the top right of the side bar.
+   * @returns
+   * @public
+   */
+  return (0, _createClass2["default"])(Provider, [{
+    key: "hasPrivateStorage",
+    value: function hasPrivateStorage() {
+      return true;
+    }
+
+    /**
+     * Whether this provider support share map via a public url, if truthy, user will be displayed with a share map via url under the export map option on the top right of the side bar
+     * @returns
+     * @public
+     */
+  }, {
+    key: "hasSharingUrl",
+    value: function hasSharingUrl() {
+      return true;
+    }
+
+    /**
+     * This method is called after user share a map, to display the share url.
+     * @param fullUrl - Whether to return the full url with domain, or just the location
+     * @returns shareUrl
+     * @public
+     */
+  }, {
+    key: "getShareUrl",
+    value: function getShareUrl() {
+      var fullUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      return '';
+    }
+
+    /**
+     * This method is called by kepler.gl demo app to pushes a new location to history, becoming the current location.
+     * @param fullURL - Whether to return the full url with domain, or just the location
+     * @returns mapUrl
+     * @public
+     */
+  }, {
+    key: "getMapUrl",
+    value: function getMapUrl() {
+      var fullURL = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return '';
+    }
+
+    /**
+     * This method is called to determine whether user already logged in to this provider
+     * @public
+     * @returns true if a user already logged in
+     */
+  }, {
+    key: "getAccessToken",
+    value: function getAccessToken() {
+      return true;
+    }
+
+    /**
+     * This method is called to get the user name of the current user. It will be displayed in the cloud provider tile.
+     * @public
+     * @returns true if a user already logged in
+     */
+  }, {
+    key: "getUserName",
+    value: function getUserName() {
+      return '';
+    }
+
+    /**
+     * This return a standard error that will trigger the overwrite map modal
+     */
+  }, {
+    key: "getFileConflictError",
+    value: function getFileConflictError() {
+      return new Error(FILE_CONFLICT_MSG);
+    }
+
+    /**
+     * This method will be called when user click the login button in the cloud provider tile.
+     * Upon login success, `onCloudLoginSuccess` has to be called to notify kepler.gl UI
+     * @param {function} onCloudLoginSuccess - callbacks to be called after login success
+     * @public
+     */
+  }, {
+    key: "login",
+    value: (function () {
+      var _login = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(onCloudLoginSuccess) {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              onCloudLoginSuccess();
+              return _context.abrupt("return");
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function login(_x) {
+        return _login.apply(this, arguments);
+      }
+      return login;
+    }()
+    /**
+     * This method will be called when user click the logout button under the cloud provider tile.
+     * Upon login success, `onCloudLoginSuccess` has to be called to notify kepler.gl UI
+     * @param {function} onCloudLogoutSuccess - callbacks to be called after logout success
+     * @public
+     */
+    )
+  }, {
+    key: "logout",
+    value: (function () {
+      var _logout = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(onCloudLogoutSuccess) {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              onCloudLogoutSuccess();
+              return _context2.abrupt("return");
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function logout(_x2) {
+        return _logout.apply(this, arguments);
+      }
+      return logout;
+    }()
+    /**
+     * This method will be called to upload map for saving and sharing. Kepler.gl will package map data, config, title, description and thumbnail for upload to storage.
+     * With the option to overwrite already saved map, and upload as private or public map.
+     *
+     * @param {Object} param
+     * @param {Object} param.mapData - the map object
+     * @param {Object} param.mapData.map - {datasets. config, info: {title, description}}
+     * @param {Blob} param.mapData.thumbnail - A thumbnail of current map. thumbnail size can be defined by provider by this.thumbnail
+     * @param {object} [param.options]
+     * @param {boolean} [param.options.overwrite] - whether user choose to overwrite already saved map under the same name
+     * @param {boolean} [param.options.isPublic] - whether user wish to share the map with others. if isPublic is truthy, kepler will call this.getShareUrl() to display an URL they can share with others
+     * @public
+     */
+    )
+  }, {
+    key: "uploadMap",
+    value: (function () {
+      var _uploadMap = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref) {
+        var mapData, _ref$options, options;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              mapData = _ref.mapData, _ref$options = _ref.options, options = _ref$options === void 0 ? {} : _ref$options;
+              return _context3.abrupt("return");
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      function uploadMap(_x3) {
+        return _uploadMap.apply(this, arguments);
+      }
+      return uploadMap;
+    }()
+    /**
+     * This method is called to get a list of maps saved by the current logged in user.
+     * @returns visualizations an array of Viz objects
+     * @public
+     * @example
+     *  async listMaps() {
+     *    return [
+     *      {
+     *        id: 'a',
+     *        title: 'My map',
+     *        description: 'My first kepler map',
+     *        imageUrl: 'http://',
+     *        lastModification: 1582677787000,
+     *        privateMap: false,
+     *        loadParams: {}
+     *      }
+     *    ];
+     *  }
+     */
+    )
+  }, {
+    key: "listMaps",
+    value: (function () {
+      var _listMaps = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", []);
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      function listMaps() {
+        return _listMaps.apply(this, arguments);
+      }
+      return listMaps;
+    }()
+    /**
+     * This method will be called when user select a map to load from the storage map viewer
+     * @param {*} loadParams - the loadParams property of each visualization object
+     * @returns mapResponse - the map object containing dataset config info and format option
+     * @public
+     * @example
+     * async downloadMap(loadParams) {
+     *  const mockResponse = {
+     *    map: {
+     *      datasets: [],
+     *      config: {},
+     *      info: {
+     *        app: 'kepler.gl',
+     *        created_at: ''
+     *        title: 'test map',
+     *        description: 'Hello this is my test dropbox map'
+     *      }
+     *    },
+     *    // pass csv here if your provider currently only support save / load file as csv
+     *    format: 'keplergl'
+     *  };
+     *
+     *  return downloadMap;
+     * }
+     */
+    )
+  }, {
+    key: "downloadMap",
+    value: (function () {
+      var _downloadMap = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(loadParams) {
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              return _context5.abrupt("return");
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      function downloadMap(_x4) {
+        return _downloadMap.apply(this, arguments);
+      }
+      return downloadMap;
+    }()
+    /**
+     * @typedef {Object} Viz
+     * @property {string} id - An unique id
+     * @property {string} title - The title of the map
+     * @property {string} description - The description of the map
+     * @property {string} imageUrl - The imageUrl of the map
+     * @property {number} lastModification - An epoch timestamp in milliseconds
+     * @property {boolean} privateMap - Optional, whether if this map is private to the user, or can be accessed by others via URL
+     * @property {*} loadParams - A property to be passed to `downloadMap`
+     * @public
+     */
+    /**
+     * The returned object of `downloadMap`. The response object should contain: datasets: [], config: {}, and info: {}
+     * each dataset object should be {info: {id, label}, data: {...}}
+     * to inform how kepler should process your data object, pass in `format`
+     * @typedef {Object} MapResponse
+     * @property {Object} map
+     * @property {Array<Object>} map.datasets
+     * @property {Object} map.config
+     * @property {Object} map.info
+     * @property {string} format - one of 'csv': csv file string, 'geojson': geojson object, 'row': row object, 'keplergl': datasets array saved using KeplerGlSchema.save
+     * @public
+     */
+    )
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_icons","require","NAME","DISPLAY_NAME","THUMBNAIL","width","height","ICON","Upload","FILE_CONFLICT_MSG","exports","Provider","props","_classCallCheck2","name","displayName","icon","thumbnail","_createClass2","key","value","hasPrivateStorage","hasSharingUrl","getShareUrl","fullUrl","arguments","length","undefined","getMapUrl","fullURL","getAccessToken","getUserName","getFileConflictError","Error","_login","_asyncToGenerator2","_regenerator","mark","_callee","onCloudLoginSuccess","wrap","_callee$","_context","prev","next","abrupt","stop","login","_x","apply","_logout","_callee2","onCloudLogoutSuccess","_callee2$","_context2","logout","_x2","_uploadMap","_callee3","_ref","mapData","_ref$options","options","_callee3$","_context3","uploadMap","_x3","_listMaps","_callee4","_callee4$","_context4","listMaps","_downloadMap","_callee5","loadParams","_callee5$","_context5","downloadMap","_x4"],"sources":["../../src/cloud-providers/provider.ts"],"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 {Upload} from 'components/common/icons';\nimport {MapData, ExportFileOptions} from 'actions/provider-actions';\nimport {ComponentType} from 'react';\n\nexport type Millisecond = number;\n\nexport type MapListItem = {\n  id: string;\n  title: string;\n  description: string;\n  loadParams: any;\n  imageUrl?: string;\n  lastModification?: Millisecond;\n  privateMap?: boolean;\n};\n\nexport type Thumbnail = {\n  width: number;\n  height: number;\n};\n\nexport type ProviderProps = {\n  name?: string;\n  displayName?: string;\n  icon?: ComponentType<IconProps>;\n  thumbnail?: Thumbnail;\n};\n\nexport interface IconProps {\n  height?: string;\n  width?: string;\n}\n\nconst NAME = 'cloud-provider';\nconst DISPLAY_NAME = 'Cloud Provider';\nconst THUMBNAIL = {width: 300, height: 200};\nconst ICON = Upload;\nexport const FILE_CONFLICT_MSG = 'file_conflict';\n/**\n * The default provider class\n * @param {object} props\n * @param {string} props.name\n * @param {string} props.displayName\n * @param {React.Component} props.icon - React element\n * @param {object} props.thumbnail - thumbnail size object\n * @param {number} props.thumbnail.width - thumbnail width in pixels\n * @param {number} props.thumbnail.height - thumbnail height in pixels\n * @public\n * @example\n *\n * const myProvider = new Provider({\n *  name: 'foo',\n *  displayName: 'Foo Storage'\n *  icon: Icon,\n *  thumbnail: {width: 300, height: 200}\n * })\n */\nexport default class Provider {\n  name: string;\n  displayName: string;\n  icon: ComponentType<IconProps>;\n  thumbnail: Thumbnail;\n  getManagementUrl?: () => string;\n\n  constructor(props: ProviderProps) {\n    this.name = props.name || NAME;\n    this.displayName = props.displayName || DISPLAY_NAME;\n    this.icon = props.icon || ICON;\n    this.thumbnail = props.thumbnail || THUMBNAIL;\n  }\n\n  /**\n   * Whether this provider support upload map to a private storage. If truthy, user will be displayed with the storage save icon on the top right of the side bar.\n   * @returns\n   * @public\n   */\n  hasPrivateStorage(): boolean {\n    return true;\n  }\n\n  /**\n   * Whether this provider support share map via a public url, if truthy, user will be displayed with a share map via url under the export map option on the top right of the side bar\n   * @returns\n   * @public\n   */\n  hasSharingUrl(): boolean {\n    return true;\n  }\n\n  /**\n   * This method is called after user share a map, to display the share url.\n   * @param fullUrl - Whether to return the full url with domain, or just the location\n   * @returns shareUrl\n   * @public\n   */\n  getShareUrl(fullUrl: boolean = false): string {\n    return '';\n  }\n\n  /**\n   * This method is called by kepler.gl demo app to pushes a new location to history, becoming the current location.\n   * @param fullURL - Whether to return the full url with domain, or just the location\n   * @returns mapUrl\n   * @public\n   */\n  getMapUrl(fullURL: boolean = true): string {\n    return '';\n  }\n\n  /**\n   * This method is called to determine whether user already logged in to this provider\n   * @public\n   * @returns true if a user already logged in\n   */\n  getAccessToken(): boolean {\n    return true;\n  }\n\n  /**\n   * This method is called to get the user name of the current user. It will be displayed in the cloud provider tile.\n   * @public\n   * @returns true if a user already logged in\n   */\n  getUserName(): string {\n    return '';\n  }\n\n  /**\n   * This return a standard error that will trigger the overwrite map modal\n   */\n  getFileConflictError() {\n    return new Error(FILE_CONFLICT_MSG);\n  }\n\n  /**\n   * This method will be called when user click the login button in the cloud provider tile.\n   * Upon login success, `onCloudLoginSuccess` has to be called to notify kepler.gl UI\n   * @param {function} onCloudLoginSuccess - callbacks to be called after login success\n   * @public\n   */\n  async login(onCloudLoginSuccess) {\n    onCloudLoginSuccess();\n    return;\n  }\n\n  /**\n   * This method will be called when user click the logout button under the cloud provider tile.\n   * Upon login success, `onCloudLoginSuccess` has to be called to notify kepler.gl UI\n   * @param {function} onCloudLogoutSuccess - callbacks to be called after logout success\n   * @public\n   */\n  async logout(onCloudLogoutSuccess: () => void) {\n    onCloudLogoutSuccess();\n    return;\n  }\n\n  /**\n   * This method will be called to upload map for saving and sharing. Kepler.gl will package map data, config, title, description and thumbnail for upload to storage.\n   * With the option to overwrite already saved map, and upload as private or public map.\n   *\n   * @param {Object} param\n   * @param {Object} param.mapData - the map object\n   * @param {Object} param.mapData.map - {datasets. config, info: {title, description}}\n   * @param {Blob} param.mapData.thumbnail - A thumbnail of current map. thumbnail size can be defined by provider by this.thumbnail\n   * @param {object} [param.options]\n   * @param {boolean} [param.options.overwrite] - whether user choose to overwrite already saved map under the same name\n   * @param {boolean} [param.options.isPublic] - whether user wish to share the map with others. if isPublic is truthy, kepler will call this.getShareUrl() to display an URL they can share with others\n   * @public\n   */\n  async uploadMap({\n    mapData,\n    options = {}\n  }: {\n    mapData: MapData;\n    options: ExportFileOptions;\n  }): Promise<any> {\n    return;\n  }\n\n  /**\n   * This method is called to get a list of maps saved by the current logged in user.\n   * @returns visualizations an array of Viz objects\n   * @public\n   * @example\n   *  async listMaps() {\n   *    return [\n   *      {\n   *        id: 'a',\n   *        title: 'My map',\n   *        description: 'My first kepler map',\n   *        imageUrl: 'http://',\n   *        lastModification: 1582677787000,\n   *        privateMap: false,\n   *        loadParams: {}\n   *      }\n   *    ];\n   *  }\n   */\n  async listMaps(): Promise<MapListItem[]> {\n    return [];\n  }\n\n  /**\n   * This method will be called when user select a map to load from the storage map viewer\n   * @param {*} loadParams - the loadParams property of each visualization object\n   * @returns mapResponse - the map object containing dataset config info and format option\n   * @public\n   * @example\n   * async downloadMap(loadParams) {\n   *  const mockResponse = {\n   *    map: {\n   *      datasets: [],\n   *      config: {},\n   *      info: {\n   *        app: 'kepler.gl',\n   *        created_at: ''\n   *        title: 'test map',\n   *        description: 'Hello this is my test dropbox map'\n   *      }\n   *    },\n   *    // pass csv here if your provider currently only support save / load file as csv\n   *    format: 'keplergl'\n   *  };\n   *\n   *  return downloadMap;\n   * }\n   */\n  async downloadMap(loadParams): Promise<{map: MapData; format: string}> {\n    return;\n  }\n\n  /**\n   * @typedef {Object} Viz\n   * @property {string} id - An unique id\n   * @property {string} title - The title of the map\n   * @property {string} description - The description of the map\n   * @property {string} imageUrl - The imageUrl of the map\n   * @property {number} lastModification - An epoch timestamp in milliseconds\n   * @property {boolean} privateMap - Optional, whether if this map is private to the user, or can be accessed by others via URL\n   * @property {*} loadParams - A property to be passed to `downloadMap`\n   * @public\n   */\n\n  /**\n   * The returned object of `downloadMap`. The response object should contain: datasets: [], config: {}, and info: {}\n   * each dataset object should be {info: {id, label}, data: {...}}\n   * to inform how kepler should process your data object, pass in `format`\n   * @typedef {Object} MapResponse\n   * @property {Object} map\n   * @property {Array<Object>} map.datasets\n   * @property {Object} map.config\n   * @property {Object} map.info\n   * @property {string} format - one of 'csv': csv file string, 'geojson': geojson object, 'row': row object, 'keplergl': datasets array saved using KeplerGlSchema.save\n   * @public\n   */\n}\n"],"mappings":";;;;;;;;;;;AAoBA,IAAAA,MAAA,GAAAC,OAAA;AApBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAmCA,IAAMC,IAAI,GAAG,gBAAgB;AAC7B,IAAMC,YAAY,GAAG,gBAAgB;AACrC,IAAMC,SAAS,GAAG;EAACC,KAAK,EAAE,GAAG;EAAEC,MAAM,EAAE;AAAG,CAAC;AAC3C,IAAMC,IAAI,GAAGC,aAAM;AACZ,IAAMC,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,eAAe;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAlBA,IAmBqBE,QAAQ,GAAAD,OAAA;EAO3B,SAAAC,SAAYC,KAAoB,EAAE;IAAA,IAAAC,gBAAA,mBAAAF,QAAA;IAChC,IAAI,CAACG,IAAI,GAAGF,KAAK,CAACE,IAAI,IAAIZ,IAAI;IAC9B,IAAI,CAACa,WAAW,GAAGH,KAAK,CAACG,WAAW,IAAIZ,YAAY;IACpD,IAAI,CAACa,IAAI,GAAGJ,KAAK,CAACI,IAAI,IAAIT,IAAI;IAC9B,IAAI,CAACU,SAAS,GAAGL,KAAK,CAACK,SAAS,IAAIb,SAAS;EAC/C;;EAEA;AACF;AACA;AACA;AACA;EAJE,WAAAc,aAAA,aAAAP,QAAA;IAAAQ,GAAA;IAAAC,KAAA,EAKA,SAAAC,iBAAiBA,CAAA,EAAY;MAC3B,OAAO,IAAI;IACb;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAF,GAAA;IAAAC,KAAA,EAKA,SAAAE,aAAaA,CAAA,EAAY;MACvB,OAAO,IAAI;IACb;;IAEA;AACF;AACA;AACA;AACA;AACA;EALE;IAAAH,GAAA;IAAAC,KAAA,EAMA,SAAAG,WAAWA,CAAA,EAAmC;MAAA,IAAlCC,OAAgB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,KAAK;MAClC,OAAO,EAAE;IACX;;IAEA;AACF;AACA;AACA;AACA;AACA;EALE;IAAAN,GAAA;IAAAC,KAAA,EAMA,SAAAQ,SAASA,CAAA,EAAkC;MAAA,IAAjCC,OAAgB,GAAAJ,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,IAAI;MAC/B,OAAO,EAAE;IACX;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAN,GAAA;IAAAC,KAAA,EAKA,SAAAU,cAAcA,CAAA,EAAY;MACxB,OAAO,IAAI;IACb;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAX,GAAA;IAAAC,KAAA,EAKA,SAAAW,WAAWA,CAAA,EAAW;MACpB,OAAO,EAAE;IACX;;IAEA;AACF;AACA;EAFE;IAAAZ,GAAA;IAAAC,KAAA,EAGA,SAAAY,oBAAoBA,CAAA,EAAG;MACrB,OAAO,IAAIC,KAAK,CAACxB,iBAAiB,CAAC;IACrC;;IAEA;AACF;AACA;AACA;AACA;AACA;EALE;IAAAU,GAAA;IAAAC,KAAA;MAAA,IAAAc,MAAA,OAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAMA,SAAAC,QAAYC,mBAAmB;QAAA,OAAAH,YAAA,YAAAI,IAAA,UAAAC,SAAAC,QAAA;UAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;YAAA;cAC7BL,mBAAmB,CAAC,CAAC;cAAC,OAAAG,QAAA,CAAAG,MAAA;YAAA;YAAA;cAAA,OAAAH,QAAA,CAAAI,IAAA;UAAA;QAAA,GAAAR,OAAA;MAAA,CAEvB;MAAA,SAHKS,KAAKA,CAAAC,EAAA;QAAA,OAAAd,MAAA,CAAAe,KAAA,OAAAxB,SAAA;MAAA;MAAA,OAALsB,KAAK;IAAA;IAKX;AACF;AACA;AACA;AACA;AACA;IALE;EAAA;IAAA5B,GAAA;IAAAC,KAAA;MAAA,IAAA8B,OAAA,OAAAf,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAMA,SAAAc,SAAaC,oBAAgC;QAAA,OAAAhB,YAAA,YAAAI,IAAA,UAAAa,UAAAC,SAAA;UAAA,kBAAAA,SAAA,CAAAX,IAAA,GAAAW,SAAA,CAAAV,IAAA;YAAA;cAC3CQ,oBAAoB,CAAC,CAAC;cAAC,OAAAE,SAAA,CAAAT,MAAA;YAAA;YAAA;cAAA,OAAAS,SAAA,CAAAR,IAAA;UAAA;QAAA,GAAAK,QAAA;MAAA,CAExB;MAAA,SAHKI,MAAMA,CAAAC,GAAA;QAAA,OAAAN,OAAA,CAAAD,KAAA,OAAAxB,SAAA;MAAA;MAAA,OAAN8B,MAAM;IAAA;IAKZ;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IAZE;EAAA;IAAApC,GAAA;IAAAC,KAAA;MAAA,IAAAqC,UAAA,OAAAtB,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAaA,SAAAqB,SAAAC,IAAA;QAAA,IAAAC,OAAA,EAAAC,YAAA,EAAAC,OAAA;QAAA,OAAA1B,YAAA,YAAAI,IAAA,UAAAuB,UAAAC,SAAA;UAAA,kBAAAA,SAAA,CAAArB,IAAA,GAAAqB,SAAA,CAAApB,IAAA;YAAA;cACEgB,OAAO,GAAAD,IAAA,CAAPC,OAAO,EAAAC,YAAA,GAAAF,IAAA,CACPG,OAAO,EAAPA,OAAO,GAAAD,YAAA,cAAG,CAAC,CAAC,GAAAA,YAAA;cAAA,OAAAG,SAAA,CAAAnB,MAAA;YAAA;YAAA;cAAA,OAAAmB,SAAA,CAAAlB,IAAA;UAAA;QAAA,GAAAY,QAAA;MAAA,CAMb;MAAA,SARKO,SAASA,CAAAC,GAAA;QAAA,OAAAT,UAAA,CAAAR,KAAA,OAAAxB,SAAA;MAAA;MAAA,OAATwC,SAAS;IAAA;IAUf;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IAlBE;EAAA;IAAA9C,GAAA;IAAAC,KAAA;MAAA,IAAA+C,SAAA,OAAAhC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAmBA,SAAA+B,SAAA;QAAA,OAAAhC,YAAA,YAAAI,IAAA,UAAA6B,UAAAC,SAAA;UAAA,kBAAAA,SAAA,CAAA3B,IAAA,GAAA2B,SAAA,CAAA1B,IAAA;YAAA;cAAA,OAAA0B,SAAA,CAAAzB,MAAA,WACS,EAAE;YAAA;YAAA;cAAA,OAAAyB,SAAA,CAAAxB,IAAA;UAAA;QAAA,GAAAsB,QAAA;MAAA,CACV;MAAA,SAFKG,QAAQA,CAAA;QAAA,OAAAJ,SAAA,CAAAlB,KAAA,OAAAxB,SAAA;MAAA;MAAA,OAAR8C,QAAQ;IAAA;IAId;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IAxBE;EAAA;IAAApD,GAAA;IAAAC,KAAA;MAAA,IAAAoD,YAAA,OAAArC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAyBA,SAAAoC,SAAkBC,UAAU;QAAA,OAAAtC,YAAA,YAAAI,IAAA,UAAAmC,UAAAC,SAAA;UAAA,kBAAAA,SAAA,CAAAjC,IAAA,GAAAiC,SAAA,CAAAhC,IAAA;YAAA;cAAA,OAAAgC,SAAA,CAAA/B,MAAA;YAAA;YAAA;cAAA,OAAA+B,SAAA,CAAA9B,IAAA;UAAA;QAAA,GAAA2B,QAAA;MAAA,CAE3B;MAAA,SAFKI,WAAWA,CAAAC,GAAA;QAAA,OAAAN,YAAA,CAAAvB,KAAA,OAAAxB,SAAA;MAAA;MAAA,OAAXoD,WAAW;IAAA;IAIjB;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IAEE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IAXE;EAAA;AAAA","ignoreList":[]}

package/dist/components/bottom-widget.d.ts

@@ -1,47 +1,47 @@
-import React from 'react';
-import TimeWidgetFactory from './filters/time-widget';
-import AnimationControlFactory from './common/animation-control/animation-control';
-import AnimationControllerFactory from './common/animation-control/animation-controller';
-import { AnimationConfig, TimeRangeFilter } from 'reducers';
-interface FilterAnimationControllerProps {
-    children?: Function;
-    filter: TimeRangeFilter & {
-        animationWindow?: string;
-    };
-    filterIdx: number;
-    setFilterAnimationTime: (idx: number, value: string, a: any[]) => void;
-}
-export declare function FilterAnimationControllerFactory(AnimationController: ReturnType<typeof AnimationControllerFactory>): React.FC<FilterAnimationControllerProps>;
-export declare namespace FilterAnimationControllerFactory {
-    var deps: (typeof AnimationControllerFactory)[];
-}
-interface LayerAnimationControllerProps {
-    children?: Function;
-    animationConfig: AnimationConfig & {
-        timeSteps?: number[] | null;
-    };
-    setLayerAnimationTime: (x: number) => void;
-}
-export declare function LayerAnimationControllerFactory(AnimationController: ReturnType<typeof AnimationControllerFactory>): React.FC<LayerAnimationControllerProps>;
-export declare namespace LayerAnimationControllerFactory {
-    var deps: (typeof AnimationControllerFactory)[];
-}
-declare function BottomWidgetFactory(TimeWidget: ReturnType<typeof TimeWidgetFactory>, AnimationControl: ReturnType<typeof AnimationControlFactory>, FilterAnimationController: ReturnType<typeof FilterAnimationControllerFactory>, LayerAnimationController: ReturnType<typeof LayerAnimationControllerFactory>): React.ForwardRefExoticComponent<{
-    containerW: number;
-} & {
-    filters: import("reducers").Filter[];
-    datasets: import("reducers").Datasets;
-    uiState: import("reducers").UiState;
-    layers: import("../layers/base-layer").default[];
-    animationConfig: AnimationConfig;
-    visStateActions: typeof import("../actions/vis-state-actions");
-    toggleModal: (id: string) => {
-        payload: string;
-        type: "@@kepler.gl/TOGGLE_MODAL";
-    };
-    sidePanelWidth: any;
-} & React.RefAttributes<unknown>>;
-declare namespace BottomWidgetFactory {
-    var deps: (typeof FilterAnimationControllerFactory | typeof LayerAnimationControllerFactory | typeof TimeWidgetFactory | typeof AnimationControlFactory)[];
-}
-export default BottomWidgetFactory;
+import React from 'react';
+import TimeWidgetFactory from './filters/time-widget';
+import AnimationControlFactory from './common/animation-control/animation-control';
+import AnimationControllerFactory from './common/animation-control/animation-controller';
+import { AnimationConfig, TimeRangeFilter } from 'reducers';
+interface FilterAnimationControllerProps {
+    children?: Function;
+    filter: TimeRangeFilter & {
+        animationWindow?: string;
+    };
+    filterIdx: number;
+    setFilterAnimationTime: (idx: number, value: string, a: any[]) => void;
+}
+export declare function FilterAnimationControllerFactory(AnimationController: ReturnType<typeof AnimationControllerFactory>): React.FC<FilterAnimationControllerProps>;
+export declare namespace FilterAnimationControllerFactory {
+    var deps: (typeof AnimationControllerFactory)[];
+}
+interface LayerAnimationControllerProps {
+    children?: Function;
+    animationConfig: AnimationConfig & {
+        timeSteps?: number[] | null;
+    };
+    setLayerAnimationTime: (x: number) => void;
+}
+export declare function LayerAnimationControllerFactory(AnimationController: ReturnType<typeof AnimationControllerFactory>): React.FC<LayerAnimationControllerProps>;
+export declare namespace LayerAnimationControllerFactory {
+    var deps: (typeof AnimationControllerFactory)[];
+}
+declare function BottomWidgetFactory(TimeWidget: ReturnType<typeof TimeWidgetFactory>, AnimationControl: ReturnType<typeof AnimationControlFactory>, FilterAnimationController: ReturnType<typeof FilterAnimationControllerFactory>, LayerAnimationController: ReturnType<typeof LayerAnimationControllerFactory>): React.ForwardRefExoticComponent<{
+    containerW: number;
+} & {
+    filters: import("reducers").Filter[];
+    datasets: import("reducers").Datasets;
+    uiState: import("reducers").UiState;
+    layers: import("../layers/base-layer").default[];
+    animationConfig: AnimationConfig;
+    visStateActions: typeof import("../actions/vis-state-actions");
+    toggleModal: (id: string) => {
+        payload: string;
+        type: "@@kepler.gl/TOGGLE_MODAL";
+    };
+    sidePanelWidth: any;
+} & React.RefAttributes<unknown>>;
+declare namespace BottomWidgetFactory {
+    var deps: (typeof TimeWidgetFactory | typeof AnimationControlFactory | typeof FilterAnimationControllerFactory | typeof LayerAnimationControllerFactory)[];
+}
+export default BottomWidgetFactory;