@carto/kepler.gl 0.0.80 → 0.1.0-alpha.0

package/dist/components/side-panel/layer-panel/text-label-panel.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import LayerConfigGroupFactory from './layer-config-group';
+import RangeSliderFactory from 'components/common/range-slider';
+import { LayerTextLabel } from 'layers/layer-factory';
+import FieldSelectorFactory from '../../common/field-selector';
+import { Field } from 'utils/table-utils/kepler-table';
+import ColorSelectorFactory from './color-selector';
+type TextLabelPanelProps = {
+    fields: Field[];
+    textLabel: LayerTextLabel[];
+    updateLayerTextLabel: (idx: number | 'all', prop: string, value: any) => void;
+    AddButton?: React.ReactNode;
+};
+declare function TextLabelPanelFactory(RangeSlider: ReturnType<typeof RangeSliderFactory>, LayerConfigGroup: ReturnType<typeof LayerConfigGroupFactory>, FieldSelector: ReturnType<typeof FieldSelectorFactory>, ColorSelector: ReturnType<typeof ColorSelectorFactory>): React.ComponentType<TextLabelPanelProps>;
+declare namespace TextLabelPanelFactory {
+    var deps: (typeof RangeSliderFactory | typeof LayerConfigGroupFactory | typeof FieldSelectorFactory | typeof ColorSelectorFactory)[];
+}
+export default TextLabelPanelFactory;

package/dist/components/side-panel/layer-panel/vis-config-by-field-selector.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl';
+import InfoHelperFactory from 'components/common/info-helper';
+import FieldSelectorFactory from '../../common/field-selector';
+import { Field } from 'utils/table-utils/kepler-table';
+import ColorDimensionScaleSelectorFactory from './color-dimension-scale-selector';
+type VisConfigByFieldSelectorProps = {
+    channel: string;
+    fields: Field[];
+    id: string;
+    property: string;
+    showScale: boolean;
+    showScaleCustomizable: boolean;
+    updateField: (val: readonly (string | number | boolean | object)[] | string | number | boolean | object | null) => void;
+    updateScale: (val: readonly (string | number | boolean | object)[] | string | number | boolean | object | null) => void;
+    updateCustomPalette: Function;
+    scaleType?: string;
+    selectedField?: Field;
+    description?: string;
+    label?: string;
+    placeholder?: string;
+    scaleOptions: string[];
+    isLoading?: boolean;
+    fieldsAggregated?: boolean;
+    aggregator?: string;
+} & WrappedComponentProps;
+declare function VisConfigByFieldSelectorFactory(InfoHelper: ReturnType<typeof InfoHelperFactory>, FieldSelector: ReturnType<typeof FieldSelectorFactory>, ColorDimensionScaleSelector: ReturnType<typeof ColorDimensionScaleSelectorFactory>): React.ForwardRefExoticComponent<import("react-intl").Omit<VisConfigByFieldSelectorProps, "intl"> & {
+    forwardedRef?: React.Ref<any>;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<VisConfigByFieldSelectorProps>;
+};
+declare namespace VisConfigByFieldSelectorFactory {
+    var deps: (typeof InfoHelperFactory | typeof FieldSelectorFactory | typeof ColorDimensionScaleSelectorFactory)[];
+}
+export default VisConfigByFieldSelectorFactory;

package/dist/components/side-panel/layer-panel/vis-config-slider.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import RangeSliderFactory from 'components/common/range-slider';
+import { Layer, LayerBaseConfig } from 'layers';
+type VisConfigSliderProps = {
+    layer: Layer;
+    property: string;
+    onChange: (v: Record<string, number | string | number[] | string[]>) => void;
+    label?: string | ((c: LayerBaseConfig) => string);
+    range: [number, number];
+    step?: number;
+    isRanged: boolean;
+    disabled?: boolean;
+    inputTheme?: string;
+    allowCustomValue?: boolean;
+};
+declare function VisConfigSliderFactory(RangeSlider: ReturnType<typeof RangeSliderFactory>): React.FC<VisConfigSliderProps>;
+declare namespace VisConfigSliderFactory {
+    var deps: (typeof RangeSliderFactory)[];
+}
+export default VisConfigSliderFactory;

