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

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

@@ -0,0 +1,101 @@
+import React, { MouseEvent } from 'react';
+import SingleColorPaletteFactory from 'components/side-panel/layer-panel/single-color-palette';
+import ColorRangeSelectFactory from './color-range-selector';
+import { ColorUI } from 'layers/layer-factory';
+import { ColorRange } from 'constants/color-ranges';
+import { NestedPartial, RGBColor } from 'reducers';
+type ColorSelectorInputProps = {
+    active: boolean;
+    disabled?: boolean;
+    inputTheme?: string;
+};
+type ColorSelectorProps = {
+    fields?: any[];
+    colorSets: {
+        selectedColor: RGBColor | ColorRange;
+        setColor: ((v: RGBColor) => void) | ((v: ColorRange) => void);
+        isRange?: boolean;
+        label?: string;
+    }[];
+    colorUI?: ColorUI;
+    inputTheme?: string;
+    disabled?: boolean;
+    setColorUI?: (newConfig: NestedPartial<ColorUI>) => void;
+};
+export declare const ColorBlock: import("styled-components").StyledComponent<"div", any, {
+    backgroundColor: RGBColor;
+}, never>;
+export declare const ColorSelectorInput: import("styled-components").StyledComponent<"div", any, ColorSelectorInputProps, never>;
+export declare const InputBoxContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+declare function ColorSelectorFactory(SingleColorPalette: any, ColorRangeSelector: any): import("react-onclickoutside").WrapperClass<ColorSelectorProps, {
+    new (props: ColorSelectorProps): {
+        state: {
+            showDropdown: boolean;
+        };
+        node: React.RefObject<HTMLDivElement>;
+        handleClickOutside: (e: any) => void;
+        _getEditing: () => number | boolean;
+        _closePanelDropdown: () => void;
+        _onSelectColor: (color: RGBColor | ColorRange, e: MouseEvent) => void;
+        _showDropdown: (e: any, i: any) => void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ColorSelectorProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<ColorSelectorProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ColorSelectorProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ColorSelectorProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ColorSelectorProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ColorSelectorProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ColorSelectorProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ColorSelectorProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ColorSelectorProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ColorSelectorProps, context: any): {
+        state: {
+            showDropdown: boolean;
+        };
+        node: React.RefObject<HTMLDivElement>;
+        handleClickOutside: (e: any) => void;
+        _getEditing: () => number | boolean;
+        _closePanelDropdown: () => void;
+        _onSelectColor: (color: RGBColor | ColorRange, e: MouseEvent) => void;
+        _showDropdown: (e: any, i: any) => void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ColorSelectorProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<ColorSelectorProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ColorSelectorProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ColorSelectorProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ColorSelectorProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ColorSelectorProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ColorSelectorProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ColorSelectorProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ColorSelectorProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    defaultProps: {
+        colorSets: any[];
+    };
+    contextType?: React.Context<any>;
+}>;
+declare namespace ColorSelectorFactory {
+    var deps: (typeof SingleColorPaletteFactory | typeof ColorRangeSelectFactory)[];
+}
+export default ColorSelectorFactory;

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

@@ -0,0 +1,22 @@
+import React from 'react';
+import FieldSelectorFactory from 'components/common/field-selector';
+import { LayerColumn, LayerColumns } from 'layers';
+import { Field, FieldPair } from 'utils/table-utils/kepler-table';
+type Pair = {
+    name: string;
+    type: string;
+    pair: FieldPair['pair'];
+};
+type ColumnSelectorProps = {
+    column: LayerColumn;
+    columns: LayerColumns;
+    label: string;
+    allFields: Field[];
+    onSelect: (items: ReadonlyArray<string | number | boolean | object> | string | number | boolean | object | null) => void;
+    fieldPairs?: Pair[] | null;
+};
+declare function ColumnSelectorFactory(FieldSelector: ReturnType<typeof FieldSelectorFactory>): React.FC<ColumnSelectorProps>;
+declare namespace ColumnSelectorFactory {
+    var deps: (typeof FieldSelectorFactory)[];
+}
+export default ColumnSelectorFactory;

package/dist/components/side-panel/layer-panel/custom-markers-config-group.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare function CustomMarkersConfigGroupFactory(): () => React.JSX.Element;
+declare namespace CustomMarkersConfigGroupFactory {
+    var deps: any[];
+}
+export default CustomMarkersConfigGroupFactory;

package/dist/components/side-panel/layer-panel/custom-palette.d.ts

@@ -0,0 +1,38 @@
+import React, { Component, MouseEventHandler, MouseEvent } from 'react';
+import { ColorRange } from 'constants/color-ranges';
+import { NestedPartial } from 'reducers';
+type CustomPaletteProps = {
+    customPalette: ColorRange;
+    showSketcher?: boolean | number;
+    setCustomPalette: (c: NestedPartial<ColorRange>) => void;
+    onCancel: () => void;
+    onToggleSketcher: (i: boolean | number) => void;
+    onApply: (p: ColorRange, e: MouseEvent) => void;
+};
+declare class CustomPalette extends Component<CustomPaletteProps> {
+    state: {
+        isSorting: boolean;
+    };
+    root: React.RefObject<HTMLDivElement>;
+    _setColorPaletteUI(colors: string[]): void;
+    _onPickerUpdate: (color: {
+        hex: string;
+    }) => void;
+    _onColorDelete: (index: number) => void;
+    _onColorAdd: () => void;
+    _onSwatchClick: (index: number) => void;
+    _onSwatchClose: () => void;
+    _onApply: MouseEventHandler;
+    _onSortEnd: ({ oldIndex, newIndex }: {
+        oldIndex: any;
+        newIndex: any;
+    }) => void;
+    _onSortStart: () => void;
+    _inputColorHex: (index: number, { target: { value } }: {
+        target: {
+            value: any;
+        };
+    }) => void;
+    render(): React.JSX.Element;
+}
+export default CustomPalette;

package/dist/components/side-panel/layer-panel/custom-picker.d.ts

@@ -0,0 +1,67 @@
+import React, { Component } from 'react';
+type SketchPickerValue = {
+    hsl: {
+        h: number;
+        s: number;
+        l: number;
+        a: number;
+    };
+    hex: string;
+    rgb: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    hsv: {
+        h: number;
+        s: number;
+        v: number;
+        a: number;
+    };
+    oldHue: number;
+    source: string;
+};
+type CustomPickerProps = {
+    color: string;
+    theme: {
+        panelBackground: string;
+    };
+    onChange: (v: SketchPickerValue) => void;
+    onSwatchClose: () => void;
+};
+declare class CustomPicker extends Component<CustomPickerProps> {
+    themeSelector: (props: CustomPickerProps) => {
+        panelBackground: string;
+    };
+    pickerStyleSelector: ((state: CustomPickerProps) => {
+        picker: {
+            width: string;
+            padding: string;
+            boxSizing: string;
+            background: string;
+        };
+    }) & import("reselect").OutputSelectorFields<(args_0: {
+        panelBackground: string;
+    }) => {
+        picker: {
+            width: string;
+            padding: string;
+            boxSizing: string;
+            background: string;
+        };
+    }, {
+        clearCache: () => void;
+    }> & {
+        clearCache: () => void;
+    };
+    handleClickOutside: (e: Event) => void;
+    render(): React.JSX.Element;
+}
+declare const _default: React.ForwardRefExoticComponent<{
+    ref?: React.LegacyRef<import("react-onclickoutside").WrapperInstance<CustomPickerProps, typeof CustomPicker>>;
+    key?: React.Key;
+} & {
+    theme?: any;
+}>;
+export default _default;

package/dist/components/side-panel/layer-panel/dataset-layer-group.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import DatasetLayerSectionFactory from './dataset-layer-section';
+import { Datasets } from 'reducers';
+import { Layer, LayerClassesType } from 'layers';
+import * as UiStateActions from 'actions/ui-state-actions';
+import * as VisStateActions from 'actions/vis-state-actions';
+import { ActionHandler } from 'actions';
+type DatasetLayerGroupProps = {
+    datasets: Datasets;
+    layers: Layer[];
+    layerOrder: number[];
+    layerClasses: LayerClassesType;
+    showDeleteDataset: boolean;
+    removeDataset: ActionHandler<typeof UiStateActions.openDeleteModal>;
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    uiStateActions: typeof UiStateActions;
+    visStateActions: typeof VisStateActions;
+};
+declare function DatasetLayerGroupFactory(DatasetLayerSection: ReturnType<typeof DatasetLayerSectionFactory>): React.FC<DatasetLayerGroupProps>;
+declare namespace DatasetLayerGroupFactory {
+    var deps: (typeof DatasetLayerSectionFactory)[];
+}
+export default DatasetLayerGroupFactory;

package/dist/components/side-panel/layer-panel/dataset-layer-section.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import SourceDataCatalogFactory from '../common/source-data-catalog';
+import LayerListFactory from './layer-list';
+import { Layer, LayerClassesType } from 'layers';
+import KeplerTable from 'utils/table-utils/kepler-table';
+import * as UiStateActions from 'actions/ui-state-actions';
+import * as VisStateActions from 'actions/vis-state-actions';
+import { ActionHandler } from 'actions';
+type DatasetLayerSectionProps = {
+    dataset: KeplerTable;
+    layers: Layer[];
+    layerOrder: number[];
+    layerClasses: LayerClassesType;
+    showDeleteDataset: boolean;
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    removeDataset: ActionHandler<typeof UiStateActions.openDeleteModal>;
+    uiStateActions: typeof UiStateActions;
+    visStateActions: typeof VisStateActions;
+};
+declare function DatasetLayerSectionFactory(SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>, LayerList: ReturnType<typeof LayerListFactory>): React.FC<DatasetLayerSectionProps>;
+declare namespace DatasetLayerSectionFactory {
+    var deps: (typeof SourceDataCatalogFactory | typeof LayerListFactory)[];
+}
+export default DatasetLayerSectionFactory;

package/dist/components/side-panel/layer-panel/dataset-section.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import SourceDataCatalogFactory from '../common/source-data-catalog';
+import { Datasets } from 'reducers';
+import * as UiStateActions from 'actions/ui-state-actions';
+import * as VisStateActions from 'actions/vis-state-actions';
+import { ActionHandler } from 'actions';
+type AddDataButtonProps = {
+    onClick: () => void;
+    isInactive: boolean;
+};
+type DatasetSectionProps = {
+    datasets: Datasets;
+    defaultDataset: string;
+    showDatasetList: boolean;
+    showDeleteDataset: boolean;
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    removeDataset: ActionHandler<typeof UiStateActions.openDeleteModal>;
+    showAddDataModal: () => void;
+};
+export declare function AddDataButtonFactory(): React.FC<AddDataButtonProps>;
+declare function DatasetSectionFactory(SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>, AddDataButton: ReturnType<typeof AddDataButtonFactory>): React.FC<DatasetSectionProps>;
+declare namespace DatasetSectionFactory {
+    var deps: (typeof SourceDataCatalogFactory | typeof AddDataButtonFactory)[];
+}
+export default DatasetSectionFactory;

package/dist/components/side-panel/layer-panel/dimension-scale-selector.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+type DimensionScaleSelectorProps = {
+    label: string;
+    onSelect: (val: readonly (string | number | boolean | object)[] | string | number | boolean | object | null) => void;
+    options: string[];
+    scaleType?: string;
+    disabled?: boolean;
+};
+declare const DimensionScaleSelector: React.FC<DimensionScaleSelectorProps>;
+export default DimensionScaleSelector;

package/dist/components/side-panel/layer-panel/hex-column-config.d.ts

@@ -0,0 +1,62 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+export type HexColumnConfigFactoryProps = {
+    onSelectColumn: Function;
+    fields?: any[];
+    value?: string;
+    iconComponent?: React.ReactNode;
+};
+export declare function HexColumnConfigFactory(): {
+    new (props: HexColumnConfigFactoryProps): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<HexColumnConfigFactoryProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<HexColumnConfigFactoryProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<HexColumnConfigFactoryProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<HexColumnConfigFactoryProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: HexColumnConfigFactoryProps, context: any): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<HexColumnConfigFactoryProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<HexColumnConfigFactoryProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<HexColumnConfigFactoryProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<HexColumnConfigFactoryProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        fields: PropTypes.Requireable<any[]>;
+        value: PropTypes.Requireable<string>;
+        onSelectColumn: PropTypes.Validator<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any>;
+};

