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

package/dist/layers/heatmap-layer/heatmap-layer.d.ts

@@ -0,0 +1,144 @@
+import MapboxGLLayer, { MapboxLayerGLConfig } from '../mapboxgl-layer';
+import HeatmapLayerIcon from './heatmap-layer-icon';
+import { LayerColumn, LayerWeightConfig, VisualChannels } from '../base-layer';
+import { DataContainerInterface } from 'utils/table-utils/data-container-interface';
+import { VisConfigColorRange, VisConfigNumber } from '../layer-factory';
+import { ColorRange } from 'constants/color-ranges';
+import { Merge } from 'reducers';
+export type HeatmapLayerVisConfigSettings = {
+    opacity: VisConfigNumber;
+    colorRange: VisConfigColorRange;
+    radius: VisConfigNumber;
+};
+export type HeatmapLayerColumnsConfig = {
+    lat: LayerColumn;
+    lng: LayerColumn;
+};
+export type HeatmapLayerVisConfig = {
+    opacity: number;
+    colorRange: ColorRange;
+    radius: number;
+};
+export type HeatmapLayerVisualChannelConfig = LayerWeightConfig;
+export type HeatmapLayerConfig = Merge<MapboxLayerGLConfig, {
+    columns: HeatmapLayerColumnsConfig;
+    visConfig: HeatmapLayerVisConfig;
+}> & HeatmapLayerVisualChannelConfig;
+export declare const MAX_ZOOM_LEVEL = 18;
+export declare const pointPosAccessor: ({ lat, lng }: HeatmapLayerColumnsConfig) => (dc: DataContainerInterface) => (d: any) => any[];
+export declare const pointColResolver: ({ lat, lng }: HeatmapLayerColumnsConfig) => string;
+export declare const heatmapVisConfigs: {
+    opacity: 'opacity';
+    colorRange: 'colorRange';
+    radius: 'heatmapRadius';
+};
+declare class HeatmapLayer extends MapboxGLLayer {
+    visConfigSettings: HeatmapLayerVisConfigSettings;
+    config: HeatmapLayerConfig;
+    getPosition: (config: HeatmapLayerColumnsConfig) => any;
+    constructor(props: any);
+    get type(): 'heatmap';
+    get visualChannels(): VisualChannels;
+    get layerIcon(): typeof HeatmapLayerIcon;
+    getVisualChannelDescription(channel: any): {
+        label: string;
+        measure: string;
+    };
+    getDefaultLayerConfig(props?: {}): HeatmapLayerConfig;
+    getPositionAccessor(dataContainer: any): any;
+    updateLayerMeta(dataContainer: any): void;
+    columnsSelector: (config: any) => string;
+    visConfigSelector: (config: any) => any;
+    weightFieldSelector: (config: any) => any;
+    weightDomainSelector: (config: any) => any;
+    paintSelector: ((state: any) => {
+        'heatmap-weight': number | any[];
+        'heatmap-intensity': (string | number | string[])[];
+        'heatmap-color': (string | number | string[])[];
+        'heatmap-radius': any[];
+        'heatmap-opacity': any;
+    }) & import("reselect").OutputSelectorFields<(args_0: any, args_1: any, args_2: any) => {
+        'heatmap-weight': number | any[];
+        'heatmap-intensity': (string | number | string[])[];
+        'heatmap-color': (string | number | string[])[];
+        'heatmap-radius': any[];
+        'heatmap-opacity': any;
+    }, {
+        clearCache: () => void;
+    }> & {
+        clearCache: () => void;
+    };
+    computeHeatmapConfiguration: ((state: any, datasets: any) => {
+        filter?: unknown;
+        type: string;
+        id: string;
+        source: string;
+        layout: {
+            visibility: string;
+        };
+        maxzoom: number;
+        paint: {
+            'heatmap-weight': number | any[];
+            'heatmap-intensity': (string | number | string[])[];
+            'heatmap-color': (string | number | string[])[];
+            'heatmap-radius': any[];
+            'heatmap-opacity': any;
+        };
+    }) & import("reselect").OutputSelectorFields<(args_0: string, args_1: unknown, args_2: {
+        'heatmap-weight': number | any[];
+        'heatmap-intensity': (string | number | string[])[];
+        'heatmap-color': (string | number | string[])[];
+        'heatmap-radius': any[];
+        'heatmap-opacity': any;
+    }) => {
+        filter?: unknown;
+        type: string;
+        id: string;
+        source: string;
+        layout: {
+            visibility: string;
+        };
+        maxzoom: number;
+        paint: {
+            'heatmap-weight': number | any[];
+            'heatmap-intensity': (string | number | string[])[];
+            'heatmap-color': (string | number | string[])[];
+            'heatmap-radius': any[];
+            'heatmap-opacity': any;
+        };
+    }, {
+        clearCache: () => void;
+    }> & {
+        clearCache: () => void;
+    };
+    formatLayerData(datasets: any, oldLayerData: any): {
+        columns?: undefined;
+        config?: undefined;
+        data?: undefined;
+        weightField?: undefined;
+        getPosition?: undefined;
+    } | {
+        columns: HeatmapLayerColumnsConfig;
+        config: {
+            filter?: unknown;
+            type: string;
+            id: string;
+            source: string;
+            layout: {
+                visibility: string;
+            };
+            maxzoom: number;
+            paint: {
+                'heatmap-weight': number | any[];
+                'heatmap-intensity': (string | number | string[])[];
+                'heatmap-color': (string | number | string[])[];
+                'heatmap-radius': any[];
+                'heatmap-opacity': any;
+            };
+        };
+        data: any[];
+        weightField: import("../../utils/table-utils/kepler-table").Field;
+        getPosition: any;
+    };
+}
+export default HeatmapLayer;