package/dist/components/side-panel/layer-panel/vis-config-switch.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import InfoHelperFactory from 'components/common/info-helper';
+import { Layer } from 'layers';
+type VisConfigSwitchProps = {
+    layer: Layer;
+    property: string;
+    onChange: (v: Record<string, boolean>) => void;
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+};
+declare function VisConfigSwitchFactory(InfoHelper: ReturnType<typeof InfoHelperFactory>): React.FC<VisConfigSwitchProps>;
+declare namespace VisConfigSwitchFactory {
+    var deps: (typeof InfoHelperFactory)[];
+}
+export default VisConfigSwitchFactory;

package/dist/components/side-panel/map-manager.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import MapStyleSelectorFactory from 'components/side-panel/map-style-panel/map-style-selector';
+import LayerGroupSelectorFactory from 'components/side-panel/map-style-panel/map-layer-selector';
+import { WrappedComponentProps } from 'react-intl';
+import { MapStyle } from 'reducers';
+import * as MapStyleActions from 'actions/map-style-actions';
+import ColorSelectorFactory from './layer-panel/color-selector';
+type MapManagerProps = {
+    mapStyle: MapStyle;
+    mapStyleActions: typeof MapStyleActions;
+    showAddMapStyleModal: () => void;
+} & WrappedComponentProps;
+declare function MapManagerFactory(MapStyleSelector: ReturnType<typeof MapStyleSelectorFactory>, LayerGroupSelector: ReturnType<typeof LayerGroupSelectorFactory>, ColorSelector: ReturnType<typeof ColorSelectorFactory>): React.ForwardRefExoticComponent<import("react-intl").Omit<MapManagerProps, "intl"> & {
+    forwardedRef?: React.Ref<any>;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<MapManagerProps>;
+};
+declare namespace MapManagerFactory {
+    var deps: (typeof MapStyleSelectorFactory | typeof LayerGroupSelectorFactory | typeof ColorSelectorFactory)[];
+}
+export default MapManagerFactory;

package/dist/components/side-panel/map-style-panel/map-layer-selector.d.ts

@@ -0,0 +1,19 @@
+import React, { ComponentType } from 'react';
+import PanelHeaderActionFactory from 'components/side-panel/panel-header-action';
+import { VisibleLayerGroups } from 'reducers';
+import { BaseProps } from 'components/common/icons/base';
+type LayerGroupSelectorProps = {
+    layers: VisibleLayerGroups;
+    editableLayers: string[];
+    onChange: (payload: {
+        visibleLayerGroups?: VisibleLayerGroups;
+        topLayerGroups?: VisibleLayerGroups;
+    }) => void;
+    topLayers: VisibleLayerGroups;
+    actionIcons?: Record<string, ComponentType<Partial<BaseProps>>>;
+};
+declare function LayerGroupSelectorFactory(PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): ({ layers, editableLayers, onChange, topLayers, actionIcons }: LayerGroupSelectorProps) => React.JSX.Element;
+declare namespace LayerGroupSelectorFactory {
+    var deps: (typeof PanelHeaderActionFactory)[];
+}
+export default LayerGroupSelectorFactory;

package/dist/components/side-panel/map-style-panel/map-style-selector.d.ts

