@kepler.gl/reducers 3.0.0-alpha.0

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,68 @@
+// 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.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.uiStateReducerFactory = 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;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
+ * Important: Do not rename `actionHandler` or the assignment pattern of property value.
+ * It is used to generate documentation
+ */
+var actionHandler = (_actionHandler = {}, (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.INIT, uiStateUpdaters.initUiStateUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_SIDE_PANEL, uiStateUpdaters.toggleSidePanelUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_MODAL, uiStateUpdaters.toggleModalUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SHOW_EXPORT_DROPDOWN, uiStateUpdaters.showExportDropdownUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.HIDE_EXPORT_DROPDOWN, uiStateUpdaters.hideExportDropdownUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.OPEN_DELETE_MODAL, uiStateUpdaters.openDeleteModalUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_MAP_CONTROL, uiStateUpdaters.toggleMapControlUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_MAP_CONTROL_VISIBILITY, uiStateUpdaters.setMapControlVisibilityUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.ADD_NOTIFICATION, uiStateUpdaters.addNotificationUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.REMOVE_NOTIFICATION, uiStateUpdaters.removeNotificationUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_IMAGE_SETTING, uiStateUpdaters.setExportImageSettingUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_IMAGE_DATA_URI, uiStateUpdaters.setExportImageDataUriUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_IMAGE_ERROR, uiStateUpdaters.setExportImageErrorUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.CLEANUP_EXPORT_IMAGE, uiStateUpdaters.cleanupExportImageUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.START_EXPORTING_IMAGE, uiStateUpdaters.startExportingImageUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_SELECTED_DATASET, uiStateUpdaters.setExportSelectedDatasetUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_DATA_TYPE, uiStateUpdaters.setExportDataTypeUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_FILTERED, uiStateUpdaters.setExportFilteredUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_DATA, uiStateUpdaters.setExportDataUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_USER_MAPBOX_ACCESS_TOKEN, uiStateUpdaters.setUserMapboxAccessTokenUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_MAP_FORMAT, uiStateUpdaters.setExportMapFormatUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_EXPORT_MAP_HTML_MODE, uiStateUpdaters.setExportMapHTMLModeUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.LOAD_FILES, uiStateUpdaters.loadFilesUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.LOAD_FILES_ERR, uiStateUpdaters.loadFilesErrUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_SPLIT_MAP, uiStateUpdaters.toggleSplitMapUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SHOW_DATASET_TABLE, uiStateUpdaters.showDatasetTableUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.SET_LOCALE, uiStateUpdaters.setLocaleUpdater), (0, _defineProperty2["default"])(_actionHandler, _actions.ActionTypes.TOGGLE_LAYER_PANEL_LIST_VIEW, uiStateUpdaters.toggleLayerPanelListViewUpdater), _actionHandler);
+/* Reducer */
+
+var 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
+    }))
+  );
+};
+
+exports.uiStateReducerFactory = uiStateReducerFactory;
+
+var _default = uiStateReducerFactory();
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ui-state.ts"],"names":["actionHandler","ActionTypes","INIT","uiStateUpdaters","initUiStateUpdater","TOGGLE_SIDE_PANEL","toggleSidePanelUpdater","TOGGLE_MODAL","toggleModalUpdater","SHOW_EXPORT_DROPDOWN","showExportDropdownUpdater","HIDE_EXPORT_DROPDOWN","hideExportDropdownUpdater","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_LAYER_PANEL_LIST_VIEW","toggleLayerPanelListViewUpdater","uiStateReducerFactory","initialState","INITIAL_UI_STATE"],"mappings":";;;;;;;;;;;;;AAoBA;;AACA;;AACA;;;;;;;;AAEA;AACA;AACA;AACA;AACA,IAAMA,aAAa,0EAChBC,qBAAYC,IADI,EACGC,eAAe,CAACC,kBADnB,oDAEhBH,qBAAYI,iBAFI,EAEgBF,eAAe,CAACG,sBAFhC,oDAGhBL,qBAAYM,YAHI,EAGWJ,eAAe,CAACK,kBAH3B,oDAIhBP,qBAAYQ,oBAJI,EAImBN,eAAe,CAACO,yBAJnC,oDAKhBT,qBAAYU,oBALI,EAKmBR,eAAe,CAACS,yBALnC,oDAMhBX,qBAAYY,iBANI,EAMgBV,eAAe,CAACW,sBANhC,oDAOhBb,qBAAYc,kBAPI,EAOiBZ,eAAe,CAACa,uBAPjC,oDAQhBf,qBAAYgB,0BARI,EAQyBd,eAAe,CAACe,8BARzC,oDAShBjB,qBAAYkB,gBATI,EASehB,eAAe,CAACiB,sBAT/B,oDAUhBnB,qBAAYoB,mBAVI,EAUkBlB,eAAe,CAACmB,yBAVlC,oDAYhBrB,qBAAYsB,wBAZI,EAYuBpB,eAAe,CAACqB,4BAZvC,oDAahBvB,qBAAYwB,yBAbI,EAawBtB,eAAe,CAACuB,4BAbxC,oDAchBzB,qBAAY0B,sBAdI,EAcqBxB,eAAe,CAACyB,0BAdrC,oDAehB3B,qBAAY4B,oBAfI,EAemB1B,eAAe,CAAC2B,yBAfnC,oDAgBhB7B,qBAAY8B,qBAhBI,EAgBoB5B,eAAe,CAAC6B,0BAhBpC,oDAkBhB/B,qBAAYgC,2BAlBI,EAkB0B9B,eAAe,CAAC+B,+BAlB1C,oDAmBhBjC,qBAAYkC,oBAnBI,EAmBmBhC,eAAe,CAACiC,wBAnBnC,oDAoBhBnC,qBAAYoC,mBApBI,EAoBkBlC,eAAe,CAACmC,wBApBlC,oDAqBhBrC,qBAAYsC,eArBI,EAqBcpC,eAAe,CAACqC,oBArB9B,oDAsBhBvC,qBAAYwC,4BAtBI,EAsB2BtC,eAAe,CAACuC,+BAtB3C,oDAwBhBzC,qBAAY0C,qBAxBI,EAwBoBxC,eAAe,CAACyC,yBAxBpC,oDA0BhB3C,qBAAY4C,wBA1BI,EA0BuB1C,eAAe,CAAC2C,2BA1BvC,oDA2BhB7C,qBAAY8C,UA3BI,EA2BS5C,eAAe,CAAC6C,gBA3BzB,oDA4BhB/C,qBAAYgD,cA5BI,EA4Ba9C,eAAe,CAAC+C,mBA5B7B,oDA8BhBjD,qBAAYkD,gBA9BI,EA8BehD,eAAe,CAACiD,qBA9B/B,oDA+BhBnD,qBAAYoD,kBA/BI,EA+BiBlD,eAAe,CAACmD,uBA/BjC,oDAgChBrD,qBAAYsD,UAhCI,EAgCSpD,eAAe,CAACqD,gBAhCzB,oDAiChBvD,qBAAYwD,4BAjCI,EAiC2BtD,eAAe,CAACuD,+BAjC3C,kBAAnB;AAoCA;;AACO,IAAMC,qBAAqB,GAAG,SAAxBA,qBAAwB;AAAA,MAACC,YAAD,uEAAgB,EAAhB;AAAA,SACnC;AACA,qCAAc5D,aAAd,gDACKG,eAAe,CAAC0D,gBADrB,GAEKD,YAFL;AAGE;AACAA,MAAAA,YAAY,EAAZA;AAJF;AAFmC;AAAA,CAA9B;;;;eASQD,qBAAqB,E","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 {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.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_LAYER_PANEL_LIST_VIEW]: uiStateUpdaters.toggleLayerPanelListViewUpdater\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"]}

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

