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

package/dist/components/common/slider/slider-handle.d.ts

@@ -0,0 +1,33 @@
+import React, { Component, RefObject } from 'react';
+import MouseEventHandler from './mouse-event';
+import { StyleRangeSliderType } from './slider';
+type SliderHandleProps = {
+    sliderHandleWidth: number;
+    left: string;
+    display: boolean;
+    valueListener: (distance: number) => void;
+    vertical: boolean;
+    track: RefObject<StyleRangeSliderType>;
+    showTooltip: boolean;
+    value?: number;
+};
+export default class SliderHandle extends Component {
+    props: SliderHandleProps;
+    static defaultProps: {
+        sliderHandleWidth: number;
+        left: string;
+        display: boolean;
+        vertical: boolean;
+        valueListener: () => void;
+        showTooltip: boolean;
+    };
+    mouseEvent: MouseEventHandler;
+    constructor(props: SliderHandleProps);
+    state: {
+        mouseOver: boolean;
+    };
+    ref: React.RefObject<HTMLSpanElement>;
+    toggleMouseOver: () => void;
+    render(): React.JSX.Element;
+}
+export {};

package/dist/components/common/slider/slider.d.ts

@@ -0,0 +1,70 @@
+import React, { Component, RefObject } from 'react';
+declare function noop(): void;
+interface StyledRangeSliderProps {
+    vertical?: boolean;
+}
+declare const StyledRangeSlider: import("styled-components").StyledComponent<"div", any, StyledRangeSliderProps, never>;
+export type StyleRangeSliderType = typeof StyledRangeSlider & HTMLDivElement;
+interface SliderWrapperProps {
+    isRanged?: boolean;
+    vertical?: boolean;
+}
+declare const SliderWrapper: import("styled-components").StyledComponent<"div", any, SliderWrapperProps, never>;
+type SliderProps = {
+    title: string;
+    isRanged: boolean;
+    value0: number;
+    value1: number;
+    minValue: number;
+    maxValue: number;
+    sliderHandleWidth: number;
+    onSlider0Change: (val: number) => void;
+    onSlider1Change: (val: number) => void;
+    onSliderBarChange: (val0: number, val1: number) => void;
+    step: number;
+    enableBarDrag: boolean;
+    showTooltip: boolean;
+    vertical: boolean;
+    marks?: number[];
+    classSet?: {
+        [key: string]: boolean;
+    };
+    disabled: boolean;
+};
+export default class Slider extends Component {
+    props: SliderProps;
+    static defaultProps: {
+        title: string;
+        isRanged: boolean;
+        value0: number;
+        value1: number;
+        minValue: number;
+        maxValue: number;
+        step: number;
+        sliderHandleWidth: number;
+        enableBarDrag: boolean;
+        onSlider0Change: typeof noop;
+        onSlider1Change: typeof noop;
+        onSliderBarChange: typeof noop;
+        disabled: boolean;
+        vertical: boolean;
+        showTooltip: boolean;
+    };
+    private anchor;
+    ref: RefObject<typeof SliderWrapper & HTMLDivElement>;
+    track: RefObject<StyleRangeSliderType>;
+    constructor(props: SliderProps);
+    private setAnchor;
+    private getBaseDistance;
+    private getDeltaVal;
+    private getDeltaX;
+    private getValue;
+    private normalizeValue;
+    slide0Listener: (x: number) => void;
+    slide1Listener: (x: number) => void;
+    sliderBarListener: (x: number) => void;
+    calcHandleLeft0: (w: number, l: number) => string;
+    calcHandleLeft1: (w: number, l: number) => string;
+    render(): React.JSX.Element;
+}
+export {};

package/dist/components/common/styled-components.d.ts

