react-bkoi-gl 1.0.7 → 2.0.1

package/dist/index.d.ts

@@ -1,2 +1,370 @@
-export * from './exports-mapbox';
-export { default as default } from './exports-mapbox';
+import * as React from 'react';
+import { CSSProperties } from 'react';
+import { PaddingOptions, MapOptions, Map as Map$1, MarkerOptions, Marker as Marker$1, PopupOptions, Popup as Popup$1, AttributionControlOptions, AttributionControl as AttributionControl$1, FullscreenControlOptions, FullscreenControl as FullscreenControl$1, GeolocateControlOptions, GeolocateControl as GeolocateControl$1, NavigationControlOptions, NavigationControl as NavigationControl$1, ScaleControlOptions, ScaleControl as ScaleControl$1, TerrainSpecification, TerrainControl as TerrainControl$1, LogoControlOptions, LogoControl as LogoControl$1, MapLayerMouseEvent, MapLayerTouchEvent, MapWheelEvent, MapLibreZoomEvent, MapLibreEvent, MapStyleDataEvent, MapSourceDataEvent, LngLat, MapMouseEvent as MapMouseEvent$1, Point, MapGeoJSONFeature, LngLatBoundsLike, PointLike, StyleSpecification, ProjectionSpecification, LightSpecification, SkySpecification, ControlPosition, SourceSpecification, LayerSpecification, CustomLayerInterface, IControl } from 'maplibre-gl';
+export { AttributionControlOptions, BackgroundLayerSpecification, CanvasSourceSpecification, CircleLayerSpecification, ControlPosition, CustomLayerInterface, FillExtrusionLayerSpecification, FillLayerSpecification, FullscreenControlOptions, GeoJSONSourceSpecification, GeolocateControlOptions, HeatmapLayerSpecification, HillshadeLayerSpecification, IControl, ImageSourceSpecification, LayerSpecification, LightSpecification, LineLayerSpecification, LngLat, LngLatBounds, LngLatBoundsLike, LngLatLike, LogoControlOptions, MapLibreZoomEvent as MapBoxZoomEvent, MapLibreEvent as MapEvent, MapGeoJSONFeature, MapLayerMouseEvent, MapLayerTouchEvent, MapOptions, MapSourceDataEvent, MapStyleDataEvent, MapTouchEvent, MapWheelEvent, MarkerOptions, NavigationControlOptions, PaddingOptions, Point, PointLike, PopupOptions, ProjectionSpecification, RasterDEMSourceSpecification, RasterLayerSpecification, RasterSourceSpecification, ScaleControlOptions, SkySpecification, SourceSpecification, StyleSpecification, SymbolLayerSpecification, TerrainSpecification, VectorSourceSpecification, VideoSourceSpecification } from 'maplibre-gl';
+
+/** Describes the camera's state */
+type ViewState = {
+    /** Longitude at map center */
+    longitude: number;
+    /** Latitude at map center */
+    latitude: number;
+    /** Map zoom level */
+    zoom: number;
+    /** Map rotation bearing in degrees counter-clockwise from north */
+    bearing: number;
+    /** Map angle in degrees at which the camera is looking at the ground */
+    pitch: number;
+    /** Dimensions in pixels applied on each side of the viewport for shifting the vanishing point. */
+    padding: PaddingOptions;
+};
+interface ImmutableLike<T> {
+    toJS: () => T;
+}
+
+/**
+ * A user-facing type that represents the minimal intersection between Mapbox and Maplibre
+ * User provided `mapLib` is supposed to implement this interface
+ * Only losely typed for compatibility
+ */
+interface MapLib {
+    supported?: (options: unknown) => boolean;
+    Map: {
+        new (options: MapOptions): Map$1;
+    };
+    Marker: {
+        new (options: MarkerOptions): Marker$1;
+    };
+    Popup: {
+        new (options: PopupOptions): Popup$1;
+    };
+    AttributionControl: {
+        new (options: AttributionControlOptions): AttributionControl$1;
+    };
+    FullscreenControl: {
+        new (options: FullscreenControlOptions): FullscreenControl$1;
+    };
+    GeolocateControl: {
+        new (options: GeolocateControlOptions): GeolocateControl$1;
+    };
+    NavigationControl: {
+        new (options: NavigationControlOptions): NavigationControl$1;
+    };
+    ScaleControl: {
+        new (options: ScaleControlOptions): ScaleControl$1;
+    };
+    TerrainControl: {
+        new (options: TerrainSpecification): TerrainControl$1;
+    };
+    LogoControl: {
+        new (options: LogoControlOptions): LogoControl$1;
+    };
+}
+
+interface MapEvent<SourceT, OriginalEventT = undefined> {
+    type: string;
+    target: SourceT;
+    originalEvent: OriginalEventT;
+}
+type ErrorEvent = MapEvent<Map$1> & {
+    type: "error";
+    error: Error;
+};
+type MapMouseEvent = MapMouseEvent$1 & {
+    point: Point;
+    lngLat: LngLat;
+    features?: MapGeoJSONFeature[];
+};
+type ViewStateChangeEvent = (MapEvent<Map$1, MouseEvent | TouchEvent | WheelEvent | undefined> & {
+    type: "movestart" | "move" | "moveend" | "zoomstart" | "zoom" | "zoomend";
+    viewState: ViewState;
+}) | (MapEvent<Map$1, MouseEvent | TouchEvent | undefined> & {
+    type: "rotatestart" | "rotate" | "rotateend" | "dragstart" | "drag" | "dragend" | "pitchstart" | "pitch" | "pitchend";
+    viewState: ViewState;
+});
+type MapCallbacks = {
+    onMouseDown?: (e: MapLayerMouseEvent) => void;
+    onMouseUp?: (e: MapLayerMouseEvent) => void;
+    onMouseOver?: (e: MapLayerMouseEvent) => void;
+    onMouseMove?: (e: MapLayerMouseEvent) => void;
+    onClick?: (e: MapLayerMouseEvent) => void;
+    onDblClick?: (e: MapLayerMouseEvent) => void;
+    onMouseEnter?: (e: MapLayerMouseEvent) => void;
+    onMouseLeave?: (e: MapLayerMouseEvent) => void;
+    onMouseOut?: (e: MapLayerMouseEvent) => void;
+    onContextMenu?: (e: MapLayerMouseEvent) => void;
+    onTouchStart?: (e: MapLayerTouchEvent) => void;
+    onTouchEnd?: (e: MapLayerTouchEvent) => void;
+    onTouchMove?: (e: MapLayerTouchEvent) => void;
+    onTouchCancel?: (e: MapLayerTouchEvent) => void;
+    onMoveStart?: (e: ViewStateChangeEvent) => void;
+    onMove?: (e: ViewStateChangeEvent) => void;
+    onMoveEnd?: (e: ViewStateChangeEvent) => void;
+    onDragStart?: (e: ViewStateChangeEvent) => void;
+    onDrag?: (e: ViewStateChangeEvent) => void;
+    onDragEnd?: (e: ViewStateChangeEvent) => void;
+    onZoomStart?: (e: ViewStateChangeEvent) => void;
+    onZoom?: (e: ViewStateChangeEvent) => void;
+    onZoomEnd?: (e: ViewStateChangeEvent) => void;
+    onRotateStart?: (e: ViewStateChangeEvent) => void;
+    onRotate?: (e: ViewStateChangeEvent) => void;
+    onRotateEnd?: (e: ViewStateChangeEvent) => void;
+    onPitchStart?: (e: ViewStateChangeEvent) => void;
+    onPitch?: (e: ViewStateChangeEvent) => void;
+    onPitchEnd?: (e: ViewStateChangeEvent) => void;
+    onWheel?: (e: MapWheelEvent) => void;
+    onBoxZoomStart?: (e: MapLibreZoomEvent) => void;
+    onBoxZoomEnd?: (e: MapLibreZoomEvent) => void;
+    onBoxZoomCancel?: (e: MapLibreZoomEvent) => void;
+    onResize?: (e: MapLibreEvent) => void;
+    onLoad?: (e: MapLibreEvent) => void;
+    onRender?: (e: MapLibreEvent) => void;
+    onIdle?: (e: MapLibreEvent) => void;
+    onError?: (e: ErrorEvent) => void;
+    onRemove?: (e: MapLibreEvent) => void;
+    onData?: (e: MapStyleDataEvent | MapSourceDataEvent) => void;
+    onStyleData?: (e: MapStyleDataEvent) => void;
+    onSourceData?: (e: MapSourceDataEvent) => void;
+};
+type PopupEvent = {
+    type: "open" | "close";
+    target: Popup$1;
+};
+type MarkerEvent<OriginalEventT = undefined> = MapEvent<Marker$1, OriginalEventT>;
+type MarkerDragEvent = MarkerEvent & {
+    type: "dragstart" | "drag" | "dragend";
+    lngLat: LngLat;
+};
+type GeolocateEvent = MapEvent<GeolocateControl$1>;
+type GeolocateResultEvent = GeolocateEvent & GeolocationPosition;
+type GeolocateErrorEvent = GeolocateEvent & GeolocationPositionError;
+
+type MaplibreProps = Partial<ViewState> & MapCallbacks & {
+    /** Camera options used when constructing the Map instance */
+    initialViewState?: Partial<ViewState> & {
+        /** The initial bounds of the map. If bounds is specified, it overrides longitude, latitude and zoom options. */
+        bounds?: LngLatBoundsLike;
+        /** A fitBounds options object to use only when setting the bounds option. */
+        fitBoundsOptions?: {
+            offset?: PointLike;
+            minZoom?: number;
+            maxZoom?: number;
+            padding?: number | PaddingOptions;
+        };
+    };
+    /** If provided, render into an external WebGL context */
+    gl?: WebGLRenderingContext;
+    /** For external controller to override the camera state */
+    viewState?: ViewState & {
+        width: number;
+        height: number;
+    };
+    /** Mapbox style */
+    mapStyle?: string | StyleSpecification | ImmutableLike<StyleSpecification>;
+    /** Enable diffing when the map style changes
+     * @default true
+     */
+    styleDiffing?: boolean;
+    /** The projection property of the style. Must conform to the Projection Style Specification.
+     * @default 'mercator'
+     */
+    projection?: ProjectionSpecification | "mercator" | "globe";
+    /** Light properties of the map. */
+    light?: LightSpecification;
+    /** Terrain property of the style. Must conform to the Terrain Style Specification.
+     * If `undefined` is provided, removes terrain from the map. */
+    terrain?: TerrainSpecification;
+    /** Sky properties of the map. Must conform to the Sky Style Specification. */
+    sky?: SkySpecification;
+    /** Default layers to query on pointer events */
+    interactiveLayerIds?: string[];
+    /** CSS cursor */
+    cursor?: string;
+};
+
+/** These methods may break the react binding if called directly */
+declare const skipMethods: readonly ["setMaxBounds", "setMinZoom", "setMaxZoom", "setMinPitch", "setMaxPitch", "setRenderWorldCopies", "setProjection", "setStyle", "addSource", "removeSource", "addLayer", "removeLayer", "setLayerZoomRange", "setFilter", "setPaintProperty", "setLayoutProperty", "setLight", "setTerrain", "setFog", "remove"];
+type MapRef = {
+    getMap(): Map$1;
+} & Omit<Map$1, (typeof skipMethods)[number]>;
+
+type GlobalSettings = {
+    /** The maximum number of images (raster tiles, sprites, icons) to load in parallel.
+     * @default 16
+     */
+    maxParallelImageRequests?: number;
+    /** The map's RTL text plugin. Necessary for supporting the Arabic and Hebrew languages, which are written right-to-left.  */
+    RTLTextPlugin?: string | {
+        pluginUrl: string;
+        lazy?: boolean;
+    };
+    /** The number of web workers instantiated on a page with maplibre-gl maps.
+     * @default 2
+     */
+    workerCount?: number;
+    /** Provides an interface for loading maplibre-gl's WebWorker bundle from a self-hosted URL.
+     * This is useful if your site needs to operate in a strict CSP (Content Security Policy) environment
+     * wherein you are not allowed to load JavaScript code from a Blob URL, which is default behavior. */
+    workerUrl?: string;
+};
+
+type MapContextValue = {
+    mapLib: MapLib;
+    map: MapRef;
+};
+type MapInitOptions = Omit<MapOptions, "style" | "container" | "bounds" | "fitBoundsOptions" | "center">;
+type MapProps = MapInitOptions & MaplibreProps & GlobalSettings & {
+    mapLib?: MapLib | Promise<MapLib>;
+    reuseMaps?: boolean;
+    /** Map container id */
+    id?: string;
+    /** Map container CSS style */
+    style?: CSSProperties;
+    children?: React.ReactNode;
+    /** Show Barikoi logo (default: true) */
+    showBarikoiLogo?: boolean;
+    /** Show Attribution (default: true) */
+    showAttribution?: boolean;
+} & React.RefAttributes<MapRef>;
+declare const Map: React.FC<MapProps>;
+
+type MarkerProps = MarkerOptions & {
+    /** Longitude of the anchor location */
+    longitude: number;
+    /** Latitude of the anchor location */
+    latitude: number;
+    popup?: Popup$1;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+    onClick?: (e: MarkerEvent<MouseEvent>) => void;
+    onDragStart?: (e: MarkerDragEvent) => void;
+    onDrag?: (e: MarkerDragEvent) => void;
+    onDragEnd?: (e: MarkerDragEvent) => void;
+    children?: React.ReactNode;
+};
+declare const Marker: React.FC<MarkerProps>;
+
+type PopupProps = PopupOptions & {
+    /** Longitude of the anchor location */
+    longitude: number;
+    /** Latitude of the anchor location */
+    latitude: number;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+    onOpen?: (e: PopupEvent) => void;
+    onClose?: (e: PopupEvent) => void;
+    children?: React.ReactNode;
+};
+declare const Popup: React.FC<PopupProps>;
+
+type AttributionControlProps = AttributionControlOptions & {
+    /** Placement of the control relative to the map. */
+    position?: ControlPosition;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+};
+declare const AttributionControl: React.FC<AttributionControlProps>;
+
+type FullscreenControlProps = Omit<FullscreenControlOptions, "container"> & {
+    /** Id of the DOM element which should be made full screen. By default, the map container
+     * element will be made full screen. */
+    containerId?: string;
+    /** Placement of the control relative to the map. */
+    position?: ControlPosition;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+};
+declare const FullscreenControl: React.FC<FullscreenControlProps>;
+
+type GeolocateControlProps = GeolocateControlOptions & {
+    /** Placement of the control relative to the map. */
+    position?: ControlPosition;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+    /** Called on each Geolocation API position update that returned as success. */
+    onGeolocate?: (e: GeolocateResultEvent) => void;
+    /** Called on each Geolocation API position update that returned as an error. */
+    onError?: (e: GeolocateErrorEvent) => void;
+    /** Called on each Geolocation API position update that returned as success but user position
+     * is out of map `maxBounds`. */
+    onOutOfMaxBounds?: (e: GeolocateResultEvent) => void;
+    /** Called when the GeolocateControl changes to the active lock state. */
+    onTrackUserLocationStart?: (e: GeolocateEvent) => void;
+    /** Called when the GeolocateControl changes to the background state. */
+    onTrackUserLocationEnd?: (e: GeolocateEvent) => void;
+};
+declare const GeolocateControl: React.FC<GeolocateControlProps>;
+
+type NavigationControlProps = NavigationControlOptions & {
+    /** Placement of the control relative to the map. */
+    position?: ControlPosition;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+};
+declare const NavigationControl: React.FC<NavigationControlProps>;
+
+type ScaleControlProps = ScaleControlOptions & {
+    unit?: string;
+    maxWidth?: number;
+    /** Placement of the control relative to the map. */
+    position?: ControlPosition;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+};
+declare const ScaleControl: React.FC<ScaleControlProps>;
+
+type TerrainControlProps = TerrainSpecification & {
+    /** Placement of the control relative to the map. */
+    position?: ControlPosition;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+};
+declare const TerrainControl: React.FC<TerrainControlProps>;
+
+type LogoControlProps = LogoControlOptions & {
+    /** Placement of the control relative to the map. */
+    position?: ControlPosition;
+    /** CSS style override, applied to the control's container */
+    style?: React.CSSProperties;
+};
+declare const LogoControl: React.FC<LogoControlProps>;
+
+type SourceProps = SourceSpecification & {
+    id?: string;
+    children?: any;
+};
+declare function Source(props: SourceProps): any;
+
+type OptionalId<T> = T extends {
+    id: string;
+} ? Omit<T, "id"> & {
+    id?: string;
+} : T;
+type OptionalSource<T> = T extends {
+    source: string;
+} ? Omit<T, "source"> & {
+    source?: string;
+} : T;
+type LayerProps = (OptionalSource<OptionalId<LayerSpecification>> | CustomLayerInterface) & {
+    /** If set, the layer will be inserted before the specified layer */
+    beforeId?: string;
+};
+declare function Layer(props: LayerProps): any;
+
+type ControlOptions = {
+    position?: ControlPosition;
+};
+declare function useControl<T extends IControl>(onCreate: (context: MapContextValue) => T, opts?: ControlOptions): T;
+declare function useControl<T extends IControl>(onCreate: (context: MapContextValue) => T, onRemove: (context: MapContextValue) => void, opts?: ControlOptions): T;
+declare function useControl<T extends IControl>(onCreate: (context: MapContextValue) => T, onAdd: (context: MapContextValue) => void, onRemove: (context: MapContextValue) => void, opts?: ControlOptions): T;
+
+declare const MapProvider: React.FC<{
+    children?: React.ReactNode;
+}>;
+type MapCollection = {
+    [id: string]: MapRef | undefined;
+    current?: MapRef;
+};
+declare function useMap(): MapCollection;
+
+export { AttributionControl, type AttributionControlProps, type ErrorEvent, FullscreenControl, type FullscreenControlProps, GeolocateControl, type GeolocateControlProps, type GeolocateErrorEvent, type GeolocateEvent, type GeolocateResultEvent, type ImmutableLike, Layer, type LayerProps, LogoControl, type LogoControlProps, Map, type MapCallbacks, type MapLib, type MapMouseEvent, type MapProps, MapProvider, type MapRef, Marker, type MarkerDragEvent, type MarkerEvent, type MarkerProps, NavigationControl, type NavigationControlProps, Popup, type PopupEvent, type PopupProps, ScaleControl, type ScaleControlProps, Source, type SourceProps, TerrainControl, type TerrainControlProps, type ViewState, type ViewStateChangeEvent, Map as default, useControl, useMap };