@kepler.gl/reducers 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/esm/provider-state-updaters.js

@@ -0,0 +1,458 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import Task, { withTask } from 'react-palm/tasks';
+import Console from 'global/console';
+import { getApplicationConfig, getError, isPlainObject } from '@kepler.gl/utils';
+import { generateHashId, toArray } from '@kepler.gl/common-utils';
+import { EXPORT_FILE_TO_CLOUD_TASK, ACTION_TASK, DELAY_TASK, LOAD_CLOUD_MAP_TASK } from '@kepler.gl/tasks';
+import { exportFileSuccess, exportFileError, postSaveLoadSuccess, loadCloudMapSuccess, loadCloudMapSuccess2, loadCloudMapError, resetProviderStatus, removeNotification, toggleModal, addNotification, addDataToMap } from '@kepler.gl/actions';
+import { DEFAULT_NOTIFICATION_TYPES, DEFAULT_NOTIFICATION_TOPICS, DATASET_FORMATS, OVERWRITE_MAP_ID } from '@kepler.gl/constants';
+import { FILE_CONFLICT_MSG } from '@kepler.gl/cloud-providers';
+import { DATASET_HANDLERS } from '@kepler.gl/processors';
+import { KeplerTable } from '@kepler.gl/table';
+export var INITIAL_PROVIDER_STATE = {
+  isProviderLoading: false,
+  isCloudMapLoading: false,
+  providerError: null,
+  currentProvider: null,
+  successInfo: {},
+  mapSaved: null,
+  savedMapId: null,
+  visualizations: []
+};
+function createActionTask(action, payload) {
+  if (typeof action === 'function') {
+    return ACTION_TASK().map(function () {
+      return action(payload);
+    });
+  }
+  return null;
+}
+function _validateProvider(provider, method) {
+  if (!provider) {
+    Console.error("provider is not defined");
+    return false;
+  }
+  if (typeof provider[method] !== 'function') {
+    Console.error("".concat(method, " is not a function of Cloud provider: ").concat(provider.name));
+    return false;
+  }
+  return true;
+}
+function createGlobalNotificationTasks(_ref) {
+  var type = _ref.type,
+    message = _ref.message,
+    _ref$delayClose = _ref.delayClose,
+    delayClose = _ref$delayClose === void 0 ? true : _ref$delayClose;
+  var id = generateHashId();
+  var successNote = {
+    id: id,
+    type: DEFAULT_NOTIFICATION_TYPES[type || ''] || DEFAULT_NOTIFICATION_TYPES.success,
+    topic: DEFAULT_NOTIFICATION_TOPICS.global,
+    message: message
+  };
+  var task = ACTION_TASK().map(function () {
+    return addNotification(successNote);
+  });
+  return delayClose ? [task, DELAY_TASK(3000).map(function () {
+    return removeNotification(id);
+  })] : [task];
+}
+
+/**
+ * This method will export the current kepler config file to the chosen cloud proder
+ * add returns a share URL
+ *
+ */
+export var exportFileToCloudUpdater = function exportFileToCloudUpdater(state, action) {
+  var _action$payload = action.payload,
+    mapData = _action$payload.mapData,
+    provider = _action$payload.provider,
+    _action$payload$optio = _action$payload.options,
+    options = _action$payload$optio === void 0 ? {} : _action$payload$optio,
+    onSuccess = _action$payload.onSuccess,
+    onError = _action$payload.onError,
+    closeModal = _action$payload.closeModal;
+  if (!_validateProvider(provider, 'uploadMap')) {
+    return state;
+  }
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    isProviderLoading: true,
+    currentProvider: provider.name
+  });
+
+  // payload called by provider.uploadMap
+  var payload = {
+    mapData: mapData,
+    options: options
+  };
+  var uploadFileTask = EXPORT_FILE_TO_CLOUD_TASK({
+    provider: provider,
+    payload: payload
+  }).bimap(
+  // success
+  function (response) {
+    return exportFileSuccess({
+      response: response,
+      provider: provider,
+      options: options,
+      onSuccess: onSuccess,
+      closeModal: closeModal
+    });
+  },
+  // error
+  function (error) {
+    return exportFileError({
+      error: error,
+      provider: provider,
+      options: options,
+      onError: onError
+    });
+  });
+  return withTask(newState, uploadFileTask);
+};
+export var exportFileSuccessUpdater = function exportFileSuccessUpdater(state, action) {
+  var _response$info$id, _response$info;
+  var _action$payload2 = action.payload,
+    response = _action$payload2.response,
+    provider = _action$payload2.provider,
+    _action$payload2$opti = _action$payload2.options,
+    options = _action$payload2$opti === void 0 ? {} : _action$payload2$opti,
+    onSuccess = _action$payload2.onSuccess,
+    closeModal = _action$payload2.closeModal;
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    isProviderLoading: false,
+    // TODO: do we always have to store this?
+    successInfo: response
+  }, !options.isPublic ? {
+    mapSaved: provider.name,
+    savedMapId: (_response$info$id = response === null || response === void 0 || (_response$info = response.info) === null || _response$info === void 0 ? void 0 : _response$info.id) !== null && _response$info$id !== void 0 ? _response$info$id : null
+  } : {});
+  var tasks = [createActionTask(onSuccess, {
+    response: response,
+    provider: provider,
+    options: options
+  }), closeModal && ACTION_TASK().map(function () {
+    return postSaveLoadSuccess("Map saved to ".concat(state.currentProvider, "!"));
+  })].filter(function (d) {
+    return d;
+  });
+  return tasks.length ? withTask(newState, tasks) : newState;
+};
+
+/**
+ * Close modal on success and display notification
+ */
+export var postSaveLoadSuccessUpdater = function postSaveLoadSuccessUpdater(state, action) {
+  var message = action.payload || "Saved / Load to ".concat(state.currentProvider, " Success");
+  var tasks = [ACTION_TASK().map(function () {
+    return toggleModal(null);
+  }), ACTION_TASK().map(function () {
+    return resetProviderStatus();
+  })].concat(_toConsumableArray(createGlobalNotificationTasks({
+    message: message
+  })));
+  return withTask(state, tasks);
+};
+export var exportFileErrorUpdater = function exportFileErrorUpdater(state, action) {
+  var _action$payload3 = action.payload,
+    error = _action$payload3.error,
+    provider = _action$payload3.provider,
+    onError = _action$payload3.onError;
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    isProviderLoading: false
+  });
+  if (isFileConflict(error)) {
+    newState.mapSaved = provider.name;
+    return withTask(newState, [ACTION_TASK().map(function () {
+      return toggleModal(OVERWRITE_MAP_ID);
+    })]);
+  }
+  newState.providerError = getError(error);
+  var task = createActionTask(onError, {
+    error: error,
+    provider: provider
+  });
+  return task ? withTask(newState, task) : newState;
+};
+export var loadCloudMapUpdater = function loadCloudMapUpdater(state, action) {
+  var _action$payload4 = action.payload,
+    loadParams = _action$payload4.loadParams,
+    provider = _action$payload4.provider,
+    onSuccess = _action$payload4.onSuccess,
+    onError = _action$payload4.onError;
+  if (!loadParams) {
+    Console.warn('load map error: loadParams is undefined');
+    return state;
+  }
+  if (!_validateProvider(provider, 'downloadMap')) {
+    return state;
+  }
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    isProviderLoading: true,
+    isCloudMapLoading: true
+  });
+
+  // payload called by provider.downloadMap
+  var uploadFileTask = LOAD_CLOUD_MAP_TASK({
+    provider: provider,
+    payload: loadParams
+  }).bimap(
+  // success
+  // @ts-expect-error
+  function (response) {
+    return loadCloudMapSuccess({
+      response: response,
+      loadParams: loadParams,
+      provider: provider,
+      onSuccess: onSuccess,
+      onError: onError
+    });
+  },
+  // error
+  // @ts-expect-error
+  function (error) {
+    return loadCloudMapError({
+      error: error,
+      provider: provider,
+      onError: onError
+    });
+  });
+  return withTask(newState, uploadFileTask);
+};
+function isFileConflict(error) {
+  return error && error.message === FILE_CONFLICT_MSG;
+}
+function checkLoadMapResponseError(response) {
+  if (!response || !isPlainObject(response)) {
+    return new Error('Load map response is empty');
+  }
+  if (!isPlainObject(response.map)) {
+    return new Error("Load map response should be an object property \"map\"");
+  }
+  if (!response.map.datasets || !response.map.config) {
+    return new Error("Load map response.map should be an object with property datasets or config");
+  }
+  return null;
+}
+function getDatasetHandler(format) {
+  var _getApplicationConfig;
+  var defaultHandler = DATASET_HANDLERS[DATASET_FORMATS.csv];
+  if (!format) {
+    Console.warn('format is not provided in load map response, will use csv by default');
+    return defaultHandler;
+  }
+
+  // use custom processors from table class
+  var TableClass = (_getApplicationConfig = getApplicationConfig().table) !== null && _getApplicationConfig !== void 0 ? _getApplicationConfig : KeplerTable;
+  if (typeof TableClass.getFileProcessor === 'function') {
+    var processorResult = TableClass.getFileProcessor(null, format);
+    if (!processorResult.processor) {
+      Console.warn("No processor found for format ".concat(format, ", will use csv by default"));
+      return defaultHandler;
+    }
+    return processorResult.processor;
+  }
+  if (!DATASET_HANDLERS[format]) {
+    var supportedFormat = Object.keys(DATASET_FORMATS).map(function (k) {
+      return "'".concat(k, "'");
+    }).join(', ');
+    Console.warn("unknown format ".concat(format, ". Please use one of ").concat(supportedFormat, ", will use csv by default"));
+    return defaultHandler;
+  }
+  return DATASET_HANDLERS[format];
+}
+
+/**
+ * A task to handle async processorMethod
+ * @param param0
+ * @returns
+ */
+function parseLoadMapResponseTask(_x) {
+  return _parseLoadMapResponseTask.apply(this, arguments);
+}
+function _parseLoadMapResponseTask() {
+  _parseLoadMapResponseTask = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref2) {
+    var response, loadParams, provider, map, format, processorMethod, parsedDatasets, parsedMap, datasets, info;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          response = _ref2.response, loadParams = _ref2.loadParams, provider = _ref2.provider;
+          map = response.map, format = response.format;
+          processorMethod = getDatasetHandler(format);
+          parsedDatasets = [];
+          if (!(format === DATASET_FORMATS.keplergl && processorMethod !== DATASET_HANDLERS[DATASET_FORMATS.keplergl])) {
+            _context2.next = 11;
+            break;
+          }
+          _context2.next = 7;
+          return processorMethod(map);
+        case 7:
+          parsedMap = _context2.sent;
+          parsedDatasets = parsedMap.datasets;
+          _context2.next = 15;
+          break;
+        case 11:
+          datasets = toArray(map.datasets);
+          _context2.next = 14;
+          return Promise.all(datasets.map(/*#__PURE__*/function () {
+            var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(ds) {
+              var info, data;
+              return _regeneratorRuntime.wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    if (!(format === DATASET_FORMATS.keplergl)) {
+                      _context.next = 4;
+                      break;
+                    }
+                    _context.next = 3;
+                    return processorMethod(ds);
+                  case 3:
+                    return _context.abrupt("return", _context.sent);
+                  case 4:
+                    info = ds && ds.info || {
+                      id: generateHashId(6)
+                    };
+                    _context.next = 7;
+                    return processorMethod(ds.data || ds);
+                  case 7:
+                    data = _context.sent;
+                    return _context.abrupt("return", {
+                      info: info,
+                      data: data
+                    });
+                  case 9:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee);
+            }));
+            return function (_x2) {
+              return _ref3.apply(this, arguments);
+            };
+          }()));
+        case 14:
+          parsedDatasets = _context2.sent;
+        case 15:
+          info = _objectSpread(_objectSpread({}, map.info), {}, {
+            provider: provider.name,
+            loadParams: loadParams
+          });
+          return _context2.abrupt("return", _objectSpread(_objectSpread({
+            datasets: parsedDatasets,
+            info: info
+          }, map.config ? {
+            config: map.config
+          } : {}), {}, {
+            options: {
+              // do not center map when loading cloud map
+              centerMap: false
+            }
+          }));
+        case 17:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _parseLoadMapResponseTask.apply(this, arguments);
+}
+var PARSE_LOAD_MAP_RESPONSE_TASK = Task.fromPromise(parseLoadMapResponseTask, 'PARSE_LOAD_MAP_RESPONSE_TASK');
+
+/**
+ * Used to load resources stored in a private storage.
+ */
+export var loadCloudMapSuccessUpdater = function loadCloudMapSuccessUpdater(state, action) {
+  var _action$payload5 = action.payload,
+    response = _action$payload5.response,
+    loadParams = _action$payload5.loadParams,
+    provider = _action$payload5.provider,
+    onError = _action$payload5.onError;
+  var formatError = checkLoadMapResponseError(response);
+  if (formatError) {
+    // if response format is not correct
+    return exportFileErrorUpdater(state, {
+      payload: {
+        error: formatError,
+        provider: provider,
+        onError: onError
+      }
+    });
+  }
+
+  // processorMethod can be async so create a task
+  var parseLoadMapResponseTask = PARSE_LOAD_MAP_RESPONSE_TASK({
+    response: response,
+    loadParams: loadParams,
+    provider: provider
+  }).bimap(function (datasetsPayload) {
+    return loadCloudMapSuccess2(_objectSpread(_objectSpread({}, action.payload), {}, {
+      datasetsPayload: datasetsPayload
+    }));
+  }, function (error) {
+    return exportFileErrorUpdater(state, {
+      payload: {
+        error: error,
+        provider: provider,
+        onError: onError
+      }
+    });
+  });
+  return withTask(state, parseLoadMapResponseTask);
+};
+export var loadCloudMapSuccess2Updater = function loadCloudMapSuccess2Updater(state, action) {
+  var _action$payload6 = action.payload,
+    datasetsPayload = _action$payload6.datasetsPayload,
+    response = _action$payload6.response,
+    loadParams = _action$payload6.loadParams,
+    provider = _action$payload6.provider,
+    onSuccess = _action$payload6.onSuccess;
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    mapSaved: provider.name,
+    currentProvider: provider.name,
+    isCloudMapLoading: false,
+    isProviderLoading: false
+  });
+  var tasks = [ACTION_TASK().map(function () {
+    return addDataToMap(datasetsPayload);
+  }), createActionTask(onSuccess, {
+    response: response,
+    loadParams: loadParams,
+    provider: provider
+  }), ACTION_TASK().map(function () {
+    return postSaveLoadSuccess("Map from ".concat(provider.name, " loaded"));
+  })].filter(function (d) {
+    return d;
+  });
+  return tasks.length ? withTask(newState, tasks) : newState;
+};
+export var loadCloudMapErrorUpdater = function loadCloudMapErrorUpdater(state, action) {
+  var message = getError(action.payload.error) || "Error loading saved map";
+  Console.warn(message);
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    isProviderLoading: false,
+    isCloudMapLoading: false,
+    providerError: null
+  });
+  return withTask(newState, createGlobalNotificationTasks({
+    type: 'error',
+    message: message,
+    delayClose: false
+  }));
+};
+export var resetProviderStatusUpdater = function resetProviderStatusUpdater(state) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    isProviderLoading: false,
+    providerError: null,
+    isCloudMapLoading: false,
+    successInfo: {}
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Task","withTask","Console","getApplicationConfig","getError","isPlainObject","generateHashId","toArray","EXPORT_FILE_TO_CLOUD_TASK","ACTION_TASK","DELAY_TASK","LOAD_CLOUD_MAP_TASK","exportFileSuccess","exportFileError","postSaveLoadSuccess","loadCloudMapSuccess","loadCloudMapSuccess2","loadCloudMapError","resetProviderStatus","removeNotification","toggleModal","addNotification","addDataToMap","DEFAULT_NOTIFICATION_TYPES","DEFAULT_NOTIFICATION_TOPICS","DATASET_FORMATS","OVERWRITE_MAP_ID","FILE_CONFLICT_MSG","DATASET_HANDLERS","KeplerTable","INITIAL_PROVIDER_STATE","isProviderLoading","isCloudMapLoading","providerError","currentProvider","successInfo","mapSaved","savedMapId","visualizations","createActionTask","action","payload","map","_validateProvider","provider","method","error","concat","name","createGlobalNotificationTasks","_ref","type","message","_ref$delayClose","delayClose","id","successNote","success","topic","global","task","exportFileToCloudUpdater","state","_action$payload","mapData","_action$payload$optio","options","onSuccess","onError","closeModal","newState","_objectSpread","uploadFileTask","bimap","response","exportFileSuccessUpdater","_response$info$id","_response$info","_action$payload2","_action$payload2$opti","isPublic","info","tasks","filter","d","length","postSaveLoadSuccessUpdater","_toConsumableArray","exportFileErrorUpdater","_action$payload3","isFileConflict","loadCloudMapUpdater","_action$payload4","loadParams","warn","checkLoadMapResponseError","Error","datasets","config","getDatasetHandler","format","_getApplicationConfig","defaultHandler","csv","TableClass","table","getFileProcessor","processorResult","processor","supportedFormat","Object","keys","k","join","parseLoadMapResponseTask","_x","_parseLoadMapResponseTask","apply","arguments","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","_ref2","processorMethod","parsedDatasets","parsedMap","wrap","_callee2$","_context2","prev","next","keplergl","sent","Promise","all","_ref3","_callee","ds","data","_callee$","_context","abrupt","stop","_x2","centerMap","PARSE_LOAD_MAP_RESPONSE_TASK","fromPromise","loadCloudMapSuccessUpdater","_action$payload5","formatError","datasetsPayload","loadCloudMapSuccess2Updater","_action$payload6","loadCloudMapErrorUpdater","resetProviderStatusUpdater"],"sources":["../../src/provider-state-updaters.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport Task, {withTask} from 'react-palm/tasks';\nimport Console from 'global/console';\nimport {getApplicationConfig, getError, isPlainObject} from '@kepler.gl/utils';\nimport {generateHashId, toArray} from '@kepler.gl/common-utils';\nimport {\n  EXPORT_FILE_TO_CLOUD_TASK,\n  ACTION_TASK,\n  DELAY_TASK,\n  LOAD_CLOUD_MAP_TASK\n} from '@kepler.gl/tasks';\nimport {\n  exportFileSuccess,\n  exportFileError,\n  postSaveLoadSuccess,\n  loadCloudMapSuccess,\n  loadCloudMapSuccess2,\n  loadCloudMapError,\n  resetProviderStatus,\n  removeNotification,\n  toggleModal,\n  addNotification,\n  addDataToMap,\n  ProviderActions\n} from '@kepler.gl/actions';\nimport {\n  DEFAULT_NOTIFICATION_TYPES,\n  DEFAULT_NOTIFICATION_TOPICS,\n  DATASET_FORMATS,\n  OVERWRITE_MAP_ID\n} from '@kepler.gl/constants';\nimport {AddDataToMapPayload, ExportFileToCloudPayload} from '@kepler.gl/types';\n\nimport {FILE_CONFLICT_MSG, MapListItem} from '@kepler.gl/cloud-providers';\nimport {DATASET_HANDLERS} from '@kepler.gl/processors';\nimport {KeplerTable} from '@kepler.gl/table';\n\ntype ActionPayload<P> = {\n  type?: string;\n  payload: P;\n};\n\nexport type ProviderState = {\n  isProviderLoading: boolean;\n  isCloudMapLoading: boolean;\n  providerError: any;\n  currentProvider: string | null;\n  successInfo: any;\n  mapSaved: null | string;\n  savedMapId: null | string;\n  initialState?: any;\n  visualizations: MapListItem[];\n};\n\nexport const INITIAL_PROVIDER_STATE: ProviderState = {\n  isProviderLoading: false,\n  isCloudMapLoading: false,\n  providerError: null,\n  currentProvider: null,\n  successInfo: {},\n  mapSaved: null,\n  savedMapId: null,\n  visualizations: []\n};\n\nfunction createActionTask(action, payload) {\n  if (typeof action === 'function') {\n    return ACTION_TASK().map(() => action(payload));\n  }\n\n  return null;\n}\n\nfunction _validateProvider(provider, method) {\n  if (!provider) {\n    Console.error(`provider is not defined`);\n    return false;\n  }\n\n  if (typeof provider[method] !== 'function') {\n    Console.error(`${method} is not a function of Cloud provider: ${provider.name}`);\n    return false;\n  }\n\n  return true;\n}\n\nfunction createGlobalNotificationTasks({\n  type,\n  message,\n  delayClose = true\n}: {\n  type?: string;\n  message: string;\n  delayClose?: boolean;\n}) {\n  const id = generateHashId();\n  const successNote = {\n    id,\n    type: DEFAULT_NOTIFICATION_TYPES[type || ''] || DEFAULT_NOTIFICATION_TYPES.success,\n    topic: DEFAULT_NOTIFICATION_TOPICS.global,\n    message\n  };\n  const task = ACTION_TASK().map(() => addNotification(successNote));\n  return delayClose ? [task, DELAY_TASK(3000).map(() => removeNotification(id))] : [task];\n}\n\n/**\n * This method will export the current kepler config file to the chosen cloud proder\n * add returns a share URL\n *\n */\nexport const exportFileToCloudUpdater = (\n  state: ProviderState,\n  action: ActionPayload<ExportFileToCloudPayload>\n): ProviderState => {\n  const {mapData, provider, options = {}, onSuccess, onError, closeModal} = action.payload;\n\n  if (!_validateProvider(provider, 'uploadMap')) {\n    return state;\n  }\n\n  const newState = {\n    ...state,\n    isProviderLoading: true,\n    currentProvider: provider.name\n  };\n\n  // payload called by provider.uploadMap\n  const payload = {\n    mapData,\n    options\n  };\n  const uploadFileTask = EXPORT_FILE_TO_CLOUD_TASK({provider, payload}).bimap(\n    // success\n    response => exportFileSuccess({response, provider, options, onSuccess, closeModal}),\n    // error\n    error => exportFileError({error, provider, options, onError})\n  );\n\n  return withTask(newState, uploadFileTask);\n};\n\nexport const exportFileSuccessUpdater = (\n  state: ProviderState,\n  action: ActionPayload<ProviderActions.ExportFileSuccessPayload>\n): ProviderState => {\n  const {response, provider, options = {}, onSuccess, closeModal} = action.payload;\n\n  const newState = {\n    ...state,\n    isProviderLoading: false,\n    // TODO: do we always have to store this?\n    successInfo: response,\n    ...(!options.isPublic\n      ? {\n          mapSaved: provider.name,\n          savedMapId: response?.info?.id ?? null\n        }\n      : {})\n  };\n\n  const tasks = [\n    createActionTask(onSuccess, {response, provider, options}),\n    closeModal &&\n      ACTION_TASK().map(() => postSaveLoadSuccess(`Map saved to ${state.currentProvider}!`))\n  ].filter(d => d);\n\n  return tasks.length ? withTask(newState, tasks) : newState;\n};\n\n/**\n * Close modal on success and display notification\n */\nexport const postSaveLoadSuccessUpdater = (\n  state: ProviderState,\n  action: ActionPayload<ProviderActions.PostSaveLoadSuccessPayload>\n): ProviderState => {\n  const message = action.payload || `Saved / Load to ${state.currentProvider} Success`;\n\n  const tasks = [\n    ACTION_TASK().map(() => toggleModal(null)),\n    ACTION_TASK().map(() => resetProviderStatus()),\n    ...createGlobalNotificationTasks({message})\n  ];\n\n  return withTask(state, tasks);\n};\n\nexport const exportFileErrorUpdater = (\n  state: ProviderState,\n  action: ActionPayload<ProviderActions.ExportFileErrorPayload>\n): ProviderState => {\n  const {error, provider, onError} = action.payload;\n\n  const newState = {\n    ...state,\n    isProviderLoading: false\n  };\n\n  if (isFileConflict(error)) {\n    newState.mapSaved = provider.name;\n    return withTask(newState, [ACTION_TASK().map(() => toggleModal(OVERWRITE_MAP_ID))]);\n  }\n\n  newState.providerError = getError(error);\n  const task = createActionTask(onError, {error, provider});\n\n  return task ? withTask(newState, task) : newState;\n};\n\nexport const loadCloudMapUpdater = (\n  state: ProviderState,\n  action: ActionPayload<ProviderActions.LoadCloudMapPayload>\n): ProviderState => {\n  const {loadParams, provider, onSuccess, onError} = action.payload;\n  if (!loadParams) {\n    Console.warn('load map error: loadParams is undefined');\n    return state;\n  }\n  if (!_validateProvider(provider, 'downloadMap')) {\n    return state;\n  }\n\n  const newState = {\n    ...state,\n    isProviderLoading: true,\n    isCloudMapLoading: true\n  };\n\n  // payload called by provider.downloadMap\n  const uploadFileTask = LOAD_CLOUD_MAP_TASK({provider, payload: loadParams}).bimap(\n    // success\n    // @ts-expect-error\n    response => loadCloudMapSuccess({response, loadParams, provider, onSuccess, onError}),\n    // error\n    // @ts-expect-error\n    error => loadCloudMapError({error, provider, onError})\n  );\n\n  return withTask(newState, uploadFileTask);\n};\n\nfunction isFileConflict(error) {\n  return error && error.message === FILE_CONFLICT_MSG;\n}\n\nfunction checkLoadMapResponseError(response) {\n  if (!response || !isPlainObject(response)) {\n    return new Error('Load map response is empty');\n  }\n  if (!isPlainObject(response.map)) {\n    return new Error(`Load map response should be an object property \"map\"`);\n  }\n  if (!response.map.datasets || !response.map.config) {\n    return new Error(`Load map response.map should be an object with property datasets or config`);\n  }\n\n  return null;\n}\n\nfunction getDatasetHandler(format) {\n  const defaultHandler = DATASET_HANDLERS[DATASET_FORMATS.csv];\n  if (!format) {\n    Console.warn('format is not provided in load map response, will use csv by default');\n    return defaultHandler;\n  }\n\n  // use custom processors from table class\n  const TableClass = getApplicationConfig().table ?? KeplerTable;\n  if (typeof TableClass.getFileProcessor === 'function') {\n    const processorResult = TableClass.getFileProcessor(null, format);\n    if (!processorResult.processor) {\n      Console.warn(`No processor found for format ${format}, will use csv by default`);\n      return defaultHandler;\n    }\n    return processorResult.processor;\n  }\n\n  if (!DATASET_HANDLERS[format]) {\n    const supportedFormat = Object.keys(DATASET_FORMATS)\n      .map(k => `'${k}'`)\n      .join(', ');\n    Console.warn(\n      `unknown format ${format}. Please use one of ${supportedFormat}, will use csv by default`\n    );\n    return defaultHandler;\n  }\n\n  return DATASET_HANDLERS[format];\n}\n\n/**\n * A task to handle async processorMethod\n * @param param0\n * @returns\n */\nasync function parseLoadMapResponseTask({\n  response,\n  loadParams,\n  provider\n}: {\n  response: ProviderActions.LoadCloudMapSuccessPayload['response'];\n  loadParams: ProviderActions.LoadCloudMapSuccessPayload['loadParams'];\n  provider: ProviderActions.LoadCloudMapSuccessPayload['provider'];\n}) {\n  const {map, format} = response;\n  const processorMethod = getDatasetHandler(format);\n\n  let parsedDatasets: AddDataToMapPayload['datasets'] = [];\n\n  if (\n    format === DATASET_FORMATS.keplergl &&\n    processorMethod !== DATASET_HANDLERS[DATASET_FORMATS.keplergl]\n  ) {\n    // plugin table provides processor for keplergl map, not single dataset with allData\n    const parsedMap = await processorMethod(map);\n    parsedDatasets = parsedMap.datasets;\n  } else {\n    const datasets = toArray(map.datasets);\n    parsedDatasets = await Promise.all(\n      datasets.map(async ds => {\n        if (format === DATASET_FORMATS.keplergl) {\n          // no need to obtain id, directly pass them in\n          return await processorMethod(ds);\n        }\n        const info = (ds && ds.info) || {id: generateHashId(6)};\n        const data = await processorMethod(ds.data || ds);\n        return {info, data};\n      })\n    );\n  }\n\n  const info = {\n    ...map.info,\n    provider: provider.name,\n    loadParams\n  };\n  return {\n    datasets: parsedDatasets,\n    info,\n    ...(map.config ? {config: map.config} : {}),\n    options: {\n      // do not center map when loading cloud map\n      centerMap: false\n    }\n  };\n}\n\nconst PARSE_LOAD_MAP_RESPONSE_TASK = Task.fromPromise(\n  parseLoadMapResponseTask,\n  'PARSE_LOAD_MAP_RESPONSE_TASK'\n);\n\n/**\n * Used to load resources stored in a private storage.\n */\nexport const loadCloudMapSuccessUpdater = (\n  state: ProviderState,\n  action: ActionPayload<ProviderActions.LoadCloudMapSuccessPayload>\n): ProviderState => {\n  const {response, loadParams, provider, onError} = action.payload;\n\n  const formatError = checkLoadMapResponseError(response);\n  if (formatError) {\n    // if response format is not correct\n    return exportFileErrorUpdater(state, {\n      payload: {error: formatError, provider, onError}\n    });\n  }\n\n  // processorMethod can be async so create a task\n  const parseLoadMapResponseTask = PARSE_LOAD_MAP_RESPONSE_TASK({\n    response,\n    loadParams,\n    provider\n  }).bimap(\n    (datasetsPayload: AddDataToMapPayload) => {\n      return loadCloudMapSuccess2({...action.payload, datasetsPayload});\n    },\n    error =>\n      exportFileErrorUpdater(state, {\n        payload: {error, provider, onError}\n      })\n  );\n\n  return withTask(state, parseLoadMapResponseTask);\n};\n\nexport const loadCloudMapSuccess2Updater = (\n  state: ProviderState,\n  action: ActionPayload<ProviderActions.LoadCloudMapSuccess2Payload>\n): ProviderState => {\n  const {datasetsPayload, response, loadParams, provider, onSuccess} = action.payload;\n\n  const newState = {\n    ...state,\n    mapSaved: provider.name,\n    currentProvider: provider.name,\n    isCloudMapLoading: false,\n    isProviderLoading: false\n  };\n\n  const tasks = [\n    ACTION_TASK().map(() => addDataToMap(datasetsPayload)),\n    createActionTask(onSuccess, {response, loadParams, provider}),\n    ACTION_TASK().map(() => postSaveLoadSuccess(`Map from ${provider.name} loaded`))\n  ].filter(d => d);\n\n  return tasks.length ? withTask(newState, tasks) : newState;\n};\n\nexport const loadCloudMapErrorUpdater = (\n  state: ProviderState,\n  action: ActionPayload<ProviderActions.LoadCloudMapErrorPayload>\n): ProviderState => {\n  const message = getError(action.payload.error) || `Error loading saved map`;\n\n  Console.warn(message);\n\n  const newState = {\n    ...state,\n    isProviderLoading: false,\n    isCloudMapLoading: false,\n    providerError: null\n  };\n\n  return withTask(\n    newState,\n    createGlobalNotificationTasks({type: 'error', message, delayClose: false})\n  );\n};\n\nexport const resetProviderStatusUpdater = (state: ProviderState): ProviderState => ({\n  ...state,\n  isProviderLoading: false,\n  providerError: null,\n  isCloudMapLoading: false,\n  successInfo: {}\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/provider-state.js

@@ -0,0 +1,28 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { handleActions } from 'redux-actions';
+import * as providerStateUpdaters from './provider-state-updaters';
+import { ProviderActionTypes as ActionTypes } from '@kepler.gl/actions';
+
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+var actionHandler = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, ActionTypes.EXPORT_FILE_TO_CLOUD, providerStateUpdaters.exportFileToCloudUpdater), ActionTypes.EXPORT_FILE_SUCCESS, providerStateUpdaters.exportFileSuccessUpdater), ActionTypes.EXPORT_FILE_ERROR, providerStateUpdaters.exportFileErrorUpdater), ActionTypes.RESET_PROVIDER_STATUS, providerStateUpdaters.resetProviderStatusUpdater), ActionTypes.POST_SAVE_LOAD_SUCCESS, providerStateUpdaters.postSaveLoadSuccessUpdater), ActionTypes.LOAD_CLOUD_MAP, providerStateUpdaters.loadCloudMapUpdater), ActionTypes.LOAD_CLOUD_MAP_SUCCESS, providerStateUpdaters.loadCloudMapSuccessUpdater), ActionTypes.LOAD_CLOUD_MAP_SUCCESS_2, providerStateUpdaters.loadCloudMapSuccess2Updater), ActionTypes.LOAD_CLOUD_MAP_ERROR, providerStateUpdaters.loadCloudMapErrorUpdater);
+
+// construct provider-state reducer
+export var providerStateReducerFactory = function providerStateReducerFactory() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (
+    // @ts-expect-error
+    handleActions(actionHandler, _objectSpread(_objectSpread(_objectSpread({}, providerStateUpdaters.INITIAL_PROVIDER_STATE), initialState), {}, {
+      initialState: initialState
+    }))
+  );
+};
+export default providerStateReducerFactory();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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