@@ -0,0 +1,119 @@
+import ReactTooltip from 'react-tooltip';
+import { RGBColor } from 'reducers';
+export declare const SelectText: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const SelectTextBold: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const IconRoundSmall: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const CenterFlexbox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const CenterVerticalFlexbox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SpaceBetweenFlexbox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SBFlexboxItem: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SBFlexboxNoMargin: import("styled-components").StyledComponent<"div", any, {}, never>;
+export type PanelLabelProps = {
+    active?: boolean;
+    className?: string;
+};
+export declare const PanelLabel: import("styled-components").StyledComponent<"label", any, PanelLabelProps, never>;
+export declare const PanelLabelWrapper: import("styled-components").StyledComponent<"div", any, {
+    className: "side-panel-panel__label-wrapper";
+}, "className">;
+export declare const PanelLabelBold: import("styled-components").StyledComponent<"label", any, PanelLabelProps, never>;
+export declare const PanelHeaderTitle: import("styled-components").StyledComponent<"span", any, {
+    className: string;
+}, "className">;
+export declare const PanelHeaderContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const PanelContent: import("styled-components").StyledComponent<"div", any, {
+    className: string;
+}, "className">;
+interface SidePanelSectionProps {
+    disabled?: boolean;
+}
+export declare const SidePanelSection: import("styled-components").StyledComponent<"div", any, {
+    className: string;
+} & SidePanelSectionProps, "className">;
+export declare const SidePanelDivider: import("styled-components").StyledComponent<"div", any, {
+    className: "side-panel-divider";
+}, "className">;
+export declare const Tooltip: import("styled-components").StyledComponent<typeof ReactTooltip, any, {}, never>;
+export interface ButtonProps {
+    negative?: boolean;
+    secondary?: boolean;
+    link?: boolean;
+    floating?: boolean;
+    cta?: boolean;
+    large?: boolean;
+    small?: boolean;
+    disabled?: boolean;
+    width?: string;
+    inactive?: boolean;
+}
+export declare const Button: import("styled-components").StyledComponent<"div", any, {
+    className: string;
+} & ButtonProps, "className">;
+interface InputProps {
+    secondary?: boolean;
+}
+export declare const Input: import("styled-components").StyledComponent<"input", any, InputProps, never>;
+export declare const InputLight: import("styled-components").StyledComponent<"input", any, {}, never>;
+export declare const TextArea: import("styled-components").StyledComponent<"textarea", any, InputProps, never>;
+export declare const TextAreaLight: import("styled-components").StyledComponent<"textarea", any, {}, never>;
+export declare const InlineInput: import("styled-components").StyledComponent<"input", any, InputProps, never>;
+export interface StyledPanelHeaderProps {
+    active?: boolean;
+    labelRCGColorValues?: RGBColor | null;
+}
+export declare const StyledPanelHeader: import("styled-components").StyledComponent<"div", any, StyledPanelHeaderProps, never>;
+interface StyledPanelDropdownProps {
+    type?: string;
+}
+export declare const StyledPanelDropdown: import("styled-components").StyledComponent<"div", any, StyledPanelDropdownProps, never>;
+export declare const ButtonGroup: import("styled-components").StyledComponent<"div", any, {}, never>;
+interface DatasetSquareProps {
+    backgroundColor: RGBColor;
+}
+export declare const DatasetSquare: import("styled-components").StyledComponent<"div", any, DatasetSquareProps, never>;
+interface SelectionButtonProps {
+    selected?: boolean;
+}
+export declare const SelectionButton: import("styled-components").StyledComponent<"div", any, SelectionButtonProps, never>;
+export declare const Table: import("styled-components").StyledComponent<"table", any, {}, never>;
+export declare const StyledModalContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const StyledModalVerticalPanel: import("styled-components").StyledComponent<"div", any, {
+    className: "modal-vertical-panel";
+}, "className">;
+export declare const StyledModalSection: import("styled-components").StyledComponent<"div", any, {
+    className: string;
+}, "className">;
+interface StyledModalInputFootnoteProps {
+    error?: boolean;
+}
+export declare const StyledModalInputFootnote: import("styled-components").StyledComponent<"div", any, {
+    className: "modal-input__footnote";
+} & StyledModalInputFootnoteProps, "className">;
+/**
+ * Newer versions of mapbox.gl display an error message banner on top of the map by default
+ * which will cause the map to display points in the wrong locations
+ * This workaround will hide the error banner.
+ */
+export declare const StyledMapContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export interface StyledExportSectionProps {
+    disabled?: boolean;
+}
+export declare const StyledExportSection: import("styled-components").StyledComponent<"div", any, StyledExportSectionProps, never>;
+export declare const StyledFilteredOption: import("styled-components").StyledComponent<"div", any, SelectionButtonProps, never>;
+export declare const StyledType: import("styled-components").StyledComponent<"div", any, SelectionButtonProps, never>;
+export declare const WidgetContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const BottomWidgetInner: import("styled-components").StyledComponent<"div", any, {}, never>;
+interface MapControlButtonProps {
+    active?: boolean;
+}
+export declare const MapControlButton: import("styled-components").StyledComponent<"div", any, {
+    className: string;
+} & ButtonProps & {
+    className: string;
+} & MapControlButtonProps, "className">;
+export declare const StyledFilterContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const TruncatedTitleText: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const CheckMark: import("styled-components").StyledComponent<"span", any, {
+    className: "checkbox-inner";
+}, "className">;
+export {};

