@kepler.gl/reducers 3.1.0-alpha.0 → 3.1.0-alpha.2

package/dist/ui-state.d.ts

@@ -0,0 +1,3 @@
+export declare const uiStateReducerFactory: (initialState?: {}) => import("redux-actions").ReduxCompatibleReducer<import("@kepler.gl/types").UiState, import("@kepler.gl/types").UiState>;
+declare const _default: import("redux-actions").ReduxCompatibleReducer<import("@kepler.gl/types").UiState, import("@kepler.gl/types").UiState>;
+export default _default;

package/dist/ui-state.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uiStateReducerFactory = exports["default"] = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _reduxActions = require("redux-actions");
+var _actions = require("@kepler.gl/actions");
+var uiStateUpdaters = _interopRequireWildcard(require("./ui-state-updaters"));
+var _actionHandler; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+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; }
+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) { (0, _defineProperty2["default"])(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; }
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+var actionHandler = (_actionHandler = {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.INIT, uiStateUpdaters.initUiStateUpdater), _actions.ActionTypes.TOGGLE_SIDE_PANEL, uiStateUpdaters.toggleSidePanelUpdater), _actions.ActionTypes.TOGGLE_MODAL, uiStateUpdaters.toggleModalUpdater), _actions.ActionTypes.SHOW_EXPORT_DROPDOWN, uiStateUpdaters.showExportDropdownUpdater), _actions.ActionTypes.HIDE_EXPORT_DROPDOWN, uiStateUpdaters.hideExportDropdownUpdater), _actions.ActionTypes.TOGGLE_SIDE_PANEL_CLOSE_BUTTON, uiStateUpdaters.toggleSidePanelCloseButtonUpdater), _actions.ActionTypes.OPEN_DELETE_MODAL, uiStateUpdaters.openDeleteModalUpdater), _actions.ActionTypes.TOGGLE_MAP_CONTROL, uiStateUpdaters.toggleMapControlUpdater), _actions.ActionTypes.SET_MAP_CONTROL_VISIBILITY, uiStateUpdaters.setMapControlVisibilityUpdater), _actions.ActionTypes.ADD_NOTIFICATION, uiStateUpdaters.addNotificationUpdater), (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.REMOVE_NOTIFICATION, uiStateUpdaters.removeNotificationUpdater), _actions.ActionTypes.SET_EXPORT_IMAGE_SETTING, uiStateUpdaters.setExportImageSettingUpdater), _actions.ActionTypes.SET_EXPORT_IMAGE_DATA_URI, uiStateUpdaters.setExportImageDataUriUpdater), _actions.ActionTypes.SET_EXPORT_IMAGE_ERROR, uiStateUpdaters.setExportImageErrorUpdater), _actions.ActionTypes.CLEANUP_EXPORT_IMAGE, uiStateUpdaters.cleanupExportImageUpdater), _actions.ActionTypes.START_EXPORTING_IMAGE, uiStateUpdaters.startExportingImageUpdater), _actions.ActionTypes.SET_EXPORT_SELECTED_DATASET, uiStateUpdaters.setExportSelectedDatasetUpdater), _actions.ActionTypes.SET_EXPORT_DATA_TYPE, uiStateUpdaters.setExportDataTypeUpdater), _actions.ActionTypes.SET_EXPORT_FILTERED, uiStateUpdaters.setExportFilteredUpdater), _actions.ActionTypes.SET_EXPORT_DATA, uiStateUpdaters.setExportDataUpdater), (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_USER_MAPBOX_ACCESS_TOKEN, uiStateUpdaters.setUserMapboxAccessTokenUpdater), _actions.ActionTypes.SET_EXPORT_MAP_FORMAT, uiStateUpdaters.setExportMapFormatUpdater), _actions.ActionTypes.SET_EXPORT_MAP_HTML_MODE, uiStateUpdaters.setExportMapHTMLModeUpdater), _actions.ActionTypes.LOAD_FILES, uiStateUpdaters.loadFilesUpdater), _actions.ActionTypes.LOAD_FILES_ERR, uiStateUpdaters.loadFilesErrUpdater), _actions.ActionTypes.TOGGLE_SPLIT_MAP, uiStateUpdaters.toggleSplitMapUpdater), _actions.ActionTypes.SHOW_DATASET_TABLE, uiStateUpdaters.showDatasetTableUpdater), _actions.ActionTypes.SET_LOCALE, uiStateUpdaters.setLocaleUpdater), _actions.ActionTypes.TOGGLE_PANEL_LIST_VIEW, uiStateUpdaters.togglePanelListViewUpdater));
+
+/* Reducer */
+var uiStateReducerFactory = exports.uiStateReducerFactory = function uiStateReducerFactory() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (
+    // @ts-expect-error
+    (0, _reduxActions.handleActions)(actionHandler, _objectSpread(_objectSpread(_objectSpread({}, uiStateUpdaters.INITIAL_UI_STATE), initialState), {}, {
+      // @ts-ignore
+      initialState: initialState
+    }))
+  );
+};
+var _default = exports["default"] = uiStateReducerFactory();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_reduxActions","require","_actions","uiStateUpdaters","_interopRequireWildcard","_actionHandler","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","ownKeys","keys","getOwnPropertySymbols","o","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","actionHandler","ActionTypes","INIT","initUiStateUpdater","TOGGLE_SIDE_PANEL","toggleSidePanelUpdater","TOGGLE_MODAL","toggleModalUpdater","SHOW_EXPORT_DROPDOWN","showExportDropdownUpdater","HIDE_EXPORT_DROPDOWN","hideExportDropdownUpdater","TOGGLE_SIDE_PANEL_CLOSE_BUTTON","toggleSidePanelCloseButtonUpdater","OPEN_DELETE_MODAL","openDeleteModalUpdater","TOGGLE_MAP_CONTROL","toggleMapControlUpdater","SET_MAP_CONTROL_VISIBILITY","setMapControlVisibilityUpdater","ADD_NOTIFICATION","addNotificationUpdater","REMOVE_NOTIFICATION","removeNotificationUpdater","SET_EXPORT_IMAGE_SETTING","setExportImageSettingUpdater","SET_EXPORT_IMAGE_DATA_URI","setExportImageDataUriUpdater","SET_EXPORT_IMAGE_ERROR","setExportImageErrorUpdater","CLEANUP_EXPORT_IMAGE","cleanupExportImageUpdater","START_EXPORTING_IMAGE","startExportingImageUpdater","SET_EXPORT_SELECTED_DATASET","setExportSelectedDatasetUpdater","SET_EXPORT_DATA_TYPE","setExportDataTypeUpdater","SET_EXPORT_FILTERED","setExportFilteredUpdater","SET_EXPORT_DATA","setExportDataUpdater","SET_USER_MAPBOX_ACCESS_TOKEN","setUserMapboxAccessTokenUpdater","SET_EXPORT_MAP_FORMAT","setExportMapFormatUpdater","SET_EXPORT_MAP_HTML_MODE","setExportMapHTMLModeUpdater","LOAD_FILES","loadFilesUpdater","LOAD_FILES_ERR","loadFilesErrUpdater","TOGGLE_SPLIT_MAP","toggleSplitMapUpdater","SHOW_DATASET_TABLE","showDatasetTableUpdater","SET_LOCALE","setLocaleUpdater","TOGGLE_PANEL_LIST_VIEW","togglePanelListViewUpdater","uiStateReducerFactory","exports","initialState","undefined","handleActions","INITIAL_UI_STATE","_default"],"sources":["../src/ui-state.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {handleActions} from 'redux-actions';\nimport {ActionTypes} from '@kepler.gl/actions';\nimport * as uiStateUpdaters from './ui-state-updaters';\n\n/**\n * Important: Do not rename `actionHandler` or the assignment pattern of property value.\n * It is used to generate documentation\n */\nconst actionHandler = {\n  [ActionTypes.INIT]: uiStateUpdaters.initUiStateUpdater,\n  [ActionTypes.TOGGLE_SIDE_PANEL]: uiStateUpdaters.toggleSidePanelUpdater,\n  [ActionTypes.TOGGLE_MODAL]: uiStateUpdaters.toggleModalUpdater,\n  [ActionTypes.SHOW_EXPORT_DROPDOWN]: uiStateUpdaters.showExportDropdownUpdater,\n  [ActionTypes.HIDE_EXPORT_DROPDOWN]: uiStateUpdaters.hideExportDropdownUpdater,\n  [ActionTypes.TOGGLE_SIDE_PANEL_CLOSE_BUTTON]: uiStateUpdaters.toggleSidePanelCloseButtonUpdater,\n  [ActionTypes.OPEN_DELETE_MODAL]: uiStateUpdaters.openDeleteModalUpdater,\n  [ActionTypes.TOGGLE_MAP_CONTROL]: uiStateUpdaters.toggleMapControlUpdater,\n  [ActionTypes.SET_MAP_CONTROL_VISIBILITY]: uiStateUpdaters.setMapControlVisibilityUpdater,\n  [ActionTypes.ADD_NOTIFICATION]: uiStateUpdaters.addNotificationUpdater,\n  [ActionTypes.REMOVE_NOTIFICATION]: uiStateUpdaters.removeNotificationUpdater,\n\n  [ActionTypes.SET_EXPORT_IMAGE_SETTING]: uiStateUpdaters.setExportImageSettingUpdater,\n  [ActionTypes.SET_EXPORT_IMAGE_DATA_URI]: uiStateUpdaters.setExportImageDataUriUpdater,\n  [ActionTypes.SET_EXPORT_IMAGE_ERROR]: uiStateUpdaters.setExportImageErrorUpdater,\n  [ActionTypes.CLEANUP_EXPORT_IMAGE]: uiStateUpdaters.cleanupExportImageUpdater,\n  [ActionTypes.START_EXPORTING_IMAGE]: uiStateUpdaters.startExportingImageUpdater,\n\n  [ActionTypes.SET_EXPORT_SELECTED_DATASET]: uiStateUpdaters.setExportSelectedDatasetUpdater,\n  [ActionTypes.SET_EXPORT_DATA_TYPE]: uiStateUpdaters.setExportDataTypeUpdater,\n  [ActionTypes.SET_EXPORT_FILTERED]: uiStateUpdaters.setExportFilteredUpdater,\n  [ActionTypes.SET_EXPORT_DATA]: uiStateUpdaters.setExportDataUpdater,\n  [ActionTypes.SET_USER_MAPBOX_ACCESS_TOKEN]: uiStateUpdaters.setUserMapboxAccessTokenUpdater,\n\n  [ActionTypes.SET_EXPORT_MAP_FORMAT]: uiStateUpdaters.setExportMapFormatUpdater,\n\n  [ActionTypes.SET_EXPORT_MAP_HTML_MODE]: uiStateUpdaters.setExportMapHTMLModeUpdater,\n  [ActionTypes.LOAD_FILES]: uiStateUpdaters.loadFilesUpdater,\n  [ActionTypes.LOAD_FILES_ERR]: uiStateUpdaters.loadFilesErrUpdater,\n\n  [ActionTypes.TOGGLE_SPLIT_MAP]: uiStateUpdaters.toggleSplitMapUpdater,\n  [ActionTypes.SHOW_DATASET_TABLE]: uiStateUpdaters.showDatasetTableUpdater,\n  [ActionTypes.SET_LOCALE]: uiStateUpdaters.setLocaleUpdater,\n  [ActionTypes.TOGGLE_PANEL_LIST_VIEW]: uiStateUpdaters.togglePanelListViewUpdater\n};\n\n/* Reducer */\nexport const uiStateReducerFactory = (initialState = {}) =>\n  // @ts-expect-error\n  handleActions(actionHandler, {\n    ...uiStateUpdaters.INITIAL_UI_STATE,\n    ...initialState,\n    // @ts-ignore\n    initialState\n  });\n\nexport default uiStateReducerFactory();\n"],"mappings":";;;;;;;;;AAGA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAC,uBAAA,CAAAH,OAAA;AAAuD,IAAAI,cAAA,EALvD;AACA;AAAA,SAAAC,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,yBAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAH,wBAAAG,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAI,UAAA,SAAAJ,CAAA,eAAAA,CAAA,gBAAAK,OAAA,CAAAL,CAAA,0BAAAA,CAAA,sBAAAA,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAG,GAAA,CAAAN,CAAA,UAAAG,CAAA,CAAAI,GAAA,CAAAP,CAAA,OAAAQ,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,CAAA,IAAAd,CAAA,oBAAAc,CAAA,OAAAC,cAAA,CAAAC,IAAA,CAAAhB,CAAA,EAAAc,CAAA,SAAAG,CAAA,GAAAP,CAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAb,CAAA,EAAAc,CAAA,UAAAG,CAAA,KAAAA,CAAA,CAAAV,GAAA,IAAAU,CAAA,CAAAC,GAAA,IAAAP,MAAA,CAAAC,cAAA,CAAAJ,CAAA,EAAAM,CAAA,EAAAG,CAAA,IAAAT,CAAA,CAAAM,CAAA,IAAAd,CAAA,CAAAc,CAAA,YAAAN,CAAA,cAAAR,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAe,GAAA,CAAAlB,CAAA,EAAAQ,CAAA,GAAAA,CAAA;AAAA,SAAAW,QAAAnB,CAAA,EAAAE,CAAA,QAAAC,CAAA,GAAAQ,MAAA,CAAAS,IAAA,CAAApB,CAAA,OAAAW,MAAA,CAAAU,qBAAA,QAAAC,CAAA,GAAAX,MAAA,CAAAU,qBAAA,CAAArB,CAAA,GAAAE,CAAA,KAAAoB,CAAA,GAAAA,CAAA,CAAAC,MAAA,WAAArB,CAAA,WAAAS,MAAA,CAAAE,wBAAA,CAAAb,CAAA,EAAAE,CAAA,EAAAsB,UAAA,OAAArB,CAAA,CAAAsB,IAAA,CAAAC,KAAA,CAAAvB,CAAA,EAAAmB,CAAA,YAAAnB,CAAA;AAAA,SAAAwB,cAAA3B,CAAA,aAAAE,CAAA,MAAAA,CAAA,GAAA0B,SAAA,CAAAC,MAAA,EAAA3B,CAAA,UAAAC,CAAA,WAAAyB,SAAA,CAAA1B,CAAA,IAAA0B,SAAA,CAAA1B,CAAA,QAAAA,CAAA,OAAAiB,OAAA,CAAAR,MAAA,CAAAR,CAAA,OAAA2B,OAAA,WAAA5B,CAAA,QAAA6B,gBAAA,aAAA/B,CAAA,EAAAE,CAAA,EAAAC,CAAA,CAAAD,CAAA,SAAAS,MAAA,CAAAqB,yBAAA,GAAArB,MAAA,CAAAsB,gBAAA,CAAAjC,CAAA,EAAAW,MAAA,CAAAqB,yBAAA,CAAA7B,CAAA,KAAAgB,OAAA,CAAAR,MAAA,CAAAR,CAAA,GAAA2B,OAAA,WAAA5B,CAAA,IAAAS,MAAA,CAAAC,cAAA,CAAAZ,CAAA,EAAAE,CAAA,EAAAS,MAAA,CAAAE,wBAAA,CAAAV,CAAA,EAAAD,CAAA,iBAAAF,CAAA;AAMA;AACA;AACA;AACA;AACA,IAAMkC,aAAa,IAAApC,cAAA,WAAAiC,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,aAAAjC,cAAA,EAChBqC,oBAAW,CAACC,IAAI,EAAGxC,eAAe,CAACyC,kBAAkB,GACrDF,oBAAW,CAACG,iBAAiB,EAAG1C,eAAe,CAAC2C,sBAAsB,GACtEJ,oBAAW,CAACK,YAAY,EAAG5C,eAAe,CAAC6C,kBAAkB,GAC7DN,oBAAW,CAACO,oBAAoB,EAAG9C,eAAe,CAAC+C,yBAAyB,GAC5ER,oBAAW,CAACS,oBAAoB,EAAGhD,eAAe,CAACiD,yBAAyB,GAC5EV,oBAAW,CAACW,8BAA8B,EAAGlD,eAAe,CAACmD,iCAAiC,GAC9FZ,oBAAW,CAACa,iBAAiB,EAAGpD,eAAe,CAACqD,sBAAsB,GACtEd,oBAAW,CAACe,kBAAkB,EAAGtD,eAAe,CAACuD,uBAAuB,GACxEhB,oBAAW,CAACiB,0BAA0B,EAAGxD,eAAe,CAACyD,8BAA8B,GACvFlB,oBAAW,CAACmB,gBAAgB,EAAG1D,eAAe,CAAC2D,sBAAsB,OAAAxB,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,aAAAjC,cAAA,EACrEqC,oBAAW,CAACqB,mBAAmB,EAAG5D,eAAe,CAAC6D,yBAAyB,GAE3EtB,oBAAW,CAACuB,wBAAwB,EAAG9D,eAAe,CAAC+D,4BAA4B,GACnFxB,oBAAW,CAACyB,yBAAyB,EAAGhE,eAAe,CAACiE,4BAA4B,GACpF1B,oBAAW,CAAC2B,sBAAsB,EAAGlE,eAAe,CAACmE,0BAA0B,GAC/E5B,oBAAW,CAAC6B,oBAAoB,EAAGpE,eAAe,CAACqE,yBAAyB,GAC5E9B,oBAAW,CAAC+B,qBAAqB,EAAGtE,eAAe,CAACuE,0BAA0B,GAE9EhC,oBAAW,CAACiC,2BAA2B,EAAGxE,eAAe,CAACyE,+BAA+B,GACzFlC,oBAAW,CAACmC,oBAAoB,EAAG1E,eAAe,CAAC2E,wBAAwB,GAC3EpC,oBAAW,CAACqC,mBAAmB,EAAG5E,eAAe,CAAC6E,wBAAwB,GAC1EtC,oBAAW,CAACuC,eAAe,EAAG9E,eAAe,CAAC+E,oBAAoB,OAAA5C,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,iBAAAA,gBAAA,aAAAjC,cAAA,EAClEqC,oBAAW,CAACyC,4BAA4B,EAAGhF,eAAe,CAACiF,+BAA+B,GAE1F1C,oBAAW,CAAC2C,qBAAqB,EAAGlF,eAAe,CAACmF,yBAAyB,GAE7E5C,oBAAW,CAAC6C,wBAAwB,EAAGpF,eAAe,CAACqF,2BAA2B,GAClF9C,oBAAW,CAAC+C,UAAU,EAAGtF,eAAe,CAACuF,gBAAgB,GACzDhD,oBAAW,CAACiD,cAAc,EAAGxF,eAAe,CAACyF,mBAAmB,GAEhElD,oBAAW,CAACmD,gBAAgB,EAAG1F,eAAe,CAAC2F,qBAAqB,GACpEpD,oBAAW,CAACqD,kBAAkB,EAAG5F,eAAe,CAAC6F,uBAAuB,GACxEtD,oBAAW,CAACuD,UAAU,EAAG9F,eAAe,CAAC+F,gBAAgB,GACzDxD,oBAAW,CAACyD,sBAAsB,EAAGhG,eAAe,CAACiG,0BAA0B,EACjF;;AAED;AACO,IAAMC,qBAAqB,GAAAC,OAAA,CAAAD,qBAAA,GAAG,SAAxBA,qBAAqBA,CAAA;EAAA,IAAIE,YAAY,GAAApE,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAqE,SAAA,GAAArE,SAAA,MAAG,CAAC,CAAC;EAAA;IACrD;IACA,IAAAsE,2BAAa,EAAChE,aAAa,EAAAP,aAAA,CAAAA,aAAA,CAAAA,aAAA,KACtB/B,eAAe,CAACuG,gBAAgB,GAChCH,YAAY;MACf;MACAA,YAAY,EAAZA;IAAY,EACb;EAAC;AAAA;AAAC,IAAAI,QAAA,GAAAL,OAAA,cAEUD,qBAAqB,CAAC,CAAC","ignoreList":[]}