@@ -0,0 +1,102 @@
+import { LayerColumns, LayerColumn, Layer } from '@kepler.gl/layers';
+import { Merger, VisState, VisStateMergers, ParsedConfig } from '@kepler.gl/schemas';
+import { ParsedLayer, SavedInteractionConfig, TooltipInfo } 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 createLayerFromConfig(state: VisState, layerConfig: any): Layer | null;
+export declare function serializeLayer(newLayer: any): ParsedLayer;
+/**
+ * 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[]): {
+    newLayerOrder: any;
+    newLayers: any;
+};
+/**
+ * Merge interactions with saved config
+ *
+ */
+export declare function mergeInteractions<S extends VisState>(state: S, interactionToBeMerged: Partial<SavedInteractionConfig> | undefined, fromConfig?: boolean): 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'], 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'], fromConfig?: boolean): S;
+/**
+ * Merge animation config
+ */
+export declare function mergeAnimationConfig<S extends VisState>(state: S, animation: NonNullable<ParsedConfig['visState']>['animationConfig'], fromConfig?: boolean): S;
+/**
+ * Validate saved layer columns with new data,
+ * update fieldIdx based on new fields
+ *
+ * @param fields
+ * @param savedCols
+ * @param emptyCols
+ * @return - validated columns or null
+ */
+export declare function validateSavedLayerColumns(fields: KeplerTable['fields'], savedCols: {
+    [key: string]: string;
+} | undefined, emptyCols: LayerColumns): LayerColumns | null;
+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
+ * @return {Object} - validated textlabel
+ */
+export declare function validateSavedTextLabel(fields: any, [layerTextLabel]: [any], savedTextLabel: any): {}[];
+/**
+ * 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): null | Layer;
+export declare function validateLayersByDatasets(datasets: Datasets, layerClasses: VisState['layerClasses'], layers?: NonNullable<ParsedConfig['visState']>['layers']): {
+    validated: Layer[];
+    failed: ParsedLayer[];
+};
+/**
+ * Validate saved layer config with new data,
+ * update fieldIdx based on new fields
+ */
+export declare function validateLayerWithData({ fields, id: dataId }: KeplerTable, savedLayer: ParsedLayer, layerClasses: VisState['layerClasses'], options?: {
+    allowEmptyColumn?: boolean;
+}): Layer | null;
+export declare function isValidMerger(merger: Merger): boolean;
+export declare const VIS_STATE_MERGERS: VisStateMergers;