package/dist/layers/hexagon-layer/hexagon-layer-icon.d.ts

@@ -0,0 +1,15 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+export default class HexagonLayerIcon extends Component {
+    static propTypes: {
+        /** Set the height of the icon, ex. '16px' */
+        height: PropTypes.Requireable<string>;
+        colors: PropTypes.Requireable<string[]>;
+    };
+    static defaultProps: {
+        height: string;
+        predefinedClassName: string;
+        totalColor: number;
+    };
+    render(): React.JSX.Element;
+}

package/dist/layers/hexagon-layer/hexagon-layer.d.ts

@@ -0,0 +1,78 @@
+import { GeoJsonLayer } from '@deck.gl/layers';
+import AggregationLayer, { AggregationLayerConfig } from '../aggregation-layer';
+import EnhancedHexagonLayer from 'deckgl-layers/hexagon-layer/enhanced-hexagon-layer';
+import HexagonLayerIcon from './hexagon-layer-icon';
+import { Merge } from '../../reducers';
+import { AggregationTypes, VisConfigBoolean, VisConfigColorRange, VisConfigNumber, VisConfigRange, VisConfigSelection } from '../layer-factory';
+import { ColorRange } from '../../constants/color-ranges';
+export type HexagonLayerVisConfigSettings = {
+    opacity: VisConfigNumber;
+    worldUnitSize: VisConfigNumber;
+    resolution: VisConfigNumber;
+    colorRange: VisConfigColorRange;
+    coverage: VisConfigNumber;
+    sizeRange: VisConfigRange;
+    percentile: VisConfigRange;
+    elevationPercentile: VisConfigRange;
+    elevationScale: VisConfigNumber;
+    enableElevationZoomFactor: VisConfigBoolean;
+    colorAggregation: VisConfigSelection;
+    sizeAggregation: VisConfigSelection;
+    enable3d: VisConfigBoolean;
+};
+export type HexagonLayerVisConfig = {
+    opacity: number;
+    worldUnitSize: number;
+    resolution: number;
+    colorRange: ColorRange;
+    coverage: number;
+    sizeRange: [number, number];
+    percentile: [number, number];
+    elevationPercentile: [number, number];
+    elevationScale: number;
+    enableElevationZoomFactor: boolean;
+    colorAggregation: AggregationTypes;
+    sizeAggregation: AggregationTypes;
+    enable3d: boolean;
+};
+export type HexagonLayerConfig = Merge<AggregationLayerConfig, {
+    visConfig: HexagonLayerVisConfig;
+}>;
+export declare const hexagonVisConfigs: {
+    opacity: 'opacity';
+    worldUnitSize: 'worldUnitSize';
+    resolution: 'resolution';
+    colorRange: 'colorRange';
+    coverage: 'coverage';
+    sizeRange: 'elevationRange';
+    percentile: 'percentile';
+    elevationPercentile: 'elevationPercentile';
+    elevationScale: 'elevationScale';
+    enableElevationZoomFactor: 'enableElevationZoomFactor';
+    colorAggregation: 'colorAggregation';
+    sizeAggregation: 'sizeAggregation';
+    enable3d: 'enable3d';
+};
+export default class HexagonLayer extends AggregationLayer {
+    visConfigSettings: HexagonLayerVisConfigSettings;
+    config: HexagonLayerConfig;
+    constructor(props: any);
+    get type(): string;
+    get name(): string;
+    get layerIcon(): typeof HexagonLayerIcon;
+    renderLayer(opts: any): (EnhancedHexagonLayer | GeoJsonLayer<any, {
+        wrapLongitude: false;
+        data: {
+            geometry: {
+                coordinates: any[];
+                type: string;
+            };
+            properties: any;
+        }[];
+        getLineColor: import("../../reducers").RGBColor | import("../../reducers").RGBAColor;
+        lineWidthScale: number;
+        id: string;
+        pickable: boolean;
+        coordinateSystem: 1;
+    }>)[];
+}

