@maticoapp/deck.gl-pmtiles/dist/index.d.ts

This repo provides a typed Deck.gl layer and loader for PMTiles data. PMTiles data provides a serverless and compact way to store tile geospatial data. Combined with Deck.gl's rendering, this provides a flexible and powerful way to cheaply manage geospati

import * as geojson from 'geojson';
import { Feature } from 'geojson';
import { MVTLayer, TileLayerProps } from '@deck.gl/geo-layers/typed';
import { DefaultProps } from '@deck.gl/core/typed';
import { GeoJsonLayerProps } from '@deck.gl/layers/typed';
import { BinaryFeatures } from '@loaders.gl/schema';
import { Loader, LoaderWithParser } from '@loaders.gl/loader-utils';

type TileJson = {
    tilejson: string;
    tiles: string[];
    vector_layers: any[];
    attribution?: string;
    scheme?: string;
    maxzoom?: number;
    minzoom?: number;
    version?: string;
};
/** Props added by the MVTLayer  */
type _MVTLayerProps = {
    /** Called if `data` is a TileJSON URL when it is successfully fetched. */
    onDataLoad?: ((tilejson: TileJson | null) => void) | null;
    /** Needed for highlighting a feature split across two or more tiles. */
    uniqueIdProperty?: string;
    /** A feature with ID corresponding to the supplied value will be highlighted. */
    highlightedFeatureId?: string | null;
    /**
     * Use tile data in binary format.
     *
     * @default true
     */
    binary?: boolean;
    /**
     * Loaders used to transform tiles into `data` property passed to `renderSubLayers`.
     *
     * @default [MVTWorkerLoader] from `@loaders.gl/mvt`
     */
    loaders?: Loader[];
};
type GeoBoundingBox = {
    west: number;
    north: number;
    east: number;
    south: number;
};
type NonGeoBoundingBox = {
    left: number;
    top: number;
    right: number;
    bottom: number;
};
type TileBoundingBox = NonGeoBoundingBox | GeoBoundingBox;
type TileIndex = {
    x: number;
    y: number;
    z: number;
};
type TileLoadProps = {
    index: TileIndex;
    id: string;
    bbox: TileBoundingBox;
    url?: string | null;
    signal?: AbortSignal;
    userData?: Record<string, any>;
    zoom?: number;
};
type ParsedPmTile = Feature[] | BinaryFeatures;
type ExtraProps = {
    raster?: boolean;
};
type _PMTLayerProps = _MVTLayerProps & ExtraProps;
type PmtLayerProps<DataT extends Feature = Feature> = _PMTLayerProps & GeoJsonLayerProps<DataT> & TileLayerProps<ParsedPmTile>;
declare class PMTLayer<DataT extends Feature = Feature, ExtraProps = {}> extends MVTLayer<DataT, ExtraProps> {
    static layerName: string;
    static defaultProps: DefaultProps<PmtLayerProps<Feature<geojson.Geometry, geojson.GeoJsonProperties>>>;
    initializeState(): void;
    getTileData(loadProps: TileLoadProps, iter?: number): Promise<ParsedPmTile>;
}

/**
 * Worker loader for the Mapbox Vector Tile format
 */
declare const PMTWorkerLoader: Loader;
/**
 * Loader for the Mapbox Vector Tile format
 */
declare const PMTLoader: LoaderWithParser;

type DataShapeNames = keyof DataShapes;
type DataShapes = {
    binary: BinaryFeatures;
    "binary-geometry": BinaryFeatures;
    "columnar-table": {
        shape: "columnar-table";
        data: BinaryFeatures;
    };
    geojson: GeoJSON.FeatureCollection;
    "geojson-row-table": {
        shape: "geojson-row-table";
        data: GeoJSON.FeatureCollection;
    };
};
declare const useJoinLoader: ({ loader, shape, leftId, rightId, tableData, dataDict, dataMap, updateTriggers, }: {
    loader: LoaderWithParser;
    shape: keyof DataShapes;
    leftId: string;
    rightId: string;
    tableData?: {
        [key: string]: any;
    }[] | undefined;
    dataDict?: {
        [key: string]: object;
    } | undefined;
    dataMap?: Map<string, object> | undefined;
    updateTriggers?: any[] | undefined;
}) => LoaderWithParser;
declare function useJoinData<T extends DataShapeNames>({ shape, leftId, rightId, tableData, dataDict, dataMap, updateTriggers, }: {
    shape: T;
    leftId: string;
    rightId: string;
    tableData?: {
        [key: string]: any;
    }[];
    dataDict?: {
        [key: string]: object;
    };
    dataMap?: Map<string, object>;
    updateTriggers?: any[];
}): (data: DataShapes[T]) => DataShapes[T];

export { PMTLayer, PMTLoader, PMTWorkerLoader, useJoinData, useJoinLoader };