@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/cloud-providers/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Provider", {
+  enumerable: true,
+  get: function get() {
+    return _provider["default"];
+  }
+});
+Object.defineProperty(exports, "FILE_CONFLICT_MSG", {
+  enumerable: true,
+  get: function get() {
+    return _provider.FILE_CONFLICT_MSG;
+  }
+});
+
+var _provider = _interopRequireWildcard(require("./provider"));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbG91ZC1wcm92aWRlcnMvaW5kZXguanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFvQkEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgKGMpIDIwMjIgVWJlciBUZWNobm9sb2dpZXMsIEluYy5cbi8vXG4vLyBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5XG4vLyBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4vLyBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzXG4vLyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsXG4vLyBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbi8vIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6XG4vL1xuLy8gVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW5cbi8vIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLlxuLy9cbi8vIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1Jcbi8vIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLFxuLy8gRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4vLyBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSXG4vLyBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLFxuLy8gT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTlxuLy8gVEhFIFNPRlRXQVJFLlxuXG5leHBvcnQge2RlZmF1bHQgYXMgUHJvdmlkZXIsIEZJTEVfQ09ORkxJQ1RfTVNHfSBmcm9tICcuL3Byb3ZpZGVyJztcbiJdfQ==

package/dist/cloud-providers/provider.js

@@ -0,0 +1,386 @@
+"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 = '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}
+ * })
+ */
+
+exports.FILE_CONFLICT_MSG = FILE_CONFLICT_MSG;
+
+var Provider = /*#__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 {boolean}
+   * @public
+   */
+
+
+  (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 {boolean}
+     * @public
+     */
+
+  }, {
+    key: "hasSharingUrl",
+    value: function hasSharingUrl() {
+      return true;
+    }
+    /**
+     * This method is called after user share a map, to display the share url.
+     * @param {boolean} fullUrl - Whether to return the full url with domain, or just the location
+     * @returns {string} 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 {boolean} fullURL - Whether to return the full url with domain, or just the location
+     * @returns {string} 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 {boolean} 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 {string} 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
+     */
+
+  }]);
+  return Provider;
+}();
+
+exports["default"] = Provider;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/cloud-providers/provider.js"],"names":["NAME","DISPLAY_NAME","THUMBNAIL","width","height","ICON","Upload","FILE_CONFLICT_MSG","Provider","props","name","displayName","icon","thumbnail","fullUrl","fullURL","Error","onCloudLoginSuccess","onCloudLogoutSuccess","mapData","options","loadParams"],"mappings":";;;;;;;;;;;;;;;;;AAoBA;;AApBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAIA,IAAMA,IAAI,GAAG,gBAAb;AACA,IAAMC,YAAY,GAAG,gBAArB;AACA,IAAMC,SAAS,GAAG;AAACC,EAAAA,KAAK,EAAE,GAAR;AAAaC,EAAAA,MAAM,EAAE;AAArB,CAAlB;AACA,IAAMC,IAAI,GAAGC,aAAb;AACO,IAAMC,iBAAiB,GAAG,eAA1B;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;IACqBC,Q;AACnB,oBAAYC,KAAZ,EAAmB;AAAA;AACjB,SAAKC,IAAL,GAAYD,KAAK,CAACC,IAAN,IAAcV,IAA1B;AACA,SAAKW,WAAL,GAAmBF,KAAK,CAACE,WAAN,IAAqBV,YAAxC;AACA,SAAKW,IAAL,GAAYH,KAAK,CAACG,IAAN,IAAcP,IAA1B;AACA,SAAKQ,SAAL,GAAiBJ,KAAK,CAACI,SAAN,IAAmBX,SAApC;AACD;AAED;AACF;AACA;AACA;AACA;;;;;WACE,6BAAoB;AAClB,aAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,yBAAgB;AACd,aAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,uBAA6B;AAAA,UAAjBY,OAAiB,uEAAP,KAAO;AAC3B,aAAO,EAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,qBAA0B;AAAA,UAAhBC,OAAgB,uEAAN,IAAM;AACxB,aAAO,EAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,0BAAiB;AACf,aAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,uBAAc;AACZ,aAAO,EAAP;AACD;AAED;AACF;AACA;;;;WACE,gCAAuB;AACrB,aAAO,IAAIC,KAAJ,CAAUT,iBAAV,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;;iGACE,iBAAYU,mBAAZ;AAAA;AAAA;AAAA;AAAA;AACEA,gBAAAA,mBAAmB;AADrB;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;AAKA;AACF;AACA;AACA;AACA;AACA;;;;;kGACE,kBAAaC,oBAAb;AAAA;AAAA;AAAA;AAAA;AACEA,gBAAAA,oBAAoB;AADtB;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;AAKA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;qGACE;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAiBC,gBAAAA,OAAjB,QAAiBA,OAAjB,sBAA0BC,OAA1B,EAA0BA,OAA1B,6BAAoC,EAApC;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;AAIA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;oGACE;AAAA;AAAA;AAAA;AAAA;AAAA,kDACS,EADT;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;AAIA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;uGACE,kBAAkBC,UAAlB;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;AAIA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","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';\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  constructor(props) {\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 {boolean}\n   * @public\n   */\n  hasPrivateStorage() {\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 {boolean}\n   * @public\n   */\n  hasSharingUrl() {\n    return true;\n  }\n\n  /**\n   * This method is called after user share a map, to display the share url.\n   * @param {boolean} fullUrl - Whether to return the full url with domain, or just the location\n   * @returns {string} shareUrl\n   * @public\n   */\n  getShareUrl(fullUrl = false) {\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 {boolean} fullURL - Whether to return the full url with domain, or just the location\n   * @returns {string} mapUrl\n   * @public\n   */\n  getMapUrl(fullURL = true) {\n    return '';\n  }\n\n  /**\n   * This method is called to determine whether user already logged in to this provider\n   * @public\n   * @returns {boolean} true if a user already logged in\n   */\n  getAccessToken() {\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 {string} true if a user already logged in\n   */\n  getUserName() {\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) {\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({mapData, options = {}}) {\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() {\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) {\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"]}