package/dist/components/common/switch.d.ts

@@ -0,0 +1,16 @@
+import React, { ChangeEventHandler, FocusEventHandler, ReactNode } from 'react';
+interface SwitchProps {
+    checked?: boolean;
+    disabled?: boolean;
+    type?: string;
+    id: string;
+    label?: ReactNode;
+    error?: string;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    value?: string;
+    secondary?: boolean;
+}
+declare const Switch: (props: SwitchProps) => React.JSX.Element;
+export default Switch;

package/dist/components/common/time-range-slider-time-title.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface TimeTitleProps {
+    value: number[];
+    isEnlarged?: boolean;
+    timezone?: string | null;
+    timeFormat: string;
+}
+declare function TimeRangeSliderTimeTitleFactory(): ({ value, isEnlarged, timezone, timeFormat }: TimeTitleProps) => React.JSX.Element;
+export default TimeRangeSliderTimeTitleFactory;

package/dist/components/common/time-range-slider.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import RangeSliderFactory from 'components/common/range-slider';
+import TimeSliderMarkerFactory from 'components/common/time-slider-marker';
+import PlaybackControlsFactory from 'components/common/animation-control/playback-controls';
+import TimeRangeSliderTimeTitleFactory from 'components/common/time-range-slider-time-title';
+import { HistogramBin, LineChart } from 'reducers';
+type TimeRangeSliderProps = {
+    domain?: [number, number];
+    value: [number, number];
+    isEnlarged?: boolean;
+    hideTimeTitle?: boolean;
+    isAnimating: boolean;
+    timeFormat: string;
+    timezone?: string | null;
+    histogram?: HistogramBin[];
+    plotType?: string;
+    lineChart?: LineChart;
+    step: number;
+    isAnimatable?: boolean;
+    speed: number;
+    animationWindow: string;
+    resetAnimation?: () => void;
+    toggleAnimation: () => void;
+    updateAnimationSpeed?: (val: number) => void;
+    setFilterAnimationWindow?: (id: string) => void;
+    onChange: (v: number[]) => void;
+};
+declare function TimeRangeSliderFactory(PlaybackControls: ReturnType<typeof PlaybackControlsFactory>, RangeSlider: ReturnType<typeof RangeSliderFactory>, TimeSliderMarker: ReturnType<typeof TimeSliderMarkerFactory>, TimeRangeSliderTimeTitle: ReturnType<typeof TimeRangeSliderTimeTitleFactory>): React.NamedExoticComponent<TimeRangeSliderProps>;
+declare namespace TimeRangeSliderFactory {
+    var deps: (typeof PlaybackControlsFactory | typeof RangeSliderFactory | typeof TimeSliderMarkerFactory | typeof TimeRangeSliderTimeTitleFactory)[];
+}
+export default TimeRangeSliderFactory;

package/dist/components/common/time-slider-marker.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { NumberValue } from 'd3-scale';
+export declare function getTickFormat(timezone: string): (date: any) => string;
+export declare function getXAxis(domain: Date[] | NumberValue[], width: number, isEnlarged: boolean, timezone: string): any;
+export declare function updateAxis(xAxisRef: any, xAxis: any): void;
+interface TimeSliderMarkerProps {
+    width: number;
+    domain: Date[] | NumberValue[];
+    isEnlarged?: boolean;
+    height?: number;
+    timezone: string;
+}
+declare function TimeSliderMarkerFactory(): React.MemoExoticComponent<{
+    ({ width, domain, isEnlarged, height, timezone }: TimeSliderMarkerProps): React.JSX.Element;
+    propTypes: {
+        domain: PropTypes.Validator<any[]>;
+        width: PropTypes.Validator<number>;
+    };
+}>;
+export default TimeSliderMarkerFactory;