package/dist/layers/hexagon-layer/hexagon-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function hexagonToPolygonGeo(object: any, properties: any, radius: any, mapState: any): {
+    geometry: {
+        coordinates: any[];
+        type: string;
+    };
+    properties: any;
+};

package/dist/layers/icon-layer/icon-info-modal.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const IconInfoModalFactory: (svgIcons?: any[]) => () => React.JSX.Element;
+export default IconInfoModalFactory;

package/dist/layers/icon-layer/icon-layer-icon.d.ts

@@ -0,0 +1,15 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+export default class IconLayerIcon extends Component {
+    static propTypes: {
+        /** Set the height of the icon, ex. '16px' */
+        height: PropTypes.Requireable<string>;
+        colors: PropTypes.Requireable<string[]>;
+    };
+    static defaultProps: {
+        height: string;
+        predefinedClassName: string;
+        totalColor: number;
+    };
+    render(): React.JSX.Element;
+}

package/dist/layers/icon-layer/icon-layer.d.ts

@@ -0,0 +1,119 @@
+/// <reference types="react" />
+import IconLayerIcon from './icon-layer-icon';
+import Layer, { LayerBaseConfig, LayerColumn } from '../base-layer';
+import { DataContainerInterface } from '../../utils/table-utils/data-container-interface';
+import { VisConfigBoolean, VisConfigColorRange, VisConfigNumber, VisConfigRange } from '../layer-factory';
+import { ColorRange } from '../../constants/color-ranges';
+import { Merge } from '../../reducers';
+import { KeplerTable } from '../../utils';
+export type IconLayerColumnsConfig = {
+    lat: LayerColumn;
+    lng: LayerColumn;
+    altitude: LayerColumn;
+    icon: LayerColumn;
+};
+type IconGeometry = {} | null;
+export type IconLayerVisConfigSettings = {
+    radius: VisConfigNumber;
+    fixedRadius: VisConfigBoolean;
+    opacity: VisConfigNumber;
+    colorRange: VisConfigColorRange;
+    radiusRange: VisConfigRange;
+};
+export type IconLayerVisConfig = {
+    radius: number;
+    fixedRadius: boolean;
+    opacity: number;
+    colorRange: ColorRange;
+    radiusRange: [number, number];
+};
+export type IconLayerConfig = Merge<LayerBaseConfig, {
+    columns: IconLayerColumnsConfig;
+    visConfig: IconLayerVisConfig;
+}>;
+export type IconLayerData = {
+    index: number;
+    icon: string;
+};
+export declare const SVG_ICON_URL: string;
+export declare const iconPosAccessor: ({ lat, lng, altitude }: IconLayerColumnsConfig) => (dc: DataContainerInterface) => (d: any) => any[];
+export declare const iconAccessor: ({ icon }: IconLayerColumnsConfig) => (dc: DataContainerInterface) => (d: any) => any;
+export declare const iconRequiredColumns: ['lat', 'lng', 'icon'];
+export declare const iconOptionalColumns: ['altitude'];
+export declare const pointVisConfigs: {
+    radius: 'radius';
+    fixedRadius: 'fixedRadius';
+    opacity: 'opacity';
+    colorRange: 'colorRange';
+    radiusRange: 'radiusRange';
+};
+export default class IconLayer extends Layer {
+    getIconAccessor: (dataContainer: DataContainerInterface) => (d: any) => any;
+    _layerInfoModal: () => JSX.Element;
+    iconGeometry: IconGeometry;
+    visConfigSettings: IconLayerVisConfigSettings;
+    config: IconLayerConfig;
+    constructor(props?: {
+        id?: string;
+        iconGeometry?: IconGeometry;
+    } & Partial<LayerBaseConfig>);
+    get type(): 'icon';
+    get requiredLayerColumns(): ["lat", "lng", "icon"];
+    get optionalColumns(): ["altitude"];
+    get columnPairs(): import("../base-layer").ColumnPairs;
+    get layerIcon(): typeof IconLayerIcon;
+    get visualChannels(): {
+        color: {
+            accessor: string;
+            defaultValue: (config: any) => any;
+            property: string;
+            field: string;
+            scale: string;
+            domain: string;
+            range: string;
+            key: string;
+            channelScaleType: string;
+            nullValue?: any;
+            defaultMeasure?: any;
+            condition?: (config: any) => boolean;
+            getAttributeValue?: (config: any) => (d: any) => any;
+            fixed?: any;
+            supportedFieldTypes?: ("string" | "boolean" | "date" | "geojson" | "integer" | "real" | "timestamp" | "point")[];
+            aggregation?: import("../base-layer").VisualChannelAggregation;
+        };
+        size: {
+            property: string;
+            range: string;
+            channelScaleType: string;
+            accessor: string;
+            defaultValue: number;
+            field: string;
+            scale: string;
+            domain: string;
+            key: string;
+            nullValue?: any;
+            defaultMeasure?: any;
+            condition?: (config: any) => boolean;
+            getAttributeValue?: (config: any) => (d: any) => any;
+            fixed?: any;
+            supportedFieldTypes?: ("string" | "boolean" | "date" | "geojson" | "integer" | "real" | "timestamp" | "point")[];
+            aggregation?: import("../base-layer").VisualChannelAggregation;
+        };
+    };
+    get layerInfoModal(): {
+        id: string;
+        template: () => JSX.Element;
+        modalProps: {
+            title: string;
+        };
+    };
+    getSvgIcons(): void;
+    static findDefaultLayerProps({ fieldPairs, fields }: KeplerTable): {
+        props: any[];
+    };
+    calculateDataAttribute({ dataContainer, filteredIndex }: KeplerTable, getPosition: any): IconLayerData[];
+    formatLayerData(datasets: any, oldLayerData: any): {};
+    updateLayerMeta(dataContainer: any, getPosition: any): void;
+    renderLayer(opts: any): any[];
+}
+export {};