package/dist/components/side-panel/layer-panel/layer-aggregation-resolution.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+declare function LayerAggregationResolutionFactory(): React.FC<import("react-intl").WithIntlProps<import("react-intl").WrappedComponentProps<any>>> & {
+    WrappedComponent: React.ComponentType<import("react-intl").WrappedComponentProps<any>>;
+};
+declare namespace LayerAggregationResolutionFactory {
+    var deps: any[];
+}
+export default LayerAggregationResolutionFactory;

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

@@ -0,0 +1,20 @@
+import React from 'react';
+import ColumnSelectorFactory from './column-selector';
+import { ColumnPairs } from 'layers/base-layer';
+import { Layer, LayerColumns, LayerBaseConfig } from 'layers';
+import { Field, FieldPair } from 'utils/table-utils/kepler-table';
+type LayerColumnConfigProps = {
+    columnPairs?: ColumnPairs | null;
+    fieldPairs?: FieldPair[];
+    columns: LayerColumns;
+    columnLabels?: Record<string, string>;
+    fields: Field[];
+    updateLayerConfig: (newConfig: Partial<LayerBaseConfig>) => void;
+    assignColumn: Layer['assignColumn'];
+    assignColumnPairs: Layer['assignColumnPairs'];
+};
+declare function LayerColumnConfigFactory(ColumnSelector: ReturnType<typeof ColumnSelectorFactory>): React.FC<LayerColumnConfigProps>;
+declare namespace LayerColumnConfigFactory {
+    var deps: (typeof ColumnSelectorFactory)[];
+}
+export default LayerColumnConfigFactory;

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