package/dist/components/common/tippy-tooltip.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TippyProps } from '@tippyjs/react';
+declare const TippyTooltip: ({ children, render, duration, ...rest }: TippyProps) => React.JSX.Element;
+export default TippyTooltip;

package/dist/components/common/toolbar-item.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { ComponentType, MouseEvent } from 'react';
+export type ToolbarItemProps = {
+    id?: string;
+    key?: string;
+    label: string;
+    className?: string;
+    active?: boolean;
+    onClose?: () => void;
+    onClick: ((event: MouseEvent<HTMLDivElement>) => void) | null;
+    icon?: ComponentType<any>;
+};
+declare const ToolbarItem: React.MemoExoticComponent<(props: ToolbarItemProps) => React.JSX.Element>;
+export default ToolbarItem;

package/dist/components/common/toolbar.d.ts

@@ -0,0 +1,5 @@
+export interface ToolbarProps {
+    show?: boolean;
+}
+declare const Toolbar: import("styled-components").StyledComponent<"div", any, ToolbarProps, never>;
+export default Toolbar;

package/dist/components/common/vertical-toolbar.d.ts

@@ -0,0 +1,3 @@
+import { ToolbarProps } from './toolbar';
+declare const VerticalToolbar: import("styled-components").StyledComponent<"div", any, ToolbarProps, never>;
+export default VerticalToolbar;

package/dist/components/container.d.ts

@@ -0,0 +1,39 @@
+import React, { ComponentType } from 'react';
+import { ConnectedProps } from 'react-redux';
+import KeplerGlFactory from './kepler-gl';
+import { KeplerGlState } from 'reducers/core';
+export declare const ERROR_MSG: {
+    noState: string;
+};
+declare const connector: import("react-redux").InferableComponentEnhancerWithProps<{
+    id: string;
+    mapboxApiAccessToken: string;
+    mapboxApiUrl?: string;
+    mapStylesReplaceDefault?: boolean;
+    initialUiState?: object;
+    width: number;
+    mint?: boolean;
+    getState: (state: any) => KeplerGlState;
+    state: any;
+} & {
+    dispatch: React.Dispatch<any>;
+}, ContainerProps>;
+type ContainerProps = {
+    id: string;
+    mapboxApiAccessToken: string;
+    mapboxApiUrl?: string;
+    mapStylesReplaceDefault?: boolean;
+    initialUiState?: object;
+    width: number;
+    mint?: boolean;
+    getState: (state: any) => KeplerGlState;
+};
+type PropsFromRedux = ConnectedProps<typeof connector> & ContainerProps;
+export declare function ContainerFactory(KeplerGl: ReturnType<typeof KeplerGlFactory>): ComponentType<PropsFromRedux>;
+export declare namespace ContainerFactory {
+    var deps: (typeof KeplerGlFactory)[];
+}
+export declare const appInjector: import("./injector").InjectorType;
+export declare function injectComponents(recipes?: any[]): any;
+declare const InjectedContainer: any;
+export default InjectedContainer;

package/dist/components/context.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+declare const KeplerGlContext: import("react").Context<{
+    selector: (state: any) => any;
+    id: string;
+}>;
+export declare const RootContext: import("react").Context<RefObject<HTMLDivElement>>;
+export default KeplerGlContext;

package/dist/components/editor/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const RENDER_STATE: {
+    INACTIVE: string;
+    UNCOMMITTED: string;
+    SELECTED: string;
+    HOVERED: string;
+};
+export declare const RENDER_TYPE: {
+    POINT: string;
+    LINE_STRING: string;
+    POLYGON: string;
+    RECTANGLE: string;
+};
+export declare const COLORS: {
+    PRIMARY: string;
+    SECONDARY: string;
+    TERTIARY: string;
+};

package/dist/components/editor/editor.d.ts