package/dist/layers/index.d.ts

@@ -0,0 +1,53 @@
+import { default as PointLayer } from './point-layer/point-layer';
+import { default as ArcLayer } from './arc-layer/arc-layer';
+import { default as LineLayer } from './line-layer/line-layer';
+import { default as GridLayer } from './grid-layer/grid-layer';
+import { default as HexagonLayer } from './hexagon-layer/hexagon-layer';
+import { default as GeojsonLayer } from './geojson-layer/geojson-layer';
+import { default as ClusterLayer } from './cluster-layer/cluster-layer';
+import { default as IconLayer } from './icon-layer/icon-layer';
+import { default as HeatmapLayer } from './heatmap-layer/heatmap-layer';
+import { default as H3Layer } from './h3-hexagon-layer/h3-hexagon-layer';
+import { default as ScenegraphLayer } from './scenegraph-layer/scenegraph-layer';
+import { default as TripLayer } from './trip-layer/trip-layer';
+import { default as S2GeometryLayer } from './s2-geometry-layer/s2-geometry-layer';
+import IconInfoModalFactory from './icon-layer/icon-info-modal';
+export { default as Layer, OVERLAY_TYPE, LAYER_ID_LENGTH, colorMaker } from './base-layer';
+export type { LayerBaseConfig, LayerColumns, LayerColumn, UpdateTrigger, UpdateTriggers } from './base-layer';
+export declare const KeplerGlLayers: {
+    PointLayer: typeof PointLayer;
+    ArcLayer: typeof ArcLayer;
+    LineLayer: typeof LineLayer;
+    GridLayer: typeof GridLayer;
+    HexagonLayer: typeof HexagonLayer;
+    GeojsonLayer: typeof GeojsonLayer;
+    ClusterLayer: typeof ClusterLayer;
+    IconLayer: typeof IconLayer;
+    HeatmapLayer: typeof HeatmapLayer;
+    H3Layer: typeof H3Layer;
+    ScenegraphLayer: typeof ScenegraphLayer;
+    TripLayer: typeof TripLayer;
+    S2GeometryLayer: typeof S2GeometryLayer;
+};
+export type LayerClassesType = typeof LayerClasses;
+export declare const LayerClasses: {
+    point: typeof PointLayer;
+    arc: typeof ArcLayer;
+    line: typeof LineLayer;
+    grid: typeof GridLayer;
+    hexagon: typeof HexagonLayer;
+    geojson: typeof GeojsonLayer;
+    cluster: typeof ClusterLayer;
+    icon: typeof IconLayer;
+    heatmap: typeof HeatmapLayer;
+    hexagonId: typeof H3Layer;
+    "3D": typeof ScenegraphLayer;
+    trip: typeof TripLayer;
+    s2: typeof S2GeometryLayer;
+};
+export type OVERLAY_TYPE = {
+    [key: string]: string;
+};
+export { LAYER_VIS_CONFIGS } from './layer-factory';
+export type { LayerVisConfig } from './layer-factory';
+export { IconInfoModalFactory };