@@ -0,0 +1,37 @@
+import React from 'react';
+import InfoHelperFactory from 'components/common/info-helper';
+import { Layer, LayerVisConfig } from 'layers';
+type LayerConfigGroupLabelProps = {
+    label?: string;
+    description?: string;
+};
+type LayerConfigGroupProps = {
+    children?: React.ReactNode;
+    layer?: Layer;
+    label: string;
+    property?: string;
+    description?: string;
+    collapsible?: boolean;
+    expanded?: boolean;
+    disabled?: boolean;
+    onChange?: (newVisConfig: Partial<LayerVisConfig>) => void;
+    switchTooltip?: React.ReactNode;
+    CollapseButton?: any;
+};
+export declare const StyledLayerConfigGroupAction: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ConfigGroupCollapsibleContent: import("styled-components").StyledComponent<"div", any, {
+    className: "layer-config-group__content__collapsible";
+}, "className">;
+export declare const ConfigGroupCollapsibleHeader: import("styled-components").StyledComponent<"div", any, {
+    className: "layer-config-group__header__collapsible";
+}, "className">;
+export declare const StyledLayerConfigGroup: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare function LayerConfigGroupLabelFactory(InfoHelper: ReturnType<typeof InfoHelperFactory>): React.FC<LayerConfigGroupLabelProps>;
+export declare namespace LayerConfigGroupLabelFactory {
+    var deps: (typeof InfoHelperFactory)[];
+}
+declare function LayerConfigGroupFactory(LayerConfigGroupLabel: ReturnType<typeof LayerConfigGroupLabelFactory>): React.ComponentType<LayerConfigGroupProps>;
+declare namespace LayerConfigGroupFactory {
+    var deps: (typeof LayerConfigGroupLabelFactory)[];
+}
+export default LayerConfigGroupFactory;