@@ -0,0 +1,29 @@
+import React, { CSSProperties } from 'react';
+import FeatureActionPanelFactory, { FeatureActionPanelProps } from './feature-action-panel';
+import { Layer } from 'layers';
+import { Datasets, Filter } from 'reducers';
+import { Feature } from '@nebula.gl/edit-modes';
+interface EditorProps {
+    filters: Filter[];
+    layers: Layer[];
+    datasets: Datasets;
+    editor: {
+        selectedFeature: Feature;
+        mode: string;
+    };
+    layersToRender: Record<string, Layer>;
+    index: number;
+    className: string;
+    clickRadius: number;
+    style: CSSProperties;
+    isEnabled: boolean;
+    onSelect: (f: Feature | null) => void;
+    onUpdate: (f: Feature[]) => void;
+    onDeleteFeature: (f: Feature) => void;
+    onTogglePolygonFilter: (l: Layer, f: Feature) => void;
+}
+declare function EditorFactory(FeatureActionPanel: React.FC<FeatureActionPanelProps>): React.ComponentClass<EditorProps>;
+declare namespace EditorFactory {
+    var deps: (typeof FeatureActionPanelFactory)[];
+}
+export default EditorFactory;

package/dist/components/editor/feature-action-panel.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { Layer } from 'layers';
+import { Datasets, Filter } from 'reducers';
+import { Feature } from '@nebula.gl/edit-modes';
+export interface FeatureActionPanelProps {
+    className?: string;
+    datasets: Datasets;
+    selectedFeature: Feature | null;
+    position: {
+        x: number;
+        y: number;
+    } | null;
+    layers: Layer[];
+    currentFilter?: Filter;
+    onToggleLayer: (l: Layer) => void;
+    onDeleteFeature: () => void;
+    onClose: () => void;
+}
+export declare function PureFeatureActionPanelFactory(): React.FC<FeatureActionPanelProps>;
+export declare namespace PureFeatureActionPanelFactory {
+    var deps: any[];
+}
+declare function FeatureActionPanelFactory(): import("react-onclickoutside").WrapperClass<FeatureActionPanelProps, React.FC<FeatureActionPanelProps>>;
+declare namespace FeatureActionPanelFactory {
+    var deps: any[];
+}
+export default FeatureActionPanelFactory;

package/dist/components/editor/feature-styles.d.ts

@@ -0,0 +1,24 @@
+export declare const DEFAULT_RADIUS = 5;
+export declare const DEFAULT_STATE_STYLE_STROKE: string;
+export declare const STATE_STYLES_STROKE: {
+    [x: number]: string;
+};
+export declare const DEFAULT_STATE_STYLE_FILL = "#000";
+export declare const STATE_STYLES_FILL: {
+    [x: number]: string;
+};
+export declare const DEFAULT_STATE_STYLE_OPACITY = 0.1;
+export declare const STATE_STYLES_STROKE_WIDTH = 2;
+export declare const DEFAULT_STROKE_DASH_ARRAY = "4,2";
+export declare const RENDER_TYPE_STYLES: {
+    [x: number]: (() => {
+        r: number;
+    }) | (() => {
+        fill: string;
+    });
+};
+export declare function noOp(): void;
+export declare function getStyle({ feature, state }: {
+    feature: any;
+    state: any;
+}): any;

package/dist/components/editor/handle-style.d.ts

@@ -0,0 +1,38 @@
+export declare const DEFAULT_STATE_STYLE_STROKE: string;
+export declare const STATE_STYLES_STROKE: {
+    [x: number]: string;
+};
+export declare const DEFAULT_STATE_STYLE_FILL = "#ffffff";
+export declare const STATE_STYLES_FILL: {
+    [x: number]: string;
+};
+export declare const RENDER_TYPE_STYLES: {
+    [x: number]: ((state: any) => {
+        fill: string;
+        stroke: string;
+    }) | (() => {
+        x: number;
+        y: number;
+        height: number;
+        width: number;
+    });
+};
+export declare const DEFAULT_STATE_STYLE_OPACITY = 0;
+export declare const DEFAULT_RADIUS = 5;
+export declare function getStyle({ feature, state }: {
+    feature: any;
+    state: any;
+}): {
+    stroke: string;
+    strokeWidth: number;
+    fill: string;
+    fillOpacity: number;
+    r: number;
+} | {
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    fillOpacity: number;
+    r: number;
+};
+export declare function getEditHandleShape(): string;

package/dist/components/filters/components.d.ts

@@ -0,0 +1,3 @@
+export declare const StyledFilterPanel: import("styled-components").StyledComponent<"label", any, {
+    className: "side-panel-panel__label";
+}, "className">;

package/dist/components/filters/filter-panels/filter-panel-with-field-select.d.ts