package/dist/layers/layer-factory.d.ts

@@ -0,0 +1,150 @@
+import { AGGREGATION_TYPES } from '../constants/default-settings';
+import { ColorRange, DEFAULT_COLOR_RANGE } from '../constants/color-ranges';
+import { RGBColor, RGBAColor } from '../reducers';
+import { Field } from '../utils/table-utils/kepler-table';
+import { LayerBaseConfig, LayerColorConfig, LayerHeightConfig, LayerSizeConfig, LayerWeightConfig } from './base-layer';
+export type LayerTextLabel = {
+    field: Field | null;
+    color: RGBColor;
+    size: number;
+    offset: [number, number];
+    anchor: string;
+    alignment: string;
+    outlineColor: RGBColor;
+};
+export type AggregationTypes = keyof typeof AGGREGATION_TYPES;
+export type ColorUI = {
+    customPalette: ColorRange;
+    showSketcher: boolean | number;
+    showDropdown: boolean | number;
+    colorRangeConfig: {
+        type: string;
+        steps: number;
+        reversed: boolean;
+        custom: boolean;
+        hexColumn: string;
+        isHexColumn: boolean;
+    };
+};
+export type VisConfig = {
+    label: string | ((config: LayerBaseConfig & Partial<LayerColorConfig> & Partial<LayerHeightConfig> & Partial<LayerSizeConfig> & Partial<LayerWeightConfig>) => string);
+    group: keyof typeof PROPERTY_GROUPS;
+    property: string;
+    description?: string;
+    condition?: (config: LayerBaseConfig & Partial<LayerColorConfig> & Partial<LayerHeightConfig> & Partial<LayerSizeConfig> & Partial<LayerWeightConfig>) => boolean;
+    allowCustomValue?: boolean;
+};
+export type VisConfigNumber = VisConfig & {
+    type: 'number';
+    isRanged: false;
+    defaultValue: number;
+    range: [number, number];
+    step: number;
+};
+export type VisConfigBoolean = VisConfig & {
+    type: 'boolean';
+    defaultValue: boolean;
+};
+export type VisConfigSelection = VisConfig & {
+    type: 'select';
+    defaultValue: string;
+    options: string[];
+};
+export type VisConfigRange = VisConfig & {
+    type: 'number';
+    isRanged: boolean;
+    range: [number, number];
+    defaultValue: [number, number];
+    step: number;
+};
+export type VisConfigColorSelect = VisConfig & {
+    type: 'color-select';
+    defaultValue: null;
+};
+export type VisConfigColorRange = VisConfig & {
+    type: 'color-range-select';
+    defaultValue: ColorRange;
+};
+export type LayerVisConfigSettings = {
+    thickness: VisConfigNumber;
+    strokeWidthRange: VisConfigRange;
+    trailLength: VisConfigNumber;
+    radius: VisConfigNumber;
+    fixedRadius: VisConfigBoolean;
+    radiusRange: VisConfigRange;
+    clusterRadius: VisConfigNumber;
+    clusterRadiusRange: VisConfigRange;
+    opacity: VisConfigNumber;
+    coverage: VisConfigNumber;
+    outline: VisConfigBoolean;
+    colorRange: VisConfigColorRange;
+    strokeColorRange: VisConfigColorRange;
+    targetColor: VisConfigColorSelect;
+    strokeColor: VisConfigColorSelect;
+    colorAggregation: VisConfigSelection;
+    sizeAggregation: VisConfigSelection;
+    percentile: VisConfigRange;
+    elevationPercentile: VisConfigRange;
+    resolution: VisConfigNumber;
+    sizeScale: VisConfigNumber;
+    angle: VisConfigNumber;
+    worldUnitSize: VisConfigNumber;
+    elevationScale: VisConfigNumber;
+    enableElevationZoomFactor: VisConfigBoolean;
+    elevationRange: VisConfigRange;
+    heightRange: VisConfigRange;
+    coverageRange: VisConfigRange;
+    'hi-precision': VisConfigBoolean;
+    enable3d: VisConfigBoolean;
+    stroked: VisConfigBoolean;
+    filled: VisConfigBoolean;
+    extruded: VisConfigBoolean;
+    wireframe: VisConfigBoolean;
+    weight: VisConfigNumber;
+    heatmapRadius: VisConfigNumber;
+};
+export type LayerVisConfig = {
+    [key: string]: any;
+};
+export type TextConfigSelect = {
+    type: 'select';
+    options: string[];
+    multiSelect: boolean;
+    searchable: boolean;
+};
+export type TextConfigNumber = {
+    type: 'number';
+    range: number[];
+    value0: number;
+    step: number;
+    isRanged: boolean;
+    label: string;
+    showInput: boolean;
+};
+export type LayerTextConfig = {
+    fontSize: TextConfigNumber;
+    textAnchor: TextConfigSelect;
+    textAlignment: TextConfigSelect;
+};
+export declare const PROPERTY_GROUPS: {
+    color: "color";
+    stroke: "stroke";
+    customMarkers: "customMarkers";
+    radius: "radius";
+    height: "height";
+    angle: "angle";
+    cell: "cell";
+    precision: "precision";
+    display: "display";
+};
+export declare const DEFAULT_LAYER_OPACITY = 0.8;
+export declare const DEFAULT_HIGHLIGHT_COLOR: RGBAColor;
+export declare const DEFAULT_LAYER_LABEL = "new layer";
+export { DEFAULT_COLOR_RANGE };
+export declare const DEFAULT_TEXT_LABEL: LayerTextLabel;
+export declare const DEFAULT_SECONDARY_TEXT_LABEL: LayerTextLabel;
+export declare const DEFAULT_CUSTOM_PALETTE: ColorRange;
+export declare const UNKNOWN_COLOR_KEY = "__unknownColor__";
+export declare const DEFAULT_COLOR_UI: ColorUI;
+export declare const LAYER_VIS_CONFIGS: LayerVisConfigSettings;
+export declare const LAYER_TEXT_CONFIGS: LayerTextConfig;