@@ -0,0 +1,16 @@
+import React, { ComponentType } from 'react';
+import PanelHeaderActionFactory from 'components/side-panel/panel-header-action';
+import { MapStyle } from 'reducers';
+import { BaseProps } from 'components/common/icons/base';
+type MapStyleSelectorProps = {
+    mapStyle: MapStyle;
+    onChange: (payload: string) => void;
+    toggleActive: () => void;
+    isSelecting: boolean;
+    actionIcons?: Record<string, ComponentType<Partial<BaseProps>>>;
+};
+declare function MapStyleSelectorFactory(PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): ({ mapStyle, onChange, toggleActive, isSelecting, actionIcons }: MapStyleSelectorProps) => React.JSX.Element;
+declare namespace MapStyleSelectorFactory {
+    var deps: (typeof PanelHeaderActionFactory)[];
+}
+export default MapStyleSelectorFactory;

package/dist/components/side-panel/panel-dropdown.d.ts

@@ -0,0 +1,18 @@
+import React, { Component } from 'react';
+type ClickOutsideCloseDropdownProps = {
+    show: boolean;
+    type: string;
+    className: string;
+    children?: React.ReactNode;
+    onClose: (e: Event) => void;
+};
+declare class ClickOutsideCloseDropdown extends Component<ClickOutsideCloseDropdownProps> {
+    static defaultProps: {
+        show: boolean;
+        type: string;
+    };
+    handleClickOutside: (e: Event) => void;
+    render(): React.JSX.Element;
+}
+declare const _default: import("react-onclickoutside").WrapperClass<ClickOutsideCloseDropdownProps, typeof ClickOutsideCloseDropdown>;
+export default _default;

package/dist/components/side-panel/panel-header-action.d.ts

@@ -0,0 +1,20 @@
+import React, { ComponentType, MouseEventHandler } from 'react';
+import { TooltipProps } from 'react-tooltip';
+import { BaseProps } from 'components/common/icons/base';
+interface PanelHeaderActionProps {
+    id?: string;
+    tooltip?: string;
+    hoverColor?: string;
+    className?: string;
+    active?: boolean;
+    flush?: boolean;
+    disabled?: boolean;
+    onClick?: MouseEventHandler;
+    tooltipType?: TooltipProps['type'];
+    IconComponent: ComponentType<Partial<BaseProps>>;
+}
+declare function PanelHeaderActionFactory(): React.ComponentType<PanelHeaderActionProps>;
+declare namespace PanelHeaderActionFactory {
+    var deps: any[];
+}
+export default PanelHeaderActionFactory;

package/dist/components/side-panel/panel-header.d.ts

@@ -0,0 +1,78 @@
+import React from 'react';
+import { ToolbarItemProps } from 'components/common/toolbar-item';
+import { UiState } from 'reducers';
+import { BaseProps } from 'components/common/icons/base';
+type ActionItem = {
+    id: string;
+    label?: string;
+    blank?: boolean;
+    href?: string;
+    tooltip?: string;
+    iconComponent: React.ComponentType<Partial<BaseProps>>;
+    iconComponentProps?: BaseProps;
+    dropdownComponent?: React.ComponentType<DropdownComponentProps>;
+    onClick?: (p: PanelHeaderProps) => void;
+};
+type PanelActionProps = {
+    item: ActionItem;
+    onClick: () => void;
+};
+type PanelHeaderDropdownProps = {
+    id: string;
+    items: ToolbarItemProps[];
+    show?: boolean;
+    onClose: () => void;
+};
+type DropdownCallbacks = {
+    logoComponent?: React.ComponentType<{
+        appName: string;
+        appWebsite: string;
+        version: string;
+    }>;
+    onExportImage: () => void;
+    onExportData: () => void;
+    onExportConfig?: () => void;
+    onExportMap: () => void;
+    onSaveToStorage: (() => void) | null;
+    onSaveAsToStorage: (() => void) | null;
+    onSaveMap?: () => void;
+    onShareMap: (() => void) | null;
+};
+type Item = {
+    label: string;
+    icon: React.ComponentType<Partial<BaseProps>>;
+    key: string;
+    onClick: (p: DropdownComponentProps) => (() => void) | null;
+};
+type DropdownComponentProps = {
+    show: boolean;
+    onClose: () => void;
+    items?: Item[];
+} & DropdownCallbacks;
+type PanelHeaderProps = {
+    appName: string;
+    appWebsite: string;
+    version: string;
+    visibleDropdown: UiState['visibleDropdown'];
+    actionItems?: ActionItem[];
+    showExportDropdown: (i: string) => void;
+    hideExportDropdown: () => void;
+} & DropdownCallbacks;
+export declare const PanelAction: React.FC<PanelActionProps>;
+export declare const PanelHeaderDropdownFactory: () => React.FC<PanelHeaderDropdownProps>;
+export declare const SaveExportDropdownFactory: {
+    (PanelHeaderDropdown: ReturnType<typeof PanelHeaderDropdownFactory>): React.FC<DropdownComponentProps>;
+    deps: (() => React.FC<PanelHeaderDropdownProps>)[];
+};
+export declare const CloudStorageDropdownFactory: {
+    (PanelHeaderDropdown: ReturnType<typeof PanelHeaderDropdownFactory>): React.FC<DropdownComponentProps>;
+    deps: (() => React.FC<PanelHeaderDropdownProps>)[];
+};
+declare function PanelHeaderFactory(SaveExportDropdown: ReturnType<typeof SaveExportDropdownFactory>, CloudStorageDropdown: ReturnType<typeof CloudStorageDropdownFactory>): React.ComponentType<PanelHeaderProps>;
+declare namespace PanelHeaderFactory {
+    var deps: {
+        (PanelHeaderDropdown: React.FC<PanelHeaderDropdownProps>): React.FC<DropdownComponentProps>;
+        deps: (() => React.FC<PanelHeaderDropdownProps>)[];
+    }[];
+}
+export default PanelHeaderFactory;

