@kepler.gl/components 3.3.0-alpha.0 → 3.3.0-alpha.10

package/dist/map/map-control.d.ts

@@ -1,27 +1,34 @@
 import React from 'react';
 import SplitMapButtonFactory from './split-map-button';
 import Toggle3dButtonFactory from './toggle-3d-button';
-import LayerSelectorPanelFactory from './layer-selector-panel';
 import MapLegendPanelFactory from './map-legend-panel';
 import MapDrawPanelFactory from './map-draw-panel';
 import LocalePanelFactory from './locale-panel';
+import ThemeToggleButtonFactory from './theme-toggle-button';
+import MapNavigationControlFactory from './map-navigation-control';
 import { Layer } from '@kepler.gl/layers';
-import { Editor, LayerVisConfig, MapControls, MapState } from '@kepler.gl/types';
+import { Editor, LayerVisConfig, LayerOrder, MapControls, MapState } from '@kepler.gl/types';
 import { Datasets } from '@kepler.gl/table';
 import { MapStateActions, UIStateActions } from '@kepler.gl/actions';
+import { MapViewMode } from '@kepler.gl/constants';
+import AnnotationControlFactory from './annotations/annotation-control';
 export type MapControlProps = {
     datasets: Datasets;
     dragRotate: boolean;
     isSplit: boolean;
     primary: boolean;
     layers: Layer[];
+    layerOrder?: LayerOrder;
     layersToRender: {
         [key: string]: boolean;
     };
     mapIndex: number;
     mapControls: MapControls;
     onTogglePerspective: () => void;
+    onSetMapViewMode?: (mode: MapViewMode) => void;
+    mapViewMode?: MapViewMode;
     onToggleSplitMap: typeof MapStateActions.toggleSplitMap;
+    onSetMapSplitMode?: typeof MapStateActions.setMapSplitMode;
     onToggleSplitMapViewport: ({ isViewportSynced, isZoomLocked }: {
         isViewportSynced: boolean;
         isZoomLocked: boolean;
@@ -30,17 +37,21 @@ export type MapControlProps = {
     onToggleMapControl: (control: string) => void;
     onSetEditorMode: (mode: string) => void;
     onToggleEditorVisibility: () => void;
+    onConvertEditorFeaturesToLayer?: () => void;
     onLayerVisConfigChange: (oldLayer: Layer, newVisConfig: Partial<LayerVisConfig>) => void;
     onToggleLayerVisibility?: (layer: Layer) => void;
     top: number;
     onSetLocale: typeof UIStateActions.setLocale;
+    onSetTheme: typeof UIStateActions.setTheme;
     availableLocales: string[];
     locale: string;
+    themeName?: string;
     logoComponent?: React.FC | React.ReactNode;
     isExport?: boolean;
     setMapControlSettings: typeof UIStateActions.setMapControlSettings;
     activeSidePanel: string | null;
     mapState?: MapState;
+    mapStateActions?: typeof MapStateActions;
     readOnly?: boolean;
     scale?: number;
     mapLayers?: {
@@ -49,11 +60,17 @@ export type MapControlProps = {
     editor: Editor;
     actionComponents?: React.ComponentType<any>[];
     mapHeight?: number;
+    splitMaps?: {
+        layers: {
+            [key: string]: boolean;
+        };
+    }[];
+    onToggleLayerForMap?: (mapIndex: number, layerId: string) => void;
 };
-declare function MapControlFactory(SplitMapButton: ReturnType<typeof SplitMapButtonFactory>, Toggle3dButton: ReturnType<typeof Toggle3dButtonFactory>, LayerSelectorPanel: ReturnType<typeof LayerSelectorPanelFactory>, MapLegendPanel: ReturnType<typeof MapLegendPanelFactory>, MapDrawPanel: ReturnType<typeof MapDrawPanelFactory>, LocalePanel: ReturnType<typeof LocalePanelFactory>): React.FC<MapControlProps> & {
+declare function MapControlFactory(SplitMapButton: ReturnType<typeof SplitMapButtonFactory>, Toggle3dButton: ReturnType<typeof Toggle3dButtonFactory>, MapLegendPanel: ReturnType<typeof MapLegendPanelFactory>, MapDrawPanel: ReturnType<typeof MapDrawPanelFactory>, LocalePanel: ReturnType<typeof LocalePanelFactory>, ThemeToggleButton: ReturnType<typeof ThemeToggleButtonFactory>, AnnotationControl: ReturnType<typeof AnnotationControlFactory>, MapNavigationControl: ReturnType<typeof MapNavigationControlFactory>): React.FC<MapControlProps> & {
     defaultActionComponents: MapControlProps["actionComponents"];
 };
 declare namespace MapControlFactory {
-    var deps: (typeof LocalePanelFactory | typeof SplitMapButtonFactory | typeof Toggle3dButtonFactory | typeof LayerSelectorPanelFactory | typeof MapLegendPanelFactory | typeof MapDrawPanelFactory)[];
+    var deps: (typeof MapNavigationControlFactory | typeof SplitMapButtonFactory | typeof Toggle3dButtonFactory | typeof MapLegendPanelFactory | typeof MapDrawPanelFactory | typeof LocalePanelFactory | typeof ThemeToggleButtonFactory | typeof AnnotationControlFactory)[];
 }
 export default MapControlFactory;

package/dist/map/map-draw-panel.d.ts

@@ -9,6 +9,7 @@ export type MapDrawPanelProps = {
     onToggleMapControl: (control: string) => void;
     onSetEditorMode: (mode: string) => void;
     onToggleEditorVisibility: () => void;
+    onConvertEditorFeaturesToLayer?: () => void;
     actionIcons: {
         [id: string]: React.ComponentType<Partial<BaseProps>>;
     };

package/dist/map/map-legend-panel.d.ts

@@ -1,7 +1,7 @@
 import React, { ComponentType } from 'react';
 import { ActionHandler, toggleSplitMapViewport } from '@kepler.gl/actions';
 import { Layer } from '@kepler.gl/layers';
-import { LayerVisConfig, MapControls, MapState } from '@kepler.gl/types';
+import { LayerVisConfig, LayerOrder, MapControls, MapState } from '@kepler.gl/types';
 import { MapLegendControlSettings } from '@kepler.gl/types';
 import MapControlPanelFactory from './map-control-panel';
 import MapControlTooltipFactory from './map-control-tooltip';
@@ -17,6 +17,7 @@ interface MapLegendPanelIcons {
 export type MapLegendPanelProps = {
     theme: any;
     layers: ReadonlyArray<Layer>;
+    layerOrder?: LayerOrder;
     scale: number;
     onToggleMapControl: (control: string) => void;
     isExport: boolean;
@@ -34,10 +35,18 @@ export type MapLegendPanelProps = {
     isSidePanelShown: boolean;
     activeSidePanel: string | null;
     setMapControlSettings: any;
+    isSplit?: boolean;
+    splitMaps?: {
+        layers: {
+            [key: string]: boolean;
+        };
+    }[];
+    onToggleLayerForMap?: (mapIndex: number, layerId: string) => void;
+    mapIndex?: number;
 };
 type MapLegendPanelComponentType = React.FC<MapLegendPanelProps>;
 declare function MapLegendPanelFactory(MapControlTooltip: ReturnType<typeof MapControlTooltipFactory>, MapControlPanel: ReturnType<typeof MapControlPanelFactory>, MapLegend: ReturnType<typeof MapLegendFactory>): MapLegendPanelComponentType;
 declare namespace MapLegendPanelFactory {
-    var deps: (typeof MapControlTooltipFactory | typeof MapControlPanelFactory | typeof MapLegendFactory)[];
+    var deps: (typeof MapControlTooltipFactory | typeof MapLegendFactory | typeof MapControlPanelFactory)[];
 }
 export default MapLegendPanelFactory;

package/dist/map/map-legend.d.ts

@@ -1,13 +1,13 @@
 import React, { FC, ComponentType } from 'react';
 import ColorLegendFactory, { LegendRowFactory } from '../common/color-legend';
 import { Layer, LayerBaseConfig, VisualChannel, VisualChannelDescription } from '@kepler.gl/layers';
-import { LayerVisConfig, MapState, RGBColor } from '@kepler.gl/types';
+import { LayerVisConfig, LayerOrder, MapState, RGBColor } from '@kepler.gl/types';
 import PanelHeaderActionFactory from '../side-panel/panel-header-action';
 interface StyledMapControlLegendProps {
     width?: number;
-    last?: boolean;
+    $last?: boolean;
 }
-export declare const StyledMapControlLegend: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, StyledMapControlLegendProps>>;
+export declare const StyledMapControlLegend: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof StyledMapControlLegendProps> & StyledMapControlLegendProps, never> & Partial<Pick<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof StyledMapControlLegendProps> & StyledMapControlLegendProps, never>>> & string;
 export declare const VisualChannelMetric: ({ name }: {
     name: any;
 }) => React.JSX.Element;
@@ -58,6 +58,15 @@ export type LayerLegendHeaderProps = {
     };
     isExport?: boolean;
     onToggleLayerVisibility?: (layer: Layer) => void;
+    isSplit?: boolean;
+    splitMaps?: {
+        layers: {
+            [key: string]: boolean;
+        };
+    }[];
+    onMapToggleLayer?: (mapIndex: number, layerId: string) => void;
+    isExpanded?: boolean;
+    onToggleExpanded?: () => void;
 };
 export declare function LayerLegendHeaderFactory(): React.FC<LayerLegendHeaderProps>;
 export type LayerLegendContentProps = {
@@ -75,6 +84,7 @@ export declare namespace LayerLegendContentFactory {
 }
 export type MapLegendProps = {
     layers?: ReadonlyArray<Layer>;
+    layerOrder?: LayerOrder;
     width?: number;
     mapState?: MapState;
     options?: {
@@ -84,6 +94,13 @@ export type MapLegendProps = {
     isExport?: boolean;
     onLayerVisConfigChange?: (oldLayer: Layer, newVisConfig: Partial<LayerVisConfig>) => void;
     onToggleLayerVisibility?: (layer: Layer) => void;
+    onMapToggleLayer?: (mapIndex: number, layerId: string) => void;
+    isSplit?: boolean;
+    splitMaps?: {
+        layers: {
+            [key: string]: boolean;
+        };
+    }[];
     actionIcons?: MapLegendIcons;
 };
 declare function MapLegendFactory(LayerLegendHeader: ReturnType<typeof LayerLegendHeaderFactory>, LayerLegendContent: ReturnType<typeof LayerLegendContentFactory>): React.FC<MapLegendProps>;

package/dist/map/map-navigation-control.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { MapState } from '@kepler.gl/types';
+import { MapStateActions } from '@kepler.gl/actions';
+export type MapNavigationControlProps = {
+    mapState: MapState;
+    mapIndex: number;
+    mapStateActions: typeof MapStateActions;
+};
+declare function MapNavigationControlFactory(): React.NamedExoticComponent<MapNavigationControlProps>;
+declare namespace MapNavigationControlFactory {
+    var deps: any[];
+}
+export default MapNavigationControlFactory;

package/dist/map/map-scale.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { MapState } from '@kepler.gl/types';
+export type MapScaleProps = {
+    mapState: MapState;
+    mapIndex?: number;
+};
+declare function MapScaleFactory(): React.NamedExoticComponent<MapScaleProps>;
+declare namespace MapScaleFactory {
+    var deps: any[];
+}
+export default MapScaleFactory;

package/dist/map/split-map-button.d.ts

@@ -1,6 +1,8 @@
 import React, { ComponentType } from 'react';
 import MapControlTooltipFactory from './map-control-tooltip';
-import { MapControls } from '@kepler.gl/types';
+import MapControlToolbarFactory from './map-control-toolbar';
+import { MapControls, MapState } from '@kepler.gl/types';
+import { MapSplitMode } from '@kepler.gl/constants';
 interface SplitMapButtonIcons {
     delete: ComponentType<any>;
     split: ComponentType<any>;
@@ -9,12 +11,17 @@ export type SplitMapButtonProps = {
     isSplit: boolean;
     mapIndex: number;
     onToggleSplitMap: (index?: number) => void;
+    onSetMapSplitMode?: (payload: {
+        mapSplitMode: MapSplitMode;
+    }) => void;
+    onToggleMapControl?: (control: string) => void;
     actionIcons: SplitMapButtonIcons;
     readOnly: boolean;
     mapControls: MapControls;
+    mapState?: MapState;
 };
-declare function SplitMapButtonFactory(MapControlTooltip: any): React.NamedExoticComponent<SplitMapButtonProps>;
+declare function SplitMapButtonFactory(MapControlTooltip: ReturnType<typeof MapControlTooltipFactory>, MapControlToolbar: ReturnType<typeof MapControlToolbarFactory>): React.NamedExoticComponent<SplitMapButtonProps>;
 declare namespace SplitMapButtonFactory {
-    var deps: (typeof MapControlTooltipFactory)[];
+    var deps: (typeof MapControlToolbarFactory | typeof MapControlTooltipFactory)[];
 }
 export default SplitMapButtonFactory;

package/dist/map/theme-toggle-button.d.ts

@@ -0,0 +1,18 @@
+import React, { ComponentType } from 'react';
+import { MapControls } from '@kepler.gl/types';
+import MapControlTooltipFactory from './map-control-tooltip';
+interface ThemeToggleButtonIcons {
+    sun: ComponentType<any>;
+    moon: ComponentType<any>;
+}
+export type ThemeToggleButtonProps = {
+    themeName?: string;
+    onSetTheme: (theme: string) => void;
+    mapControls: MapControls;
+    actionIcons?: ThemeToggleButtonIcons;
+};
+declare function ThemeToggleButtonFactory(MapControlTooltip: ReturnType<typeof MapControlTooltipFactory>): React.NamedExoticComponent<ThemeToggleButtonProps>;
+declare namespace ThemeToggleButtonFactory {
+    var deps: (typeof MapControlTooltipFactory)[];
+}
+export default ThemeToggleButtonFactory;

package/dist/map/toggle-3d-button.d.ts

@@ -1,17 +1,23 @@
 import React, { ComponentType } from 'react';
 import MapControlTooltipFactory from './map-control-tooltip';
+import MapControlToolbarFactory from './map-control-toolbar';
 import { MapControls } from '@kepler.gl/types';
+import { MapViewMode } from '@kepler.gl/constants';
 interface Toggle3dButtonIcons {
     cube: ComponentType<any>;
+    globe: ComponentType<any>;
 }
 export type Toggle3dButtonProps = {
     dragRotate: boolean;
+    mapViewMode?: MapViewMode;
     onTogglePerspective: () => void;
+    onSetMapViewMode?: (mode: MapViewMode) => void;
+    onToggleMapControl: (control: string) => void;
     actionIcons: Toggle3dButtonIcons;
     mapControls: MapControls;
 };
-declare function Toggle3dButtonFactory(MapControlTooltip: any): React.NamedExoticComponent<Toggle3dButtonProps>;
+declare function Toggle3dButtonFactory(MapControlTooltip: ReturnType<typeof MapControlTooltipFactory>, MapControlToolbar: ReturnType<typeof MapControlToolbarFactory>): React.NamedExoticComponent<Toggle3dButtonProps>;
 declare namespace Toggle3dButtonFactory {
-    var deps: (typeof MapControlTooltipFactory)[];
+    var deps: (typeof MapControlToolbarFactory | typeof MapControlTooltipFactory)[];
 }
 export default Toggle3dButtonFactory;

package/dist/map-container.d.ts

@@ -1,25 +1,22 @@
 import React from 'react';
-import { Map, MapRef } from 'react-map-gl';
+import { Map as MapboxLegacyMap, MapRef } from 'react-map-gl/mapbox-legacy';
+import { Map as MaplibreMap } from '@vis.gl/react-maplibre';
 import { VisStateActions, MapStateActions, UIStateActions } from '@kepler.gl/actions';
 import MapPopoverFactory from './map/map-popover';
 import MapControlFactory from './map/map-control';
+import MapScaleFactory from './map/map-scale';
+import { Attribution, AttributionLogos, renderBasemapAttribution, dedupeBasemapAttributions } from './map/attribution';
 import EditorFactory from './editor/editor';
 import { generateMapboxLayers } from '@kepler.gl/layers';
-import { DatasetAttribution, MapState, MapControls, Viewport } from '@kepler.gl/types';
-import { BaseMapLibraryConfig, GetMapRef } from '@kepler.gl/utils';
+import { AttributionWithStyle, DatasetAttribution, MapState, MapControls, Viewport } from '@kepler.gl/types';
+import { GetMapRef } from '@kepler.gl/utils';
 import { MapStyle, computeDeckLayers } from '@kepler.gl/reducers';
 import { VisState } from '@kepler.gl/schemas';
 export declare const isSplitSelector: (props: any) => any;
 export declare const Droppable: ({ containerId }: {
     containerId: any;
 }) => React.JSX.Element;
-type AttributionProps = {
-    showBaseMapLibLogo: boolean;
-    showOsmBasemapAttribution: boolean;
-    datasetAttributions: DatasetAttribution[];
-    baseMapLibraryConfig: BaseMapLibraryConfig;
-};
-export declare const Attribution: React.FC<AttributionProps>;
+export { Attribution, AttributionLogos, renderBasemapAttribution, dedupeBasemapAttributions };
 type MapboxStyle = string | object | undefined;
 export interface MapContainerProps {
     visState: VisState;
@@ -47,9 +44,10 @@ export interface MapContainerProps {
     activeSidePanel: string | null;
     sidePanelWidth?: number;
     locale?: any;
+    uiTheme?: string;
     theme?: any;
     editor?: any;
-    MapComponent?: typeof Map;
+    MapComponent?: typeof MapboxLegacyMap | typeof MaplibreMap;
     deckGlProps?: any;
     onDeckInitialized?: (a: any, b: any) => void;
     onViewStateChange?: (viewport: Viewport) => void;
@@ -58,7 +56,10 @@ export interface MapContainerProps {
     transformRequest?: (url: string, resourceType?: string) => {
         url: string;
     };
+    /** Pass `false` to disable the remote RTL text plugin, or a URL string to self-host it. */
+    RTLTextPlugin?: string | false;
     datasetAttributions?: DatasetAttribution[];
+    attributionLogos?: AttributionWithStyle[];
     generateMapboxLayers?: typeof generateMapboxLayers;
     generateDeckGLLayers?: typeof computeDeckLayers;
     onMouseMove?: (event: React.MouseEvent & {
@@ -72,8 +73,8 @@ export interface MapContainerProps {
     };
     logoComponent?: React.FC | React.ReactNode;
 }
-declare function MapContainerFactory(MapPopover: ReturnType<typeof MapPopoverFactory>, MapControl: ReturnType<typeof MapControlFactory>, Editor: ReturnType<typeof EditorFactory>): React.ComponentType<MapContainerProps>;
+declare function MapContainerFactory(MapPopover: ReturnType<typeof MapPopoverFactory>, MapControl: ReturnType<typeof MapControlFactory>, Editor: ReturnType<typeof EditorFactory>, MapScale: ReturnType<typeof MapScaleFactory>): React.ComponentType<MapContainerProps>;
 declare namespace MapContainerFactory {
-    var deps: (typeof EditorFactory | typeof MapPopoverFactory | typeof MapControlFactory)[];
+    var deps: (typeof MapScaleFactory | typeof MapPopoverFactory | typeof MapControlFactory | typeof EditorFactory)[];
 }
 export default MapContainerFactory;

package/dist/map-view-state-context.d.ts

@@ -5,6 +5,9 @@ type MapViewState = {
     zoom: number;
     bearing?: number;
     pitch?: number;
+    maxPitch?: number;
+    minZoom?: number;
+    maxZoom?: number;
 };
 import { MapState } from '@kepler.gl/types';
 export type MapViewStateContextType = {

package/dist/maps-layout.d.ts

@@ -4,6 +4,9 @@ interface MapsLayoutProps {
     mapState: MapState;
     className?: string;
     children?: React.ReactNode;
+    onSetSwipeComparePercentage?: (payload: {
+        percentage: number;
+    }) => void;
 }
 declare function MapsLayoutFactory(): React.ComponentType<MapsLayoutProps>;
 declare namespace MapsLayoutFactory {

package/dist/modal-container.d.ts

@@ -8,6 +8,7 @@ import LoadDataModalFactory from './modals/load-data-modal';
 import ExportImageModalFactory from './modals/export-image-modal';
 import ExportDataModalFactory from './modals/export-data-modal';
 import ExportMapModalFactory from './modals/export-map-modal/export-map-modal';
+import ExportVideoModalFactory from './modals/export-video-modal';
 import AddMapStyleModalFactory from './modals/add-map-style-modal';
 import SaveMapModalFactory from './modals/save-map-modal';
 import ShareMapModalFactory from './modals/share-map-modal';
@@ -38,7 +39,7 @@ export type ModalContainerProps = {
     onExportToCloudSuccess?: OnSuccessCallBack;
     onExportToCloudError?: OnErrorCallBack;
 };
-declare function ModalContainerFactory(DeleteDatasetModal: ReturnType<typeof DeleteDatasetModalFactory>, OverWriteMapModal: ReturnType<typeof OverWriteMapModalFactory>, DataTableModal: ReturnType<typeof DataTableModalFactory>, LoadDataModal: ReturnType<typeof LoadDataModalFactory>, ExportImageModal: ReturnType<typeof ExportImageModalFactory>, ExportDataModal: ReturnType<typeof ExportDataModalFactory>, ExportMapModal: ReturnType<typeof ExportMapModalFactory>, AddMapStyleModal: ReturnType<typeof AddMapStyleModalFactory>, ModalDialog: ReturnType<typeof ModalDialogFactory>, SaveMapModal: ReturnType<typeof SaveMapModalFactory>, ShareMapModal: ReturnType<typeof ShareMapModalFactory>): React.ElementType<ModalContainerProps>;
+declare function ModalContainerFactory(DeleteDatasetModal: ReturnType<typeof DeleteDatasetModalFactory>, OverWriteMapModal: ReturnType<typeof OverWriteMapModalFactory>, DataTableModal: ReturnType<typeof DataTableModalFactory>, LoadDataModal: ReturnType<typeof LoadDataModalFactory>, ExportImageModal: ReturnType<typeof ExportImageModalFactory>, ExportDataModal: ReturnType<typeof ExportDataModalFactory>, ExportMapModal: ReturnType<typeof ExportMapModalFactory>, ExportVideoModal: ReturnType<typeof ExportVideoModalFactory>, AddMapStyleModal: ReturnType<typeof AddMapStyleModalFactory>, ModalDialog: ReturnType<typeof ModalDialogFactory>, SaveMapModal: ReturnType<typeof SaveMapModalFactory>, ShareMapModal: ReturnType<typeof ShareMapModalFactory>): React.ElementType<ModalContainerProps>;
 declare namespace ModalContainerFactory {
     var deps: (typeof ShareMapModalFactory | (() => React.FC<import("./modals/delete-data-modal").DeleteDatasetModalProps>) | (() => React.FC<{
         mapSaved: string | null;
@@ -52,6 +53,6 @@ declare namespace ModalContainerFactory {
         WrappedComponent: React.ComponentType<import("./modals/export-image-modal").ExportImageModalProps>;
     }) | (() => React.FC<import("react-intl").WithIntlProps<import("./modals/export-data-modal").ExportDataModalProps>> & {
         WrappedComponent: React.ComponentType<import("./modals/export-data-modal").ExportDataModalProps>;
-    }) | typeof ExportMapModalFactory | typeof AddMapStyleModalFactory | (() => import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<import("./common/modal").ModalDialogOwnProps & Omit<import("react-modal").Props, "className" | "style" | "ariaHideApp"> & React.RefAttributes<import("./common/modal").ModalDialog>, never>> & Omit<typeof import("./common/modal").ModalDialog, keyof React.Component<any, {}, any>>) | typeof SaveMapModalFactory)[];
+    }) | typeof ExportMapModalFactory | (() => React.FC<import("./modals/export-video-modal").ExportVideoModalProps>) | typeof AddMapStyleModalFactory | (() => import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("./common/modal").ModalDialogOwnProps & Omit<import("react-modal").Props, "className" | "style" | "ariaHideApp"> & React.RefAttributes<import("./common/modal").ModalDialog>, never> & Partial<Pick<import("./common/modal").ModalDialogOwnProps & Omit<import("react-modal").Props, "className" | "style" | "ariaHideApp"> & React.RefAttributes<import("./common/modal").ModalDialog>, never>>> & string & Omit<typeof import("./common/modal").ModalDialog, keyof React.Component<any, {}, any>>) | typeof SaveMapModalFactory)[];
 }
 export default ModalContainerFactory;

package/dist/modals/cloud-components/cloud-item.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
-export declare const CloudItem: ({ vis, onClick }: {
+export declare const CloudItem: ({ vis, onClick, provider }: {
     vis: any;
     onClick: any;
+    provider: any;
 }) => React.JSX.Element;

package/dist/modals/cloud-components/cloud-storage-disclaimer.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const CloudStorageDisclaimer: React.FC;

package/dist/modals/cloud-tile.d.ts

@@ -1,11 +1,10 @@
 import React from 'react';
-import { IStyledComponent } from 'styled-components';
 import { Provider } from '@kepler.gl/cloud-providers';
 import { BaseComponentProps } from '../types';
 export type StyledTileWrapperProps = BaseComponentProps & {
     selected?: boolean;
 };
-export declare const StyledWarning: IStyledComponent<"web", import("styled-components/dist/types").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>;
+export declare const StyledWarning: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;
 interface CloudTileProps {
     actionName?: string | null;
     provider: Provider;

package/dist/modals/data-table-modal.d.ts

@@ -7,7 +7,7 @@ import { UiState } from '@kepler.gl/types';
 import DataTableConfigFactory from '../common/data-table/display-format';
 import { BaseComponentProps } from '../types';
 export type DatasetModalTabProps = BaseComponentProps & {
-    active?: boolean;
+    $active?: boolean;
 };
 export declare const DatasetModalTab: IStyledComponent<'web', DatasetModalTabProps>;
 interface DatasetTabsUnmemoizedProps {
@@ -31,6 +31,7 @@ interface DataTableModalProps {
     }) => void;
     uiStateActions: typeof UIStateActions;
     uiState: UiState;
+    loadColumnStats?: (dataId: string, fieldName: string | string[]) => void;
 }
 declare function DataTableModalFactory(DataTable: ReturnType<typeof DataTableFactory>, DataTableConfig: ReturnType<typeof DataTableConfigFactory>): React.ComponentType<Omit<DataTableModalProps, 'theme'>>;
 declare namespace DataTableModalFactory {

package/dist/modals/export-map-modal/components.d.ts

@@ -1,9 +1,27 @@
 import React from 'react';
-export declare const StyledExportMapSection: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<Omit<import("styled-components/dist/types").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "disabled"> & import("../../common/styled-components").StyledExportSectionProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<HTMLDivElement> | null | undefined;
-}, never>> & Omit<import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("../../common/styled-components").StyledExportSectionProps>>, keyof React.Component<any, {}, any>>;
-export declare const StyledWarning: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>;
-export declare const StyledExportLink: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, never>>;
+export declare const StyledExportMapModalContent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>, "as" | "forwardedAs"> & {
+    as?: import("styled-components").WebTarget | undefined;
+    forwardedAs?: import("styled-components").WebTarget | undefined;
+}, never> & Partial<Pick<import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>, "as" | "forwardedAs"> & {
+    as?: import("styled-components").WebTarget | undefined;
+    forwardedAs?: import("styled-components").WebTarget | undefined;
+}, never>>> & string;
+export declare const StyledExportMapSection: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "disabled"> & import("../../common/styled-components").StyledExportSectionProps, never> & Partial<Pick<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "disabled"> & import("../../common/styled-components").StyledExportSectionProps, never>>, "as" | "forwardedAs"> & {
+    as?: import("styled-components").WebTarget | undefined;
+    forwardedAs?: import("styled-components").WebTarget | undefined;
+}, never> & Partial<Pick<import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "disabled"> & import("../../common/styled-components").StyledExportSectionProps, never> & Partial<Pick<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "disabled"> & import("../../common/styled-components").StyledExportSectionProps, never>>, "as" | "forwardedAs"> & {
+    as?: import("styled-components").WebTarget | undefined;
+    forwardedAs?: import("styled-components").WebTarget | undefined;
+}, never>>> & string;
+export declare const StyledExportMapNote: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never>>> & string;
+export declare const StyledExportMapFormatPanels: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+export declare const StyledExportMapFormatPanel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$active"> & {
+    $active: boolean;
+}, never> & Partial<Pick<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$active"> & {
+    $active: boolean;
+}, never>>> & string;
+export declare const StyledWarning: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;
+export declare const StyledExportLink: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, never>>> & string;
 export declare const ExportMapLink: ({ children, ...props }: {
     [x: string]: any;
     children: any;

package/dist/modals/export-video-modal.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { ExportVideo } from '@kepler.gl/types';
+import { MapStyle } from '@kepler.gl/reducers';
+import { UIStateActions, VisStateActions } from '@kepler.gl/actions';
+export type VideoConfiguration = {
+    mediaType?: string;
+    cameraPreset?: string;
+    fileName?: string;
+    resolution?: string;
+    durationMs?: number;
+    swipeStartPct?: number;
+    swipeEndPct?: number;
+    swipeEasing?: 'linear' | 'ease-in-out';
+};
+export interface ExportVideoModalProps {
+    mapboxApiAccessToken: string;
+    mapboxApiUrl?: string;
+    mapState: any;
+    mapStyle: MapStyle;
+    visState: any;
+    exportVideo: ExportVideo;
+    containerW: number;
+    visStateActions: typeof VisStateActions;
+    uiStateActions: typeof UIStateActions;
+    onClose: () => void;
+}
+declare const ExportVideoModalFactory: () => React.FC<ExportVideoModalProps>;
+export default ExportVideoModalFactory;

package/dist/modals/export-video-modal.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modals/fog-height-animation.d.ts

@@ -0,0 +1,8 @@
+import { Effect } from '@kepler.gl/types';
+/**
+ * Drives the surface fog elevation animation during Hubble video export.
+ *
+ * Patches DeckSurfaceFogEffect.postRender to interpolate height per-frame
+ * using the Hubble adapter's videoCapture.timeMs for precise sync.
+ */
+export declare function useFogHeightAnimation(videoEffects: Effect[], hubbleContainerRef: React.RefObject<any>): void;