package/dist/layers/layer-text-label.d.ts

@@ -0,0 +1,7 @@
+export declare const defaultPadding = 20;
+export declare function getTextOffsetByRadius(radiusScale: any, getRadius: any): (textLabel: any) => ((d: any) => number[]) | number[];
+export declare const textLabelAccessor: (textLabel: any) => (dc: any) => (d: any) => string;
+export declare const formatTextLabelData: ({ textLabel, dataContainer }: {
+    textLabel: any;
+    dataContainer: any;
+}) => any;

package/dist/layers/layer-update.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {Object} updateTriggers {getPosition: {column}, getData: {filteredIndex}}
+ * @param {Object} oldUpdateTriggers
+ * @returns {boolean|object} `false` if nothing changed, or `triggerChanged` as an object
+ */
+export declare function diffUpdateTriggers(updateTriggers: any, oldUpdateTriggers?: {}): false | {
+    [key: string]: true;
+};

package/dist/layers/line-layer/line-layer-icon.d.ts

@@ -0,0 +1,15 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+export default class LineLayerIcon extends Component {
+    static propTypes: {
+        /** Set the height of the icon, ex. '16px' */
+        height: PropTypes.Requireable<string>;
+        colors: PropTypes.Requireable<string[]>;
+    };
+    static defaultProps: {
+        height: string;
+        predefinedClassName: string;
+        totalColor: number;
+    };
+    render(): React.JSX.Element;
+}