package/dist/components/side-panel/panel-tab.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { BaseProps } from 'components/common/icons/base';
+type StyledPanelTabProps = {
+    active?: boolean;
+};
+export type PanelItem = {
+    id: string;
+    label: string;
+    iconComponent: React.ComponentType<Partial<BaseProps>>;
+};
+type PanelTabProps = {
+    isActive: boolean;
+    panel: PanelItem;
+    onClick: () => void;
+};
+export declare const StyledPanelTab: import("styled-components").StyledComponent<"div", any, {
+    className: "side-panel__tab";
+} & StyledPanelTabProps, "className">;
+export declare function PanelTabFactory(): React.FC<PanelTabProps>;
+export default PanelTabFactory;

package/dist/components/side-panel/panel-title.d.ts

@@ -0,0 +1,4 @@
+declare const PanelTitleFactory: () => import("styled-components").StyledComponent<"div", any, {
+    className: string;
+}, "className">;
+export default PanelTitleFactory;

package/dist/components/side-panel/panel-toggle.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import PanelTabFactory, { PanelItem } from './panel-tab';
+import { toggleSidePanel } from 'actions/ui-state-actions';
+import { ActionHandler } from 'actions';
+type PanelToggleProps = {
+    panels: PanelItem[];
+    activePanel: string;
+    togglePanel: ActionHandler<typeof toggleSidePanel>;
+};
+declare function PanelToggleFactory(PanelTab: ReturnType<typeof PanelTabFactory>): React.FC<PanelToggleProps>;
+declare namespace PanelToggleFactory {
+    var deps: (typeof PanelTabFactory)[];
+}
+export default PanelToggleFactory;

