kepler.gl/src/layers/dist/geojson-layer/geojson-layer.d.ts

kepler.gl is a webgl based application to visualize large scale location data in the browser

/// <reference types="react" />
import { Feature, Polygon } from 'geojson';
import Layer, { LayerBaseConfig, LayerBaseConfigPartial, LayerColorConfig, LayerHeightConfig, LayerRadiusConfig, LayerSizeConfig, LayerStrokeColorConfig } from '../base-layer';
import { GeojsonDataMaps, DeckGlGeoTypes, COLUMN_MODE_GEOJSON } from './geojson-utils';
import GeojsonLayerIcon from './geojson-layer-icon';
import { ColorRange, VisConfigNumber, VisConfigColorSelect, VisConfigColorRange, VisConfigRange, VisConfigBoolean, Merge, RGBColor, LayerColumn } from '@kepler.gl/types';
import { KeplerTable } from '@kepler.gl/table';
import { DataContainerInterface } from '@kepler.gl/utils';
export declare const geojsonVisConfigs: {
    opacity: 'opacity';
    strokeOpacity: VisConfigNumber;
    thickness: VisConfigNumber;
    strokeColor: 'strokeColor';
    colorRange: 'colorRange';
    strokeColorRange: 'strokeColorRange';
    radius: 'radius';
    sizeRange: 'strokeWidthRange';
    radiusRange: 'radiusRange';
    heightRange: 'elevationRange';
    elevationScale: 'elevationScale';
    stroked: 'stroked';
    filled: 'filled';
    enable3d: 'enable3d';
    wireframe: 'wireframe';
    fixedHeight: 'fixedHeight';
};
export declare type GeoJsonVisConfigSettings = {
    opacity: VisConfigNumber;
    strokeOpacity: VisConfigNumber;
    thickness: VisConfigNumber;
    strokeColor: VisConfigColorSelect;
    colorRange: VisConfigColorRange;
    strokeColorRange: VisConfigColorRange;
    radius: VisConfigNumber;
    sizeRange: VisConfigRange;
    radiusRange: VisConfigRange;
    heightRange: VisConfigRange;
    elevationScale: VisConfigNumber;
    fixedHeight: VisConfigBoolean;
    stroked: VisConfigBoolean;
    filled: VisConfigBoolean;
    enable3d: VisConfigBoolean;
    wireframe: VisConfigBoolean;
};
export declare type GeoJsonLayerColumnsConfig = {
    geojson: LayerColumn;
};
export declare type GeoJsonLayerVisConfig = {
    opacity: number;
    strokeOpacity: number;
    thickness: number;
    strokeColor: RGBColor;
    colorRange: ColorRange;
    strokeColorRange: ColorRange;
    radius: number;
    sizeRange: [number, number];
    radiusRange: [number, number];
    heightRange: [number, number];
    elevationScale: number;
    stroked: boolean;
    filled: boolean;
    enable3d: boolean;
    wireframe: boolean;
    fixedHeight: boolean;
};
declare type GeoJsonLayerVisualChannelConfig = LayerColorConfig & LayerStrokeColorConfig & LayerSizeConfig & LayerHeightConfig & LayerRadiusConfig;
export declare type GeoJsonLayerConfig = Merge<LayerBaseConfig, {
    columns: GeoJsonLayerColumnsConfig;
    visConfig: GeoJsonLayerVisConfig;
}> & GeoJsonLayerVisualChannelConfig;
export declare type GeoJsonLayerMeta = {
    featureTypes?: DeckGlGeoTypes;
    fixedRadius?: boolean;
};
export declare const geoJsonRequiredColumns: ['geojson'];
declare type ObjectInfo = {
    index: number;
    object?: Feature | undefined;
    picked: boolean;
    layer: Layer;
    radius?: number;
    id?: string;
};
export declare const featureAccessor: ({ geojson }: GeoJsonLayerColumnsConfig) => (dc: DataContainerInterface) => (d: any) => any;
export declare const defaultElevation = 500;
export declare const defaultLineWidth = 1;
export declare const defaultRadius = 1;
export declare const COLUMN_MODE_TABLE = "table";
export default class GeoJsonLayer extends Layer {
    config: GeoJsonLayerConfig;
    visConfigSettings: GeoJsonVisConfigSettings;
    meta: GeoJsonLayerMeta;
    geoArrowMode: boolean;
    dataToFeature: GeojsonDataMaps;
    dataContainer: DataContainerInterface | null;
    filteredIndex: Uint8ClampedArray | null;
    filteredIndexTrigger: number[] | null;
    centroids: Array<number[] | null>;
    _layerInfoModal: {
        [COLUMN_MODE_TABLE]: () => React.JSX.Element;
        [COLUMN_MODE_GEOJSON]: () => React.JSX.Element;
    };
    constructor(props: any);
    get type(): "geojson";
    static get type(): 'geojson';
    get name(): 'Polygon';
    get layerIcon(): typeof GeojsonLayerIcon;
    get columnPairs(): import("@kepler.gl/types").ColumnPairs;
    get supportedColumnModes(): ({
        key: string;
        label: string;
        requiredColumns: string[];
        optionalColumns?: undefined;
    } | {
        key: string;
        label: string;
        requiredColumns: string[];
        optionalColumns: string[];
    })[];
    get layerInfoModal(): {
        geojson: {
            id: string;
            template: () => import("react").JSX.Element;
            modalProps: {
                title: string;
            };
        };
        table: {
            id: string;
            template: () => import("react").JSX.Element;
            modalProps: {
                title: string;
            };
        };
    };
    accessVSFieldValue(): (field: any, d: any) => any;
    get visualChannels(): {
        color: {
            accessor: string;
            condition: (config: any) => any;
            nullValue: any;
            getAttributeValue: (config: any) => (d: any) => any;
            defaultValue: (config: any) => any;
            property: string;
            field: string;
            scale: string;
            domain: string;
            range: string;
            key: string;
            channelScaleType: string;
            defaultMeasure?: any;
            fixed?: any;
            supportedFieldTypes?: import("@kepler.gl/types").SupportedFieldTypes[] | undefined;
            aggregation?: import("@kepler.gl/types").VisualChannelAggregation | undefined;
        };
        strokeColor: {
            property: string;
            field: string;
            scale: string;
            domain: string;
            range: string;
            key: string;
            channelScaleType: "color";
            accessor: string;
            condition: (config: any) => any;
            nullValue: any;
            getAttributeValue: (config: any) => (d: any) => any;
            defaultValue: (config: any) => any;
        };
        size: {
            property: string;
            accessor: string;
            condition: (config: any) => any;
            nullValue: number;
            getAttributeValue: () => (d: any) => any;
            field: string;
            scale: string;
            domain: string;
            range: string;
            key: string;
            channelScaleType: string;
            defaultMeasure?: any;
            defaultValue?: any;
            fixed?: any;
            supportedFieldTypes?: import("@kepler.gl/types").SupportedFieldTypes[] | undefined;
            aggregation?: import("@kepler.gl/types").VisualChannelAggregation | undefined;
        };
        height: {
            property: string;
            field: string;
            scale: string;
            domain: string;
            range: string;
            key: string;
            fixed: string;
            channelScaleType: "size";
            accessor: string;
            condition: (config: any) => any;
            nullValue: number;
            getAttributeValue: () => (d: any) => any;
        };
        radius: {
            property: string;
            field: string;
            scale: string;
            domain: string;
            range: string;
            key: string;
            channelScaleType: "radius";
            accessor: string;
            nullValue: number;
            getAttributeValue: () => (d: any) => any;
        };
    };
    static findDefaultLayerProps({ label, fields }: KeplerTable): {
        props: {
            label: string;
            columns: any;
            isVisible: boolean;
        }[];
    };
    getDefaultLayerConfig(props: LayerBaseConfigPartial): {
        columnMode: string;
        heightField: null;
        heightDomain: number[];
        heightScale: string;
        radiusField: null;
        radiusDomain: number[];
        radiusScale: string;
        strokeColorField: null;
        strokeColorDomain: number[];
        strokeColorScale: string;
        colorUI: {
            strokeColorRange: import("@kepler.gl/types").ColorUI;
            color: import("@kepler.gl/types").ColorUI;
            colorRange: import("@kepler.gl/types").ColorUI;
        };
        dataId: string;
        label: string;
        color: RGBColor;
        columns: import("@kepler.gl/types").LayerColumns;
        isVisible: boolean;
        isConfigActive: boolean;
        highlightColor: RGBColor | import("@kepler.gl/types").RGBAColor;
        hidden: boolean;
        visConfig: import("@kepler.gl/types").LayerVisConfig;
        textLabel: import("@kepler.gl/types").LayerTextLabel[];
        animation: {
            enabled: boolean;
            domain?: [number, number] | null | undefined;
        };
        aggregatedBins?: import("@kepler.gl/types").AggregatedBin[] | undefined;
        colorField?: import("@kepler.gl/types").VisualChannelField | undefined;
        colorDomain?: import("@kepler.gl/types").VisualChannelDomain | undefined;
        colorScale?: string | number | symbol | undefined;
        sizeDomain?: import("@kepler.gl/types").VisualChannelDomain | undefined;
        sizeScale?: string | number | symbol | undefined;
        sizeField?: import("@kepler.gl/types").VisualChannelField | undefined;
    };
    getHoverData(object: any, dataContainer: any): any;
    getFilteredItemCount(): number | null;
    calculateDataAttribute(dataset: KeplerTable): any;
    formatLayerData(datasets: any, oldLayerData: any): {};
    isInPolygon(data: DataContainerInterface, index: number, polygon: Feature<Polygon>): boolean;
    updateLayerMeta(dataset: KeplerTable): void;
    setInitialLayerConfig(dataset: KeplerTable): this;
    isLayerHovered(objectInfo: ObjectInfo): boolean;
    hasHoveredObject(objectInfo: ObjectInfo): Feature | null;
    getElevationZoomFactor({ zoom, zoomOffset }: {
        zoom: any;
        zoomOffset?: number | undefined;
    }): number;
    renderLayer(opts: any): any[];
}
export {};