package/dist/vis-state-merger.d.ts

@@ -0,0 +1,143 @@
+import { Layer } from '@kepler.gl/layers';
+import { VisState, VisStateMergers, KeplerGLSchemaClass } from '@kepler.gl/schemas';
+import { ParsedLayer, ParsedVisState, SavedInteractionConfig, TooltipInfo, SavedEditor, ParsedConfig, Filter, Effect as EffectType, ParsedEffect, LayerColumns, LayerColumn } from '@kepler.gl/types';
+import { KeplerTable, Datasets } from '@kepler.gl/table';
+/**
+ * Merge loaded filters with current state, if no fields or data are loaded
+ * save it for later
+ *
+ */
+export declare function mergeFilters<S extends VisState>(state: S, filtersToMerge: NonNullable<ParsedConfig['visState']>['filters'], fromConfig?: boolean): S;
+export declare function replaceFilterDatasetIds(savedFilter: Filter[], dataId: string, dataIdToUse: string): Filter[] | null;
+export declare function isSavedLayerConfigV1(layerConfig: any): boolean;
+export declare function parseLayerConfig(schema: KeplerGLSchemaClass, layerConfig: any): ParsedLayer | undefined;
+export declare function createLayerFromConfig(state: VisState, layerConfig: any): Layer | null;
+/**
+ * Get loaded layer from state
+ */
+export declare function serializeLayer(newLayer: Layer, schema: KeplerGLSchemaClass): ParsedLayer | undefined;
+/**
+ * Get loaded effect from state
+ */
+export declare function serializeEffect(newEffect: EffectType, schema: KeplerGLSchemaClass): ParsedEffect | undefined;
+/**
+ * Get vis state config
+ */
+export declare function serializeVisState(visState: Partial<VisState>, schema: KeplerGLSchemaClass): ParsedVisState | undefined;
+/**
+ * Merge layers from de-serialized state, if no fields or data are loaded
+ * save it for later
+ *
+ */
+export declare function mergeLayers<S extends VisState>(state: S, layersToMerge?: NonNullable<ParsedConfig['visState']>['layers'], fromConfig?: boolean): S;
+export declare function insertLayerAtRightOrder(currentLayers: any, layersToInsert: any, currentOrder: any, preservedOrder?: string[]): {
+    newLayers: any;
+    newLayerOrder: any;
+};
+/**
+ * Merge interactions with saved config
+ *
+ */
+export declare function mergeInteractions<S extends VisState>(state: S, interactionToBeMerged: Partial<SavedInteractionConfig> | undefined): S;
+/**
+ * Merge splitMaps config with current visStete.
+ * 1. if current map is split, but splitMap DOESNOT contain maps
+ *    : don't merge anything
+ * 2. if current map is NOT split, but splitMaps contain maps
+ *    : add to splitMaps, and add current layers to splitMaps
+ */
+export declare function mergeSplitMaps<S extends VisState>(state: S, splitMaps?: NonNullable<ParsedConfig['visState']>['splitMaps']): S;
+/**
+ * Merge effects with saved config
+ */
+export declare function mergeEffects<S extends VisState>(state: S, effects: NonNullable<ParsedConfig['visState']>['effects'], fromConfig?: boolean): S;
+/**
+ * Merge interactionConfig.tooltip with saved config,
+ * validate fieldsToShow
+ *
+ * @param state
+ * @param tooltipConfig
+ * @return - {mergedTooltip: {}, unmergedTooltip: {}}
+ */
+export declare function mergeInteractionTooltipConfig(state: VisState, tooltipConfig?: Pick<TooltipInfo['config'], 'fieldsToShow'> | null): {
+    mergedTooltip: {
+        [key: string]: import("@kepler.gl/types").TooltipField[];
+    };
+    unmergedTooltip: {
+        [key: string]: import("@kepler.gl/types").TooltipField[];
+    };
+};
+/**
+ * Merge layerBlending with saved
+ *
+ */
+export declare function mergeLayerBlending<S extends VisState>(state: S, layerBlending: NonNullable<ParsedConfig['visState']>['layerBlending']): S;
+/**
+ * Merge overlayBlending with saved
+ */
+export declare function mergeOverlayBlending<S extends VisState>(state: S, overlayBlending: NonNullable<ParsedConfig['visState']>['overlayBlending']): S;
+/**
+ * Merge animation config
+ */
+export declare function mergeAnimationConfig<S extends VisState>(state: S, animation: NonNullable<ParsedConfig['visState']>['animationConfig']): S;
+/**
+ * Validate saved layer columns with new data,
+ * update fieldIdx based on new fields
+ *
+ * @param fields
+ * @param savedCols
+ * @param emptyCols
+ * @param options
+ * @return - validated columns or null
+ */
+export declare function validateSavedLayerColumns(fields: KeplerTable['fields'], savedCols: {
+    [key: string]: string;
+} | undefined, emptyCols: LayerColumns, options?: {
+    throwOnError?: boolean;
+}): LayerColumns | null;
+/**
+ * Validate layer column
+ */
+export declare function validateColumn(column: LayerColumn & {
+    validator?: typeof validateColumn;
+}, columns: LayerColumns, allFields: KeplerTable['fields']): boolean;
+/**
+ * Validate saved text label config with new data
+ * refer to vis-state-schema.js TextLabelSchemaV1
+ *
+ * @param {Array<Object>} fields
+ * @param {Object} savedTextLabel
+ * @param {Object} options
+ * @return {Object} - validated textlabel
+ */
+export declare function validateSavedTextLabel(fields: any, [layerTextLabel]: [any], savedTextLabel: any, options?: {
+    throwOnError?: boolean;
+}): {}[];
+/**
+ * Validate saved visual channels config with new data,
+ * refer to vis-state-schema.js VisualChannelSchemaV1
+ */
+export declare function validateSavedVisualChannels(fields: KeplerTable['fields'], newLayer: Layer, savedLayer: ParsedLayer, options?: {
+    throwOnError?: boolean;
+}): null | Layer;
+declare type ValidateLayerOption = {
+    allowEmptyColumn?: boolean;
+    throwOnError?: boolean;
+};
+export declare function validateLayersByDatasets(datasets: Datasets, layerClasses: VisState['layerClasses'], layers?: NonNullable<ParsedConfig['visState']>['layers'], options?: ValidateLayerOption): {
+    validated: Layer[];
+    failed: ParsedLayer[];
+};
+/**
+ * Validate saved layer config with new data,
+ * update fieldIdx based on new fields
+ */
+export declare function validateLayerWithData(dataset: KeplerTable, savedLayer: ParsedLayer, layerClasses: VisState['layerClasses'], options?: ValidateLayerOption): Layer | null;
+export declare function mergeEditor<S extends VisState>(state: S, savedEditor: SavedEditor): S;
+/**
+ * Validate saved layer config with new data,
+ * update fieldIdx based on new fields
+ */
+export declare function mergeDatasetsByOrder(state: VisState, newDataEntries: Datasets): Datasets;
+export declare const VIS_STATE_MERGERS: VisStateMergers<any>;
+export {};