package/dist/components/side-panel/side-bar.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+type CollapseButtonProps = {
+    isOpen: boolean;
+    onClick: () => void;
+};
+type SideBarProps = {
+    children: React.ReactNode;
+    width: number;
+    isOpen: boolean;
+    minifiedWidth: number;
+    onOpenOrClose: (v: {
+        isOpen: boolean;
+    }) => void;
+};
+export declare const CollapseButtonFactory: () => ({ onClick, isOpen }: CollapseButtonProps) => React.JSX.Element;
+declare function SidebarFactory(CollapseButton: ReturnType<typeof CollapseButtonFactory>): {
+    new (props: SideBarProps): {
+        _onOpenOrClose: () => void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<SideBarProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<SideBarProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<SideBarProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<SideBarProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<SideBarProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<SideBarProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<SideBarProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<SideBarProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<SideBarProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: SideBarProps, context: any): {
+        _onOpenOrClose: () => void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<SideBarProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<SideBarProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<SideBarProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<SideBarProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<SideBarProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<SideBarProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<SideBarProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<SideBarProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<SideBarProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    defaultProps: {
+        width: number;
+        minifiedWidth: number;
+        isOpen: boolean;
+        onOpenOrClose: () => void;
+    };
+    contextType?: React.Context<any>;
+};
+declare namespace SidebarFactory {
+    var deps: (() => ({ onClick, isOpen }: CollapseButtonProps) => React.JSX.Element)[];
+}
+export default SidebarFactory;

package/dist/components/side-panel.d.ts

@@ -0,0 +1,134 @@
+import React from 'react';
+import SidebarFactory from './side-panel/side-bar';
+import PanelHeaderFactory from './side-panel/panel-header';
+import PanelToggleFactory from './side-panel/panel-toggle';
+import LayerManagerFactory from './side-panel/layer-manager';
+import FilterManagerFactory from './side-panel/filter-manager';
+import InteractionManagerFactory from './side-panel/interaction-manager';
+import MapManagerFactory from './side-panel/map-manager';
+import CustomPanelsFactory from './side-panel/custom-panel';
+import PanelTitleFactory from './side-panel/panel-title';
+import { SidePanelProps } from './types';
+export declare const StyledSidePanelContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+/**
+ * Vertical sidebar containing input components for the rendering layers
+ */
+declare function SidePanelFactory(Sidebar: ReturnType<typeof SidebarFactory>, PanelHeader: ReturnType<typeof PanelHeaderFactory>, PanelToggle: ReturnType<typeof PanelToggleFactory>, PanelTitle: ReturnType<typeof PanelTitleFactory>, LayerManager: ReturnType<typeof LayerManagerFactory>, FilterManager: ReturnType<typeof FilterManagerFactory>, InteractionManager: ReturnType<typeof InteractionManagerFactory>, MapManager: ReturnType<typeof MapManagerFactory>, CustomPanels: ReturnType<typeof CustomPanelsFactory>): {
+    (props: SidePanelProps): React.JSX.Element;
+    defaultProps: {
+        panels: {
+            component: any;
+            id: string;
+            label: string;
+            iconComponent: typeof import("./common/icons").Layers;
+            onClick: any;
+        }[];
+        sidebarComponents: {
+            layer: React.ForwardRefExoticComponent<import("react-intl").Omit<{
+                datasets: import("..").Datasets;
+                layers: import("../layers/base-layer").default[];
+                layerOrder: number[];
+                layerClasses: {
+                    point: typeof import("../layers/point-layer/point-layer").default;
+                    arc: typeof import("../layers/arc-layer/arc-layer").default;
+                    line: typeof import("../layers/line-layer/line-layer").default;
+                    grid: typeof import("../layers/grid-layer/grid-layer").default;
+                    hexagon: typeof import("../layers/hexagon-layer/hexagon-layer").default;
+                    geojson: typeof import("../layers/geojson-layer/geojson-layer").default;
+                    cluster: typeof import("../layers/cluster-layer/cluster-layer").default;
+                    icon: typeof import("../layers/icon-layer/icon-layer").default;
+                    heatmap: typeof import("../layers/heatmap-layer/heatmap-layer").default;
+                    hexagonId: typeof import("../layers/h3-hexagon-layer/h3-hexagon-layer").default;
+                    "3D": typeof import("../layers/scenegraph-layer/scenegraph-layer").default;
+                    trip: typeof import("../layers/trip-layer/trip-layer").default;
+                    s2: typeof import("../layers/s2-geometry-layer/s2-geometry-layer").default;
+                };
+                layerBlending: string;
+                uiStateActions: typeof import("../actions/ui-state-actions");
+                visStateActions: typeof import("../actions/vis-state-actions");
+                showAddDataModal: () => void;
+                removeDataset: import("..").ActionHandler<(datasetId: string) => {
+                    payload: string;
+                    type: "@@kepler.gl/OPEN_DELETE_MODAL";
+                }>;
+                showDatasetTable: import("..").ActionHandler<typeof import("..").showDatasetTable>;
+                updateTableColor: import("..").ActionHandler<typeof import("..").updateTableColor>;
+                layerPanelListView: import("../reducers/ui-state-updaters").LayerPanelListView;
+                panelMetadata: import("./types").SidePanelItem;
+            } & import("react-intl").WrappedComponentProps<"intl">, "intl"> & {
+                forwardedRef?: React.Ref<any>;
+            } & React.RefAttributes<any>> & {
+                WrappedComponent: React.ComponentType<{
+                    datasets: import("..").Datasets;
+                    layers: import("../layers/base-layer").default[];
+                    layerOrder: number[];
+                    layerClasses: {
+                        point: typeof import("../layers/point-layer/point-layer").default;
+                        arc: typeof import("../layers/arc-layer/arc-layer").default;
+                        line: typeof import("../layers/line-layer/line-layer").default;
+                        grid: typeof import("../layers/grid-layer/grid-layer").default;
+                        hexagon: typeof import("../layers/hexagon-layer/hexagon-layer").default;
+                        geojson: typeof import("../layers/geojson-layer/geojson-layer").default;
+                        cluster: typeof import("../layers/cluster-layer/cluster-layer").default;
+                        icon: typeof import("../layers/icon-layer/icon-layer").default;
+                        heatmap: typeof import("../layers/heatmap-layer/heatmap-layer").default;
+                        hexagonId: typeof import("../layers/h3-hexagon-layer/h3-hexagon-layer").default;
+                        "3D": typeof import("../layers/scenegraph-layer/scenegraph-layer").default;
+                        trip: typeof import("../layers/trip-layer/trip-layer").default;
+                        s2: typeof import("../layers/s2-geometry-layer/s2-geometry-layer").default;
+                    };
+                    layerBlending: string;
+                    uiStateActions: typeof import("../actions/ui-state-actions");
+                    visStateActions: typeof import("../actions/vis-state-actions");
+                    showAddDataModal: () => void;
+                    removeDataset: import("..").ActionHandler<(datasetId: string) => {
+                        payload: string;
+                        type: "@@kepler.gl/OPEN_DELETE_MODAL";
+                    }>;
+                    showDatasetTable: import("..").ActionHandler<typeof import("..").showDatasetTable>;
+                    updateTableColor: import("..").ActionHandler<typeof import("..").updateTableColor>;
+                    layerPanelListView: import("../reducers/ui-state-updaters").LayerPanelListView;
+                    panelMetadata: import("./types").SidePanelItem;
+                } & import("react-intl").WrappedComponentProps<"intl">>;
+            };
+            filter: ({ filters, datasets, layers, showDatasetTable, updateTableColor, visStateActions }: {
+                filters: import("..").Filter[];
+                datasets: import("..").Datasets;
+                layers: import("../layers/base-layer").default[];
+                showDatasetTable: import("..").ActionHandler<typeof import("..").showDatasetTable>;
+                updateTableColor: import("..").ActionHandler<typeof import("..").updateTableColor>;
+                visStateActions: typeof import("../actions/vis-state-actions");
+            }) => React.JSX.Element;
+            interaction: ({ interactionConfig, datasets, visStateActions }: {
+                interactionConfig: import("..").InteractionConfig;
+                datasets: import("..").Datasets;
+                visStateActions: typeof import("../actions/vis-state-actions");
+            }) => React.JSX.Element;
+            map: React.ForwardRefExoticComponent<import("react-intl").Omit<{
+                mapStyle: import("..").MapStyle;
+                mapStyleActions: typeof import("../actions/map-style-actions");
+                showAddMapStyleModal: () => void;
+            } & import("react-intl").WrappedComponentProps<"intl">, "intl"> & {
+                forwardedRef?: React.Ref<any>;
+            } & React.RefAttributes<any>> & {
+                WrappedComponent: React.ComponentType<{
+                    mapStyle: import("..").MapStyle;
+                    mapStyleActions: typeof import("../actions/map-style-actions");
+                    showAddMapStyleModal: () => void;
+                } & import("react-intl").WrappedComponentProps<"intl">>;
+            };
+        };
+        uiState: {};
+        visStateActions: {};
+        mapStyleActions: {};
+        uiStateActions: {};
+        availableProviders: {};
+        mapInfo: {};
+    };
+};
+declare namespace SidePanelFactory {
+    var deps: (typeof SidebarFactory | typeof PanelHeaderFactory | typeof PanelToggleFactory | (() => import("styled-components").StyledComponent<"div", any, {
+        className: string;
+    }, "className">) | typeof LayerManagerFactory | typeof FilterManagerFactory | typeof InteractionManagerFactory | typeof MapManagerFactory | typeof CustomPanelsFactory)[];
+}
+export default SidePanelFactory;

package/dist/components/types.d.ts

@@ -0,0 +1,44 @@
+import { ComponentType } from 'react';
+import { Datasets, Filter, InteractionConfig, MapStyle } from '../reducers';
+import { Layer, LayerClassesType } from '../layers';
+import { UiState } from 'reducers/ui-state-updaters';
+import * as MapStyleActions from 'actions/map-style-actions';
+import * as VisStateActions from 'actions/vis-state-actions';
+import * as MapStateActions from 'actions/map-state-actions';
+import * as UIStateActions from 'actions/ui-state-actions';
+export type SidePanelItem = {
+    id: string;
+    label: string;
+    iconComponent: ComponentType<any>;
+    component?: ComponentType<any>;
+};
+export type SidePanelProps = {
+    appName: string;
+    appWebsite: string;
+    filters: Filter[];
+    interactionConfig: InteractionConfig;
+    layerBlending: string;
+    layers: Layer[];
+    layerClasses: LayerClassesType;
+    layerOrder: number[];
+    mapStyle: MapStyle;
+    onSaveMap?: () => void;
+    width: number;
+    mapInfo: {
+        title: string;
+        description: string;
+    };
+    datasets: Datasets;
+    uiStateActions: typeof UIStateActions;
+    visStateActions: typeof VisStateActions;
+    mapStateActions: typeof MapStateActions;
+    mapStyleActions: typeof MapStyleActions;
+    uiState: UiState;
+    availableProviders: {
+        hasShare: boolean;
+        hasStorage: boolean;
+    };
+    mapSaved?: string | null;
+    panels: SidePanelItem[];
+    version: string;
+};

package/dist/connect/keplergl-connect.d.ts

@@ -0,0 +1,5 @@
+import { JSXElementConstructor } from 'react';
+import { GetProps, Matching } from 'react-redux';
+export declare const connect: <T extends JSXElementConstructor<Matching<any, GetProps<T>>>>(mapStateToProps?: (state: any, _: any, __: any) => any, makeMapDispatchToProps?: () => (dispatch: any, _: any, __: any) => {
+    dispatch: any;
+}, reduxMergeProps?: any, options?: any) => (BaseComponent: T) => import("react").ComponentType<any>;

package/dist/connect/with-local-selector.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { KeplerGlState } from 'reducers/combined-updaters';
+declare const withLocalSelector: <P extends {}>(ParentComponent: React.ComponentType<P>) => React.ComponentType<P & {
+    selector: (...args: any[]) => KeplerGlState;
+}>;
+export default withLocalSelector;