@carto/kepler.gl 0.0.86-alpha.deck9.1 → 0.0.86

package/dist/cloud-providers/index.js

@@ -1,21 +1,22 @@
 "use strict";
 
+var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "FILE_CONFLICT_MSG", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _provider.FILE_CONFLICT_MSG;
   }
 });
 Object.defineProperty(exports, "Provider", {
   enumerable: true,
-  get: function () {
-    return _provider.default;
+  get: function get() {
+    return _provider["default"];
   }
 });
 var _provider = _interopRequireWildcard(require("./provider"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/cloud-providers/provider.js

@@ -4,8 +4,11 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.FILE_CONFLICT_MSG = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+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.
 //
@@ -27,14 +30,14 @@ var _icons = require("../components/common/icons");
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-const NAME = 'cloud-provider';
-const DISPLAY_NAME = 'Cloud Provider';
-const THUMBNAIL = {
+var NAME = 'cloud-provider';
+var DISPLAY_NAME = 'Cloud Provider';
+var THUMBNAIL = {
   width: 300,
   height: 200
 };
-const ICON = _icons.Upload;
-const FILE_CONFLICT_MSG = exports.FILE_CONFLICT_MSG = 'file_conflict';
+var ICON = _icons.Upload;
+var FILE_CONFLICT_MSG = exports.FILE_CONFLICT_MSG = 'file_conflict';
 /**
  * The default provider class
  * @param {object} props
@@ -54,13 +57,9 @@ const FILE_CONFLICT_MSG = exports.FILE_CONFLICT_MSG = 'file_conflict';
  *  thumbnail: {width: 300, height: 200}
  * })
  */
-class Provider {
-  constructor(props) {
-    (0, _defineProperty2.default)(this, "name", void 0);
-    (0, _defineProperty2.default)(this, "displayName", void 0);
-    (0, _defineProperty2.default)(this, "icon", void 0);
-    (0, _defineProperty2.default)(this, "thumbnail", void 0);
-    (0, _defineProperty2.default)(this, "getManagementUrl", void 0);
+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;
@@ -72,185 +71,276 @@ class Provider {
    * @returns
    * @public
    */
-  hasPrivateStorage() {
-    return true;
-  }
+  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
-   */
-  hasSharingUrl() {
-    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
-   */
-  getShareUrl() {
-    let fullUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    return '';
-  }
+    /**
+     * 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
-   */
-  getMapUrl() {
-    let fullURL = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    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
-   */
-  getAccessToken() {
-    return true;
-  }
+    /**
+     * 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
-   */
-  getUserName() {
-    return '';
-  }
+    /**
+     * 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
-   */
-  getFileConflictError() {
-    return new Error(FILE_CONFLICT_MSG);
-  }
+    /**
+     * 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
-   */
-  async login(onCloudLoginSuccess) {
-    onCloudLoginSuccess();
-    return;
-  }
-
-  /**
-   * 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
-   */
-  async logout(onCloudLogoutSuccess) {
-    onCloudLogoutSuccess();
-    return;
-  }
-
-  /**
-   * 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
-   */
-  async uploadMap(_ref) {
-    let {
-      mapData,
-      options = {}
-    } = _ref;
-    return;
-  }
-
-  /**
-   * 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: {}
-   *      }
-   *    ];
-   *  }
-   */
-  async listMaps() {
-    return [];
-  }
-
-  /**
-   * 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;
-   * }
-   */
-  async downloadMap(loadParams) {
-    return;
-  }
-
-  /**
-   * @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
-   */
-}
-exports.default = Provider;
-//# 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","constructor","props","_defineProperty2","default","name","displayName","icon","thumbnail","hasPrivateStorage","hasSharingUrl","getShareUrl","fullUrl","arguments","length","undefined","getMapUrl","fullURL","getAccessToken","getUserName","getFileConflictError","Error","login","onCloudLoginSuccess","logout","onCloudLogoutSuccess","uploadMap","_ref","mapData","options","listMaps","downloadMap","loadParams"],"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,MAAMC,IAAI,GAAG,gBAAgB;AAC7B,MAAMC,YAAY,GAAG,gBAAgB;AACrC,MAAMC,SAAS,GAAG;EAACC,KAAK,EAAE,GAAG;EAAEC,MAAM,EAAE;AAAG,CAAC;AAC3C,MAAMC,IAAI,GAAGC,aAAM;AACZ,MAAMC,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;AACe,MAAME,QAAQ,CAAC;EAO5BC,WAAWA,CAACC,KAAoB,EAAE;IAAA,IAAAC,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAChC,IAAI,CAACC,IAAI,GAAGH,KAAK,CAACG,IAAI,IAAId,IAAI;IAC9B,IAAI,CAACe,WAAW,GAAGJ,KAAK,CAACI,WAAW,IAAId,YAAY;IACpD,IAAI,CAACe,IAAI,GAAGL,KAAK,CAACK,IAAI,IAAIX,IAAI;IAC9B,IAAI,CAACY,SAAS,GAAGN,KAAK,CAACM,SAAS,IAAIf,SAAS;EAC/C;;EAEA;AACF;AACA;AACA;AACA;EACEgB,iBAAiBA,CAAA,EAAY;IAC3B,OAAO,IAAI;EACb;;EAEA;AACF;AACA;AACA;AACA;EACEC,aAAaA,CAAA,EAAY;IACvB,OAAO,IAAI;EACb;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEC,WAAWA,CAAA,EAAmC;IAAA,IAAlCC,OAAgB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,KAAK;IAClC,OAAO,EAAE;EACX;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEG,SAASA,CAAA,EAAkC;IAAA,IAAjCC,OAAgB,GAAAJ,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,IAAI;IAC/B,OAAO,EAAE;EACX;;EAEA;AACF;AACA;AACA;AACA;EACEK,cAAcA,CAAA,EAAY;IACxB,OAAO,IAAI;EACb;;EAEA;AACF;AACA;AACA;AACA;EACEC,WAAWA,CAAA,EAAW;IACpB,OAAO,EAAE;EACX;;EAEA;AACF;AACA;EACEC,oBAAoBA,CAAA,EAAG;IACrB,OAAO,IAAIC,KAAK,CAACvB,iBAAiB,CAAC;EACrC;;EAEA;AACF;AACA;AACA;AACA;AACA;EACE,MAAMwB,KAAKA,CAACC,mBAAmB,EAAE;IAC/BA,mBAAmB,CAAC,CAAC;IACrB;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;EACE,MAAMC,MAAMA,CAACC,oBAAgC,EAAE;IAC7CA,oBAAoB,CAAC,CAAC;IACtB;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,SAASA,CAAAC,IAAA,EAME;IAAA,IAND;MACdC,OAAO;MACPC,OAAO,GAAG,CAAC;IAIb,CAAC,GAAAF,IAAA;IACC;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMG,QAAQA,CAAA,EAA2B;IACvC,OAAO,EAAE;EACX;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,WAAWA,CAACC,UAAU,EAA2C;IACrE;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;EAEE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAACjC,OAAA,CAAAK,OAAA,GAAAJ,QAAA","ignoreList":[]}
+    /**
+     * 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":"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","ignoreList":[]}