@@ -0,0 +1,10 @@
+import FilterPanelHeaderFactory from 'components/side-panel/filter-panel/filter-panel-header';
+import PanelHeaderActionFactory from 'components/side-panel/panel-header-action';
+import SourceDataSelectorFactory from 'components/side-panel/common/source-data-selector';
+import FieldSelectorFactory from '../../common/field-selector';
+import { FilterPanelWithFieldSelectComponent } from './types';
+declare function FieldPanelWithFieldSelectFactory(FilterPanelHeader: ReturnType<typeof FilterPanelHeaderFactory>, SourceDataSelector: ReturnType<typeof SourceDataSelectorFactory>, FieldSelector: ReturnType<typeof FieldSelectorFactory>, PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): FilterPanelWithFieldSelectComponent;
+declare namespace FieldPanelWithFieldSelectFactory {
+    var deps: (typeof FilterPanelHeaderFactory | typeof SourceDataSelectorFactory | typeof FieldSelectorFactory | typeof PanelHeaderActionFactory)[];
+}
+export default FieldPanelWithFieldSelectFactory;

package/dist/components/filters/filter-panels/multi-select-filter-panel.d.ts

@@ -0,0 +1,9 @@
+import MultiSelectFilterFactory from 'components/filters/multi-select-filter';
+import { MultiSelectFilter } from 'reducers';
+import FieldPanelWithFieldSelectFactory from 'components/filters/filter-panels/filter-panel-with-field-select';
+import { FilterPanelComponent } from './types';
+declare function MultiSelectFilterPanelFactory(FieldPanelWithFieldSelect: ReturnType<typeof FieldPanelWithFieldSelectFactory>, MultiSelectFilter: ReturnType<typeof MultiSelectFilterFactory>): FilterPanelComponent<MultiSelectFilter>;
+declare namespace MultiSelectFilterPanelFactory {
+    var deps: (typeof FieldPanelWithFieldSelectFactory | typeof MultiSelectFilterFactory)[];
+}
+export default MultiSelectFilterPanelFactory;

package/dist/components/filters/filter-panels/new-filter-panel.d.ts

@@ -0,0 +1,12 @@
+import FilterPanelHeaderFactory from 'components/side-panel/filter-panel/filter-panel-header';
+import SourceDataSelectorFactory from 'components/side-panel/common/source-data-selector';
+import FieldSelectorFactory from '../../common/field-selector';
+import { FilterBase } from 'reducers';
+import { FilterPanelComponent } from './types';
+import KeplerTable, { Field } from 'utils/table-utils/kepler-table';
+export declare function getSupportedFilterFields(supportedFilterTypes: KeplerTable['supportedFilterTypes'], fields: Field[]): Field[];
+declare function NewFilterPanelFactory(FilterPanelHeader: ReturnType<typeof FilterPanelHeaderFactory>, SourceDataSelector: ReturnType<typeof SourceDataSelectorFactory>, FieldSelector: ReturnType<typeof FieldSelectorFactory>): FilterPanelComponent<FilterBase>;
+declare namespace NewFilterPanelFactory {
+    var deps: (typeof FilterPanelHeaderFactory | typeof SourceDataSelectorFactory | typeof FieldSelectorFactory)[];
+}
+export default NewFilterPanelFactory;

package/dist/components/filters/filter-panels/polygon-filter-panel.d.ts

@@ -0,0 +1,9 @@
+import PolygonFilterFactory from 'components/filters/polygon-filter';
+import PanelHeaderActionFactory from 'components/side-panel/panel-header-action';
+import FilterPanelHeaderFactory from 'components/side-panel/filter-panel/filter-panel-header';
+import { PolygonFilterPanelComponent } from './types';
+declare function PolygonFilterPanelFactory(FilterPanelHeader: ReturnType<typeof FilterPanelHeaderFactory>, PolygonFilter: ReturnType<typeof PolygonFilterFactory>, PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): PolygonFilterPanelComponent;
+declare namespace PolygonFilterPanelFactory {
+    var deps: (typeof FilterPanelHeaderFactory | typeof PolygonFilterFactory | typeof PanelHeaderActionFactory)[];
+}
+export default PolygonFilterPanelFactory;

package/dist/components/filters/filter-panels/range-filter-panel.d.ts

@@ -0,0 +1,9 @@
+import RangeFilterFactory from 'components/filters/range-filter';
+import { RangeFilter } from 'reducers';
+import FieldPanelWithFieldSelectFactory from 'components/filters/filter-panels/filter-panel-with-field-select';
+import { FilterPanelComponent } from './types';
+declare function RangeFilterPanelFactory(FieldPanelWithFieldSelect: ReturnType<typeof FieldPanelWithFieldSelectFactory>, RangeFilter: ReturnType<typeof RangeFilterFactory>): FilterPanelComponent<RangeFilter>;
+declare namespace RangeFilterPanelFactory {
+    var deps: (typeof FieldPanelWithFieldSelectFactory | typeof RangeFilterFactory)[];
+}
+export default RangeFilterPanelFactory;

package/dist/components/filters/filter-panels/single-select-filter-panel.d.ts

@@ -0,0 +1,9 @@
+import SingleSelectFilterFactory from 'components/filters/single-select-filter';
+import { SelectFilter } from 'reducers';
+import FieldPanelWithFieldSelectFactory from 'components/filters/filter-panels/filter-panel-with-field-select';
+import { FilterPanelComponent } from './types';
+declare function SingleSelectFilterPanelFactory(FieldPanelWithFieldSelect: ReturnType<typeof FieldPanelWithFieldSelectFactory>, SingleSelectFilter: ReturnType<typeof SingleSelectFilterFactory>): FilterPanelComponent<SelectFilter>;
+declare namespace SingleSelectFilterPanelFactory {
+    var deps: (typeof FieldPanelWithFieldSelectFactory | typeof SingleSelectFilterFactory)[];
+}
+export default SingleSelectFilterPanelFactory;

package/dist/components/filters/filter-panels/time-range-filter-panel.d.ts

@@ -0,0 +1,8 @@
+import TimeRangeFilterFactory from 'components/filters/time-range-filter';
+import FieldPanelWithFieldSelectFactory from 'components/filters/filter-panels/filter-panel-with-field-select';
+import { TimeRangeFilterPanelComponent } from './types';
+declare function TimeRangeFilterPanelFactory(FieldPanelWithFieldSelect: ReturnType<typeof FieldPanelWithFieldSelectFactory>, TimeRangeFilter: ReturnType<typeof TimeRangeFilterFactory>): TimeRangeFilterPanelComponent;
+declare namespace TimeRangeFilterPanelFactory {
+    var deps: (typeof FieldPanelWithFieldSelectFactory | typeof TimeRangeFilterFactory)[];
+}
+export default TimeRangeFilterPanelFactory;

package/dist/components/filters/filter-panels/types.d.ts

@@ -0,0 +1,36 @@
+import { FunctionComponent, ComponentType } from 'react';
+import { Datasets, Filter, PolygonFilter, TimeRangeFilter } from 'reducers';
+import { Layer } from 'layers';
+import { Field } from 'utils/table-utils/kepler-table';
+interface PanelAction {
+    id: string;
+    tooltip: string;
+    onClick: () => void;
+    iconComponent: ComponentType;
+    active: boolean;
+}
+export interface FilterPanelProps<F = Filter> {
+    idx: number;
+    datasets: Datasets;
+    allAvailableFields: Field[];
+    filter: F;
+    removeFilter: () => void;
+    setFilter: (idx: number, field: string, value: any) => void;
+}
+export interface PolygonFilterPanelProps extends FilterPanelProps<PolygonFilter> {
+    layers: ReadonlyArray<Layer>;
+    toggleFilterFeature: () => void;
+}
+export interface TimeRangeFilterPanelProps extends FilterPanelProps<TimeRangeFilter> {
+    enlargeFilter: () => void;
+    toggleAnimation: () => void;
+}
+export interface FilterPanelWithFieldSelectProps extends FilterPanelProps {
+    children?: React.ReactNode;
+    panelActions?: ReadonlyArray<PanelAction>;
+}
+export type FilterPanelComponent<F> = FunctionComponent<FilterPanelProps<F>>;
+export type PolygonFilterPanelComponent = FunctionComponent<PolygonFilterPanelProps>;
+export type TimeRangeFilterPanelComponent = FunctionComponent<TimeRangeFilterPanelProps>;
+export type FilterPanelWithFieldSelectComponent = FunctionComponent<FilterPanelWithFieldSelectProps>;
+export {};