@types/mapbox-gl

Version 3.4.1
Published 13 days ago
104 kB
1 dependency
MIT license

Install

npm i @types/mapbox-gl

yarn add @types/mapbox-gl

pnpm add @types/mapbox-gl

Overview

TypeScript definitions for mapbox-gl

Index

Variables

variable accessToken

let accessToken: string;

variable baseApiUrl

let baseApiUrl: string;

variable maxParallelImageRequests

let maxParallelImageRequests: number;

Maximum number of images (raster tiles, sprites, icons) to load in parallel, which affects performance in raster-heavy maps. 16 by default.

variable version

let version: string;

variable workerCount

let workerCount: number;

Number of web workers instantiated on a page with GL JS maps. By default, it is set to half the number of CPU cores (capped at 6).

Functions

function clearPrewarmedResources

clearPrewarmedResources: () => void;

Clears up resources that have previously been created by mapboxgl.prewarm(). Note that this is typically not necessary. You should only call this function if you expect the user of your app to not return to a Map view at any point in your application.

function clearStorage

clearStorage: (callback?: (err?: Error) => void) => void;

Clears browser storage used by this library. Using this method flushes the Mapbox tile cache that is managed by this library. Tiles may still be cached by the browser in some cases.

function getRTLTextPluginStatus

getRTLTextPluginStatus: () => PluginStatus;

function prewarm

prewarm: () => void;

Initializes resources like WebWorkers that can be shared across maps to lower load times in some situations. mapboxgl.workerUrl and mapboxgl.workerCount, if being used, must be set before prewarm() is called to have an effect.
By default, the lifecycle of these resources is managed automatically, and they are lazily initialized when a Map is first created. By invoking prewarm(), these resources will be created ahead of time, and will not be cleared when the last Map is removed from the page. This allows them to be re-used by new Map instances that are created later. They can be manually cleared by calling mapboxgl.clearPrewarmedResources(). This is only necessary if your web page remains active but stops using maps altogether.
This is primarily useful when using GL-JS maps in a single page app, wherein a user would navigate between various views that can cause Map instances to constantly be created and destroyed.

function setRTLTextPlugin

setRTLTextPlugin: (
    pluginURL: string,
    callback: (error: Error) => void,
    deferred?: boolean
) => void;

function supported

supported: (options?: {
    failIfMajorPerformanceCaveat?: boolean | undefined;
}) => boolean;

Classes

class AttributionControl

class AttributionControl extends Control {}

Attribution

constructor

constructor(options?: {
    compact?: boolean | undefined;
    customAttribution?: string | string[] | undefined;
});

class BoxZoomHandler

class BoxZoomHandler {}

BoxZoomHandler

constructor

constructor(map: Map);

method disable

disable: () => void;

method enable

enable: () => void;

method isActive

isActive: () => boolean;

method isEnabled

isEnabled: () => boolean;

class CanvasSource

class CanvasSource implements CanvasSourceRaw {}

property canvas

canvas: string | HTMLCanvasElement;

property coordinates

coordinates: number[][];

property type

type: string;

method getCanvas

getCanvas: () => HTMLCanvasElement;

method pause

pause: () => void;

method play

play: () => void;

method setCoordinates

setCoordinates: (coordinates: number[][]) => this;

class Control

class Control extends Evented implements IControl {}

Control

property getDefaultPosition

getDefaultPosition?: () => string;

method onAdd

onAdd: (map: Map) => HTMLElement;

method onRemove

onRemove: (map: Map) => void;

class DoubleClickZoomHandler

class DoubleClickZoomHandler {}

DoubleClickZoomHandler

constructor

constructor(map: Map);

method disable

disable: () => void;

method enable

enable: () => void;

method isEnabled

isEnabled: () => boolean;

class DragPanHandler

class DragPanHandler {}

DragPenHandler

constructor

constructor(map: Map);

method disable

disable: () => void;

method enable

enable: (options?: DragPanOptions) => void;

method isActive

isActive: () => boolean;

method isEnabled

isEnabled: () => boolean;

class DragRotateHandler

class DragRotateHandler {}

DragRotateHandler

constructor

constructor(
    map: Map,
    options?: {
        bearingSnap?: number | undefined;
        pitchWithRotate?: boolean | undefined;
    }
);

method disable

disable: () => void;

method enable

enable: () => void;

method isActive

isActive: () => boolean;

method isEnabled

isEnabled: () => boolean;

class ErrorEvent

class ErrorEvent extends MapboxEvent {}

property error

error: Error;

property type

type: string;

class Evented

class Evented {}

Evented

method fire

fire: (type: string, properties?: { [key: string]: any }) => this;

method off

off: (type?: string | any, listener?: EventedListener) => this;

method on

on: (type: string, listener: EventedListener) => this;

method once

once: (type: string, listener: EventedListener) => this;

class FreeCameraOptions

class FreeCameraOptions {}

Various options for accessing physical properties of the underlying camera entity. A direct access to these properties allows more flexible and precise controlling of the camera while also being fully compatible and interchangeable with CameraOptions. All fields are optional. See Camera#setFreeCameraOptions and Camera#getFreeCameraOptions
Parameter position
Position of the camera in slightly modified web mercator coordinates - The size of 1 unit is the width of the projected world instead of the "mercator meter". Coordinate [0, 0, 0] is the north-west corner and [1, 1, 0] is the south-east corner. - Z coordinate is conformal and must respect minimum and maximum zoom values. - Zoom is automatically computed from the altitude (z)
Parameter orientation
Orientation of the camera represented as a unit quaternion [x, y, z, w] in a left-handed coordinate space. Direction of the rotation is clockwise around the respective axis. The default pose of the camera is such that the forward vector is looking up the -Z axis and the up vector is aligned with north orientation of the map: forward: [0, 0, -1] up: [0, -1, 0] right [1, 0, 0] Orientation can be set freely but certain constraints still apply - Orientation must be representable with only pitch and bearing. - Pitch has an upper limit

constructor

constructor(position?: MercatorCoordinate, orientation?: quat);

property position

position: MercatorCoordinate;

method lookAtPoint

lookAtPoint: (location: LngLatLike, up?: vec3) => void;

Helper function for setting orientation of the camera by defining a focus point on the map.
Parameter location
Location of the focus point on the map
Parameter up
Up vector of the camera is required in certain scenarios where bearing can't be deduced from the viewing direction.

method setPitchBearing

setPitchBearing: (pitch: number, bearing: number) => void;

Helper function for setting the orientation of the camera as a pitch and a bearing.
Parameter pitch
Pitch angle in degrees
Parameter bearing
Bearing angle in degrees

class FullscreenControl

class FullscreenControl extends Control {}

FullscreenControl

constructor

constructor(options?: FullscreenControlOptions);

class GeoJSONSource

class GeoJSONSource implements GeoJSONSourceRaw {}

constructor

constructor(options?: GeoJSONSourceOptions);

property type

type: string;

method getClusterChildren

getClusterChildren: (
    clusterId: number,
    callback: (
        error: any,
        features: Array<GeoJSON.Feature<GeoJSON.Geometry>>
    ) => void
) => this;

method getClusterExpansionZoom

getClusterExpansionZoom: (
    clusterId: number,
    callback: (error: any, zoom: number) => void
) => this;

method getClusterLeaves

getClusterLeaves: (
    cluserId: number,
    limit: number,
    offset: number,
    callback: (
        error: any,
        features: Array<GeoJSON.Feature<GeoJSON.Geometry>>
    ) => void
) => this;

method setData

setData: (
    data:
        | GeoJSON.Feature<GeoJSON.Geometry>
        | GeoJSON.FeatureCollection<GeoJSON.Geometry>
        | String
) => this;

class GeolocateControl

class GeolocateControl extends Control {}

Geolocate

constructor

constructor(options?: {
    positionOptions?: PositionOptions;
    fitBoundsOptions?: FitBoundsOptions | undefined;
    trackUserLocation?: boolean | undefined;
    showAccuracyCircle?: boolean | undefined;
    showUserLocation?: boolean | undefined;
    showUserHeading?: boolean | undefined;
    geolocation?: Geolocation | undefined;
});

method trigger

trigger: () => boolean;

class ImageSource

class ImageSource implements ImageSourceRaw {}

constructor

constructor(options?: ImageSourceOptions);

property type

type: string;

method setCoordinates

setCoordinates: (coordinates: number[][]) => this;

method updateImage

updateImage: (options: ImageSourceOptions) => this;

class KeyboardHandler

class KeyboardHandler {}

KeyboardHandler

constructor

constructor(map: Map);

method disable

disable: () => void;

method disableRotation

disableRotation: () => void;

Disables the "keyboard pan/rotate" interaction, leaving the "keyboard zoom" interaction enabled.
Example 1
map.keyboard.disableRotation();

method enable

enable: () => void;

method enableRotation

enableRotation: () => void;

Enables the "keyboard pan/rotate" interaction.
Example 1
map.keyboard.enable(); map.keyboard.enableRotation();

method isActive

isActive: () => boolean;

Returns true if the handler is enabled and has detected the start of a zoom/rotate gesture.
Returns
{boolean} true if the handler is enabled and has detected the start of a zoom/rotate gesture.

method isEnabled

isEnabled: () => boolean;

class LngLat

class LngLat {}

LngLat

constructor

constructor(lng: number, lat: number);

property lat

lat: number;

property lng

lng: number;

method convert

static convert: (input: LngLatLike) => LngLat;

method distanceTo

distanceTo: (lngLat: LngLat) => number;

Returns the approximate distance between a pair of coordinates in meters Uses the Haversine Formula (from R.W. Sinnott, "Virtues of the Haversine", Sky and Telescope, vol. 68, no. 2, 1984, p. 159)

method toArray

toArray: () => number[];

Return a LngLat as an array

method toBounds

toBounds: (radius: number) => LngLatBounds;

method toString

toString: () => string;

Return a LngLat as a string

method wrap

wrap: () => LngLat;

Return a new LngLat object whose longitude is wrapped to the range (-180, 180).

class LngLatBounds

class LngLatBounds {}

LngLatBounds

constructor

constructor(
    boundsLike?: [number, number, number, number] | [LngLatLike, LngLatLike]
);

constructor

constructor(sw: LngLatLike, ne: LngLatLike);

property ne

ne: LngLatLike;

property sw

sw: LngLatLike;

method contains

contains: (lnglat: LngLatLike) => boolean;

Check if the point is within the bounding box.

method convert

static convert: (input: LngLatBoundsLike) => LngLatBounds;

Convert an array to a LngLatBounds object, or return an existing LngLatBounds object unchanged.

method extend

extend: (obj: mapboxgl.LngLatLike | mapboxgl.LngLatBoundsLike) => this;

Extend the bounds to include a given LngLat or LngLatBounds.

method getCenter

getCenter: () => LngLat;

Get the point equidistant from this box's corners

method getEast

getEast: () => number;

Get east edge longitude

method getNorth

getNorth: () => number;

Get north edge latitude

method getNorthEast

getNorthEast: () => LngLat;

Get northeast corner

method getNorthWest

getNorthWest: () => LngLat;

Get northwest corner

method getSouth

getSouth: () => number;

Get south edge latitude

method getSouthEast

getSouthEast: () => LngLat;

Get southeast corner

method getSouthWest

getSouthWest: () => LngLat;

Get southwest corner

method getWest

getWest: () => number;

Get west edge longitude

method isEmpty

isEmpty: () => boolean;

Returns a boolean

method setNorthEast

setNorthEast: (ne: LngLatLike) => this;

method setSouthWest

setSouthWest: (sw: LngLatLike) => this;

method toArray

toArray: () => number[][];

Returns a LngLatBounds as an array

method toString

toString: () => string;

Return a LngLatBounds as a string

class Map

class Map extends Evented {}

constructor

constructor(options?: MapboxOptions);

property boxZoom

boxZoom: BoxZoomHandler;

property doubleClickZoom

doubleClickZoom: DoubleClickZoomHandler;

property dragPan

dragPan: DragPanHandler;

property dragRotate

dragRotate: DragRotateHandler;

property keyboard

keyboard: KeyboardHandler;

property repaint

repaint: boolean;

property scrollZoom

scrollZoom: ScrollZoomHandler;

property showCollisionBoxes

showCollisionBoxes: boolean;

property showPadding

showPadding: boolean;

Gets and sets a Boolean indicating whether the map will visualize the padding offsets.
showPadding Map

property showTerrainWireframe

showTerrainWireframe: boolean;

property showTileBoundaries

showTileBoundaries: boolean;

property touchPitch

touchPitch: TouchPitchHandler;

property touchZoomRotate

touchZoomRotate: TouchZoomRotateHandler;

method addControl

addControl: (
    control: Control | IControl,
    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left'
) => this;

method addImage

addImage: (
    name: string,
    image:
        | HTMLImageElement
        | ArrayBufferView
        | { width: number; height: number; data: Uint8Array | Uint8ClampedArray }
        | ImageData
        | ImageBitmap,
    options?: {
        pixelRatio?: number | undefined;
        sdf?: boolean | undefined;
        stretchX?: Array<[number, number]> | undefined;
        stretchY?: Array<[number, number]> | undefined;
        content?: [number, number, number, number] | undefined;
    }
) => void;

method addLayer

addLayer: (layer: mapboxgl.AnyLayer, before?: string) => this;

method addSource

addSource: (id: string, source: AnySourceData) => this;

method areTilesLoaded

areTilesLoaded: () => boolean;

method cameraForBounds

cameraForBounds: (
    bounds: LngLatBoundsLike,
    options?: CameraForBoundsOptions
) => CameraForBoundsResult | undefined;

method easeTo

easeTo: (
    options: mapboxgl.EaseToOptions,
    eventData?: mapboxgl.EventData
) => this;

method fitBounds

fitBounds: (
    bounds: LngLatBoundsLike,
    options?: mapboxgl.FitBoundsOptions,
    eventData?: mapboxgl.EventData
) => this;

method fitScreenCoordinates

fitScreenCoordinates: (
    p0: PointLike,
    p1: PointLike,
    bearing: number,
    options?: AnimationOptions & CameraOptions,
    eventData?: EventData
) => this;

method flyTo

flyTo: (options: mapboxgl.FlyToOptions, eventData?: mapboxgl.EventData) => this;

method getBearing

getBearing: () => number;

method getBounds

getBounds: () => LngLatBounds;

method getCanvas

getCanvas: () => HTMLCanvasElement;

method getCanvasContainer

getCanvasContainer: () => HTMLElement;

method getCenter

getCenter: () => LngLat;

method getConfigProperty

getConfigProperty: (importId: string, configName: string) => any;

Returns the value of a configuration property in the imported style.
Parameter importId
The name of the imported style to set the config for (e.g. basemap).
Parameter configName
The name of the configuration property from the style.
Returns
{*} Returns the value of the configuration property.
Example 1
map.getConfigProperty('basemap', 'showLabels');

method getContainer

getContainer: () => HTMLElement;

method getFeatureState

getFeatureState: (
    feature: FeatureIdentifier | mapboxgl.MapboxGeoJSONFeature
) => { [key: string]: any };

method getFilter

getFilter: (layer: string) => any[];

method getFog

getFog: () => Fog | null;

method getFreeCameraOptions

getFreeCameraOptions: () => FreeCameraOptions;

Returns position and orientation of the camera entity.
Map#
Returns
{FreeCameraOptions} The camera state

method getLayer

getLayer: (id: string) => mapboxgl.AnyLayer;

method getLayoutProperty

getLayoutProperty: (layer: string, name: string) => any;

method getLight

getLight: () => mapboxgl.Light;

method getMaxBounds

getMaxBounds: () => LngLatBounds;

method getMaxPitch

getMaxPitch: () => number;

method getMaxZoom

getMaxZoom: () => number;

method getMinPitch

getMinPitch: () => number;

method getMinZoom

getMinZoom: () => number;

method getPadding

getPadding: () => PaddingOptions;

Returns the current padding applied around the map viewport.
Map#
Returns
The current padding around the map viewport.

method getPaintProperty

getPaintProperty: (layer: string, name: string) => any;

method getPitch

getPitch: () => number;

method getProjection

getProjection: () => Projection;

method getRenderWorldCopies

getRenderWorldCopies: () => boolean;

method getSource

getSource: (id: string) => AnySourceImpl;

method getStyle

getStyle: () => mapboxgl.Style;

method getTerrain

getTerrain: () => TerrainSpecification | null;

method getZoom

getZoom: () => number;

method hasControl

hasControl: (control: IControl) => boolean;

Checks if a control exists on the map.
Parameter control
The IControl to check.
Returns
{boolean} True if map contains control.
Example 1

method hasImage

hasImage: (name: string) => boolean;

method isEasing

isEasing: () => boolean;

method isMoving

isMoving: () => boolean;

method isRotating

isRotating: () => boolean;

method isSourceLoaded

isSourceLoaded: (id: string) => boolean;

method isStyleLoaded

isStyleLoaded: () => boolean;

method isZooming

isZooming: () => boolean;

method jumpTo

jumpTo: (
    options: mapboxgl.CameraOptions,
    eventData?: mapboxgl.EventData
) => this;

method listImages

listImages: () => string[];

method loaded

loaded: () => boolean;

method loadImage

loadImage: (
    url: string,
    callback: (error?: Error, result?: HTMLImageElement | ImageBitmap) => void
) => void;

method moveLayer

moveLayer: (id: string, beforeId?: string) => this;

method off

off: {
    <T extends keyof MapLayerEventType>(
        type: T,
        layer: string | readonly string[],
        listener: (ev: MapLayerEventType[T] & EventData) => void
    ): this;
    <T extends keyof MapEventType>(
        type: T,
        listener: (ev: MapEventType[T] & EventData) => void
    ): this;
    (type: string, listener: (ev: any) => void): this;
};

method on

on: {
    <T extends keyof MapLayerEventType>(
        type: T,
        layer: string | readonly string[],
        listener: (ev: MapLayerEventType[T] & EventData) => void
    ): this;
    <T extends keyof MapEventType>(
        type: T,
        listener: (ev: MapEventType[T] & EventData) => void
    ): this;
    (type: string, listener: (ev: any) => void): this;
};

method once

once: {
    <T extends keyof MapLayerEventType>(
        type: T,
        layer: string | readonly string[],
        listener: (ev: MapLayerEventType[T] & EventData) => void
    ): this;
    <T extends keyof MapEventType>(
        type: T,
        listener: (ev: MapEventType[T] & EventData) => void
    ): this;
    (type: string, listener: (ev: any) => void): this;
    <T extends keyof MapEventType>(type: T): Promise<MapEventType[T]>;
};

method panBy

panBy: (
    offset: PointLike,
    options?: mapboxgl.AnimationOptions,
    eventData?: mapboxgl.EventData
) => this;

method panTo

panTo: (
    lnglat: LngLatLike,
    options?: mapboxgl.AnimationOptions,
    eventdata?: mapboxgl.EventData
) => this;

method project

project: (lnglat: LngLatLike) => Point;

method queryRenderedFeatures

queryRenderedFeatures: (
    pointOrBox?: PointLike | [PointLike, PointLike],
    options?: {
        layers?: string[] | undefined;
        filter?: any[] | undefined;
    } & FilterOptions
) => MapboxGeoJSONFeature[];

Returns an array of GeoJSON Feature objects representing visible features that satisfy the query parameters.
The properties value of each returned feature object contains the properties of its source feature. For GeoJSON sources, only string and numeric property values are supported (i.e. null, Array, and Object values are not supported).
Each feature includes top-level layer, source, and sourceLayer properties. The layer property is an object representing the style layer to which the feature belongs. Layout and paint properties in this object contain values which are fully evaluated for the given zoom level and feature.
Only features that are currently rendered are included. Some features will not be included, like:
- Features from layers whose visibility property is "none". - Features from layers whose zoom range excludes the current zoom level. - Symbol features that have been hidden due to text or icon collision.
Features from all other layers are included, including features that may have no visible contribution to the rendered result; for example, because the layer's opacity or color alpha component is set to 0.
The topmost rendered feature appears first in the returned array, and subsequent features are sorted by descending z-order. Features that are rendered multiple times (due to wrapping across the antimeridian at low zoom levels) are returned only once (though subject to the following caveat).
Because features come from tiled vector data or GeoJSON data that is converted to tiles internally, feature geometries may be split or duplicated across tile boundaries and, as a result, features may appear multiple times in query results. For example, suppose there is a highway running through the bounding rectangle of a query. The results of the query will be those parts of the highway that lie within the map tiles covering the bounding rectangle, even if the highway extends into other tiles, and the portion of the highway within each map tile will be returned as a separate feature. Similarly, a point feature near a tile boundary may appear in multiple tiles due to tile buffering.
Parameter pointOrBox
The geometry of the query region: either a single point or southwest and northeast points describing a bounding box. Omitting this parameter (i.e. calling Map#queryRenderedFeatures with zero arguments, or with only a options argument) is equivalent to passing a bounding box encompassing the entire map viewport.
Parameter options

method querySourceFeatures

querySourceFeatures: (
    sourceID: string,
    parameters?: {
        sourceLayer?: string | undefined;
        filter?: any[] | undefined;
    } & FilterOptions
) => MapboxGeoJSONFeature[];

Returns an array of GeoJSON Feature objects representing features within the specified vector tile or GeoJSON source that satisfy the query parameters.
In contrast to Map#queryRenderedFeatures, this function returns all features matching the query parameters, whether or not they are rendered by the current style (i.e. visible). The domain of the query includes all currently-loaded vector tiles and GeoJSON source tiles: this function does not check tiles outside the currently visible viewport.
Because features come from tiled vector data or GeoJSON data that is converted to tiles internally, feature geometries may be split or duplicated across tile boundaries and, as a result, features may appear multiple times in query results. For example, suppose there is a highway running through the bounding rectangle of a query. The results of the query will be those parts of the highway that lie within the map tiles covering the bounding rectangle, even if the highway extends into other tiles, and the portion of the highway within each map tile will be returned as a separate feature. Similarly, a point feature near a tile boundary may appear in multiple tiles due to tile buffering.
Parameter sourceID
The ID of the vector tile or GeoJSON source to query.
Parameter parameters

method queryTerrainElevation

queryTerrainElevation: (
    lngLat: mapboxgl.LngLatLike,
    options?: ElevationQueryOptions
) => number | null;

Parameter lngLat
The coordinate to query
Parameter options
Optional {ElevationQueryOptions}
Returns
The elevation in meters at mean sea level or null

method remove

remove: () => void;

method removeControl

removeControl: (control: Control | IControl) => this;

method removeFeatureState

removeFeatureState: (
    target: FeatureIdentifier | mapboxgl.MapboxGeoJSONFeature,
    key?: string
) => void;

method removeImage

removeImage: (name: string) => void;

method removeLayer

removeLayer: (id: string) => this;

method removeSource

removeSource: (id: string) => this;

method resetNorth

resetNorth: (
    options?: mapboxgl.AnimationOptions,
    eventData?: mapboxgl.EventData
) => this;

method resetNorthPitch

resetNorthPitch: (
    options?: mapboxgl.AnimationOptions | null,
    eventData?: mapboxgl.EventData | null
) => this;

method resize

resize: (eventData?: EventData) => this;

method rotateTo

rotateTo: (
    bearing: number,
    options?: AnimationOptions & CameraOptions,
    eventData?: EventData
) => this;

method setBearing

setBearing: (bearing: number, eventData?: mapboxgl.EventData) => this;

method setCenter

setCenter: (center: LngLatLike, eventData?: mapboxgl.EventData) => this;

method setConfigProperty

setConfigProperty: (importId: string, configName: string, value: any) => this;

Sets the value of a configuration property in the currently set style.
Parameter importId
The name of the imported style to set the config for (e.g. basemap).
Parameter configName
The name of the configuration property from the style.
Parameter value
The value of the configuration property. Must be of a type appropriate for the property, as defined by the style configuration schema.
Returns
{Map} Returns itself to allow for method chaining.
Example 1
map.setConfigProperty('basemap', 'showLabels', false);

method setFeatureState

setFeatureState: (
    feature: FeatureIdentifier | mapboxgl.MapboxGeoJSONFeature,
    state: { [key: string]: any }
) => void;

method setFilter

setFilter: (
    layer: string,
    filter?: any[] | boolean | null,
    options?: FilterOptions | null
) => this;

method setFog

setFog: (fog: Fog | null | undefined) => this;

Parameter fog
If null or undefined is provided, function removes fog from the map.

method setFreeCameraOptions

setFreeCameraOptions: (options: FreeCameraOptions, eventData?: Object) => this;

FreeCameraOptions provides more direct access to the underlying camera entity. For backwards compatibility the state set using this API must be representable with CameraOptions as well. Parameters are clamped into a valid range or discarded as invalid if the conversion to the pitch and bearing presentation is ambiguous. For example orientation can be invalid if it leads to the camera being upside down, the quaternion has zero length, or the pitch is over the maximum pitch limit.
Map#
Parameter options
FreeCameraOptions object
Parameter eventData
Additional properties to be added to event objects of events triggered by this method. movestart zoomstart pitchstart rotate move zoom pitch moveend zoomend pitchend
Returns
{Map} this

method setLayerZoomRange

setLayerZoomRange: (layerId: string, minzoom: number, maxzoom: number) => this;

method setLayoutProperty

setLayoutProperty: (
    layer: string,
    name: string,
    value: any,
    options?: FilterOptions
) => this;

method setLight

setLight: (light: mapboxgl.Light, options?: FilterOptions) => this;

method setMaxBounds

setMaxBounds: (lnglatbounds?: LngLatBoundsLike) => this;

method setMaxPitch

setMaxPitch: (maxPitch?: number | null) => this;

method setMaxZoom

setMaxZoom: (maxZoom?: number | null) => this;

method setMinPitch

setMinPitch: (minPitch?: number | null) => this;

method setMinZoom

setMinZoom: (minZoom?: number | null) => this;

method setPadding

setPadding: (padding: PaddingOptions, eventData?: EventData) => this;

Sets the padding in pixels around the viewport.
Equivalent to jumpTo({padding: padding}).
Map#
Parameter padding
The desired padding. Format: { left: number, right: number, top: number, bottom: number }
Parameter eventData
Additional properties to be added to event objects of events triggered by this method. movestart moveend
Returns
{Map} this
Example 1
// Sets a left padding of 300px, and a top padding of 50px map.setPadding({ left: 300, top: 50 });

method setPaintProperty

setPaintProperty: (
    layer: string,
    name: string,
    value: any,
    options?: FilterOptions
) => this;

method setPitch

setPitch: (pitch: number, eventData?: EventData) => this;

method setProjection

setProjection: (projection: Projection | string) => this;

method setRenderWorldCopies

setRenderWorldCopies: (renderWorldCopies?: boolean) => this;

method setStyle

setStyle: (
    style: mapboxgl.Style | string,
    options?: {
        diff?: boolean | undefined;
        localIdeographFontFamily?: string | undefined;
    }
) => this;

method setTerrain

setTerrain: (terrain?: TerrainSpecification | null) => this;

Sets the terrain property of the style.
Parameter terrain
Terrain properties to set. Must conform to the [Mapbox Style Specification](https://www.mapbox.com/mapbox-gl-style-spec/#terrain). If null or undefined is provided, function removes terrain.
Returns
{Map} this
Example 1
map.addSource('mapbox-dem', { 'type': 'raster-dem', 'url': 'mapbox://mapbox.mapbox-terrain-dem-v1', 'tileSize': 512, 'maxzoom': 14 }); // add the DEM source as a terrain layer with exaggerated height map.setTerrain({ 'source': 'mapbox-dem', 'exaggeration': 1.5 });

method setZoom

setZoom: (zoom: number, eventData?: mapboxgl.EventData) => this;

method snapToNorth

snapToNorth: (
    options?: mapboxgl.AnimationOptions,
    eventData?: mapboxgl.EventData
) => this;

method stop

stop: () => this;

method triggerRepaint

triggerRepaint: () => void;

method unproject

unproject: (point: PointLike) => LngLat;

method updateImage

updateImage: (
    name: string,
    image:
        | HTMLImageElement
        | ArrayBufferView
        | { width: number; height: number; data: Uint8Array | Uint8ClampedArray }
        | ImageData
        | ImageBitmap
) => void;

method zoomIn

zoomIn: (
    options?: mapboxgl.AnimationOptions,
    eventData?: mapboxgl.EventData
) => this;

method zoomOut

zoomOut: (
    options?: mapboxgl.AnimationOptions,
    eventData?: mapboxgl.EventData
) => this;

method zoomTo

zoomTo: (
    zoom: number,
    options?: mapboxgl.AnimationOptions,
    eventData?: mapboxgl.EventData
) => this;

class MapboxEvent

class MapboxEvent<TOrig = undefined> {}

property originalEvent

originalEvent: {};

property target

target: Map;

property type

type: string;

class MapMouseEvent

class MapMouseEvent extends MapboxEvent<MouseEvent> {}

property defaultPrevented

defaultPrevented: boolean;

property lngLat

lngLat: LngLat;

property point

point: Point;

property type

type:
    | 'click'
    | 'dblclick'
    | 'mousedown'
    | 'mouseup'
    | 'mousemove'
    | 'mouseenter'
    | 'mouseleave'
    | 'mouseover'
    | 'mouseout'
    | 'contextmenu';

method preventDefault

preventDefault: () => void;

class MapTouchEvent

class MapTouchEvent extends MapboxEvent<TouchEvent> {}

property defaultPrevented

defaultPrevented: boolean;

property lngLat

lngLat: LngLat;

property lngLats

lngLats: LngLat[];

property point

point: Point;

property points

points: Point[];

property type

type: 'touchstart' | 'touchend' | 'touchcancel';

method preventDefault

preventDefault: () => void;

class MapWheelEvent

class MapWheelEvent extends MapboxEvent<WheelEvent> {}

property defaultPrevented

defaultPrevented: boolean;

property type

type: string;

method preventDefault

preventDefault: () => void;

class Marker

class Marker extends Evented {}

Marker

constructor

constructor(options?: MarkerOptions);

constructor

constructor(element?: HTMLElement, options?: MarkerOptions);

method addTo

addTo: (map: Map) => this;

method getElement

getElement: () => HTMLElement;

method getLngLat

getLngLat: () => LngLat;

method getOccludedOpacity

getOccludedOpacity: () => number;

method getOffset

getOffset: () => PointLike;

method getPitchAlignment

getPitchAlignment: () => Alignment;

method getPopup

getPopup: () => Popup;

method getRotation

getRotation: () => number;

method getRotationAlignment

getRotationAlignment: () => Alignment;

method isDraggable

isDraggable: () => boolean;

method remove

remove: () => this;

method setDraggable

setDraggable: (shouldBeDraggable: boolean) => this;

method setLngLat

setLngLat: (lngLat: LngLatLike) => this;

method setOccludedOpacity

setOccludedOpacity: (opacity: number) => this;

method setOffset

setOffset: (offset: PointLike) => this;

method setPitchAlignment

setPitchAlignment: (alignment: Alignment) => this;

method setPopup

setPopup: (popup?: Popup) => this;

method setRotation

setRotation: (rotation: number) => this;

method setRotationAlignment

setRotationAlignment: (alignment: Alignment) => this;

method togglePopup

togglePopup: () => this;

class MercatorCoordinate

class MercatorCoordinate {}

MercatorCoordinate

constructor

constructor(x: number, y: number, z?: number);

property x

x: number;

The x component of the position.

property y

y: number;

The y component of the position.

property z

z?: number;

The z component of the position.
0

method fromLngLat

static fromLngLat: (
    lngLatLike: LngLatLike,
    altitude?: number
) => MercatorCoordinate;

Project a LngLat to a MercatorCoordinate.

method meterInMercatorCoordinateUnits

meterInMercatorCoordinateUnits: () => number;

Returns the distance of 1 meter in MercatorCoordinate units at this latitude.
For coordinates in real world units using meters, this naturally provides the scale to transform into MercatorCoordinates.

method toAltitude

toAltitude: () => number;

Returns the altitude in meters of the coordinate.

method toLngLat

toLngLat: () => LngLat;

Returns the LngLat for the coordinate.

class NavigationControl

class NavigationControl extends Control {}

Navigation

constructor

constructor(options?: {
    showCompass?: boolean | undefined;
    showZoom?: boolean | undefined;
    visualizePitch?: boolean | undefined;
});

class Point

class Point {}

Point

constructor

constructor(x: number, y: number);

property x

x: number;

property y

y: number;

method add

add: (p: Point) => Point;

method angle

angle: () => number;

method angleTo

angleTo: (p: Point) => number;

method angleWidth

angleWidth: (p: Point) => number;

method angleWithSep

angleWithSep: (x: number, y: number) => number;

method clone

clone: () => Point;

method convert

static convert: (a: PointLike) => Point;

method dist

dist: (p: Point) => number;

method distSqr

distSqr: (p: Point) => number;

method div

div: (k: number) => Point;

method equals

equals: (p: Point) => boolean;

method mag

mag: () => number;

method matMult

matMult: (m: number) => Point;

method mult

mult: (k: number) => Point;

method perp

perp: () => Point;

method rotate

rotate: (a: number) => Point;

method round

round: () => Point;

method sub

sub: (p: Point) => Point;

method unit

unit: () => Point;

class Popup extends Evented {}

Popup

constructor(options?: PopupOptions);

addClassName: (className: string) => void;

Adds a CSS class to the popup container element.
Parameter className
Non-empty string with CSS class name to add to popup container
Example 1
let popup = new mapboxgl.Popup() popup.addClassName('some-class')

addTo: (map: Map) => this;

getElement: () => HTMLElement;

Returns the Popup's HTML element.

getLngLat: () => LngLat;

getMaxWidth: () => string;

isOpen: () => boolean;

remove: () => this;

removeClassName: (className: string) => void;

Removes a CSS class from the popup container element.
Parameter className
Non-empty string with CSS class name to remove from popup container
Example 1
let popup = new mapboxgl.Popup() popup.removeClassName('some-class')

setDOMContent: (htmlNode: Node) => this;

setHTML: (html: string) => this;

setLngLat: (lnglat: LngLatLike) => this;

Sets the geographical location of the popup's anchor, and moves the popup to it. Replaces trackPointer() behavior.
Parameter lnglat
The geographical location to set as the popup's anchor.

setMaxWidth: (maxWidth: string) => this;

setOffset: (offset?: Offset | null) => this;

Sets the popup's offset.
Parameter offset
Sets the popup's offset.
Returns
{Popup} this

setText: (text: string) => this;

toggleClassName: (className: string) => void;

Add or remove the given CSS class on the popup container, depending on whether the container currently has that class.
Parameter className
Non-empty string with CSS class name to add/remove
Returns
{boolean} if the class was removed return false, if class was added, then return true
Example 1
let popup = new mapboxgl.Popup() popup.toggleClassName('toggleClass')

trackPointer: () => this;

Tracks the popup anchor to the cursor position, on screens with a pointer device (will be hidden on touchscreens). Replaces the setLngLat behavior. For most use cases, closeOnClick and closeButton should also be set to false here.

class PositionOptions

class PositionOptions {}

property enableHighAccuracy

enableHighAccuracy?: boolean;

property maximumAge

maximumAge?: number;

property timeout

timeout?: number;

class ScaleControl

class ScaleControl extends Control {}

Scale

constructor

constructor(options?: {
    maxWidth?: number | undefined;
    unit?: string | undefined;
});

method setUnit

setUnit: (unit: 'imperial' | 'metric' | 'nautical') => void;

class ScrollZoomHandler

class ScrollZoomHandler {}

ScrollZoomHandler

constructor

constructor(map: Map);

method disable

disable: () => void;

method enable

enable: (options?: InteractiveOptions) => void;

method isEnabled

isEnabled: () => boolean;

method setWheelZoomRate

setWheelZoomRate: (wheelZoomRate: number) => void;

method setZoomRate

setZoomRate: (zoomRate: number) => void;

class TouchPitchHandler

class TouchPitchHandler {}

constructor

constructor(map: Map);

method disable

disable: () => void;

method enable

enable: (options?: InteractiveOptions) => void;

method isActive

isActive: () => boolean;

method isEnabled

isEnabled: () => boolean;

class TouchZoomRotateHandler

class TouchZoomRotateHandler {}

TouchZoomRotateHandler

constructor

constructor(map: Map);

method disable

disable: () => void;

method disableRotation

disableRotation: () => void;

method enable

enable: (options?: InteractiveOptions) => void;

method enableRotation

enableRotation: () => void;

method isEnabled

isEnabled: () => boolean;

class VideoSource

class VideoSource implements VideoSourceRaw {}

constructor

constructor(options?: VideoSourceOptions);

property type

type: string;

method getVideo

getVideo: () => HTMLVideoElement;

method setCoordinates

setCoordinates: (coordinates: number[][]) => this;

Interfaces

interface AnimationOptions

interface AnimationOptions {}

AnimationOptions

property animate

animate?: boolean | undefined;

When set to false, no animation happens

property duration

duration?: number | undefined;

Number in milliseconds

property easing

easing?: ((time: number) => number) | undefined;

A function taking a time in the range 0..1 and returning a number where 0 is the initial state and 1 is the final state.

property essential

essential?: boolean | undefined;

If true, then the animation is considered essential and will not be affected by prefers-reduced-motion. Otherwise, the transition will happen instantly if the user has enabled the reduced motion accesibility feature in their operating system.

property offset

offset?: PointLike | undefined;

point, origin of movement relative to map center

interface BackgroundLayer

interface BackgroundLayer extends Layer {}

property layout

layout?: BackgroundLayout | undefined;

property paint

paint?: BackgroundPaint | undefined;

property type

type: 'background';

interface BackgroundLayout

interface BackgroundLayout extends Layout {}

interface BackgroundPaint

interface BackgroundPaint {}

property "background-color-transition"

'background-color-transition'?: Transition | undefined;

property "background-color"

'background-color'?: string | Expression | undefined;

property "background-emissive-strength"

'background-emissive-strength'?: number | Expression | undefined;

property "background-opacity-transition"

'background-opacity-transition'?: Transition | undefined;

property "background-opacity"

'background-opacity'?: number | Expression | undefined;

property "background-pattern-transition"

'background-pattern-transition'?: Transition | undefined;

property "background-pattern"

'background-pattern'?: string | undefined;

interface CameraForBoundsOptions

interface CameraForBoundsOptions extends CameraOptions {}

property maxZoom

maxZoom?: number | undefined;

property offset

offset?: PointLike | undefined;

interface CameraOptions

interface CameraOptions {}

CameraOptions

property around

around?: LngLatLike | undefined;

If zooming, the zoom center (defaults to map center)

property bearing

bearing?: number | undefined;

Map rotation bearing in degrees counter-clockwise from north

property center

center?: LngLatLike | undefined;

Map center

property padding

padding?: number | PaddingOptions | undefined;

Dimensions in pixels applied on each side of the viewport for shifting the vanishing point.

property pitch

pitch?: number | undefined;

Map angle in degrees at which the camera is looking at the ground

property zoom

zoom?: number | undefined;

Map zoom level

interface CanonicalCoordinate

interface CanonicalCoordinate {}

property key

key: number;

property x

x: number;

property y

y: number;

property z

z: number;

method equals

equals: (coord: CanonicalCoordinate) => boolean;

interface CanvasSourceOptions

interface CanvasSourceOptions {}

property animate

animate?: boolean | undefined;

property canvas

canvas: string | HTMLCanvasElement;

property coordinates

coordinates: number[][];

interface CanvasSourceRaw

interface CanvasSourceRaw extends Source, CanvasSourceOptions {}

CanvasSource

property type

type: 'canvas';

interface CircleLayer

interface CircleLayer extends Layer {}

property layout

layout?: CircleLayout | undefined;

property paint

paint?: CirclePaint | undefined;

property type

type: 'circle';

interface CircleLayout

interface CircleLayout extends Layout {}

property "circle-sort-key"

'circle-sort-key'?: number | Expression | undefined;

interface CirclePaint

interface CirclePaint {}

property "circle-blur-transition"

'circle-blur-transition'?: Transition | undefined;

property "circle-blur"

'circle-blur'?: number | StyleFunction | Expression | undefined;

property "circle-color-transition"

'circle-color-transition'?: Transition | undefined;

property "circle-color"

'circle-color'?: string | StyleFunction | Expression | undefined;

property "circle-emissive-strength"

'circle-emissive-strength'?: number | StyleFunction | Expression | undefined;

property "circle-opacity-transition"

'circle-opacity-transition'?: Transition | undefined;

property "circle-opacity"

'circle-opacity'?: number | StyleFunction | Expression | undefined;

property "circle-pitch-alignment"

'circle-pitch-alignment'?: 'map' | 'viewport' | undefined;

property "circle-pitch-scale"

'circle-pitch-scale'?: 'map' | 'viewport' | undefined;

property "circle-radius-transition"

'circle-radius-transition'?: Transition | undefined;

property "circle-radius"

'circle-radius'?: number | StyleFunction | Expression | undefined;

property "circle-stroke-color-transition"

'circle-stroke-color-transition'?: Transition | undefined;

property "circle-stroke-color"

'circle-stroke-color'?: string | StyleFunction | Expression | undefined;

property "circle-stroke-opacity-transition"

'circle-stroke-opacity-transition'?: Transition | undefined;

property "circle-stroke-opacity"

'circle-stroke-opacity'?: number | StyleFunction | Expression | undefined;

property "circle-stroke-width-transition"

'circle-stroke-width-transition'?: Transition | undefined;

property "circle-stroke-width"

'circle-stroke-width'?: number | StyleFunction | Expression | undefined;

property "circle-translate-anchor"

'circle-translate-anchor'?: 'map' | 'viewport' | undefined;

property "circle-translate-transition"

'circle-translate-transition'?: Transition | undefined;

property "circle-translate"

'circle-translate'?: number[] | Expression | undefined;

interface Coordinate

interface Coordinate {}

property canonical

canonical: CanonicalCoordinate;

property key

key: number;

property wrap

wrap: number;

interface CustomLayerInterface

interface CustomLayerInterface {}

property id

id: string;

A unique layer id.

property renderingMode

renderingMode?: '2d' | '3d' | undefined;

property type

type: 'custom';

method onAdd

onAdd: (map: Map, gl: WebGLRenderingContext) => void;

Optional method called when the layer has been added to the Map with Map#addLayer. This gives the layer a chance to initialize gl resources and register event listeners.
Parameter map
The Map this custom layer was just added to.
Parameter gl
The gl context for the map.

method onRemove

onRemove: (map: Map, gl: WebGLRenderingContext) => void;

Optional method called when the layer has been removed from the Map with Map#removeLayer. This gives the layer a chance to clean up gl resources and event listeners.
Parameter map
The Map this custom layer was just added to.
Parameter gl
The gl context for the map.

method prerender

prerender: (gl: WebGLRenderingContext, matrix: number[]) => void;

Optional method called during a render frame to allow a layer to prepare resources or render into a texture.
The layer cannot make any assumptions about the current GL state and must bind a framebuffer before rendering.
Parameter gl
The map's gl context.
Parameter matrix
The map's camera matrix. It projects spherical mercator coordinates to gl coordinates. The mercator coordinate [0, 0] represents the top left corner of the mercator world and [1, 1] represents the bottom right corner. When the renderingMode is "3d" , the z coordinate is conformal. A box with identical x, y, and z lengths in mercator units would be rendered as a cube. MercatorCoordinate .fromLatLng can be used to project a LngLat to a mercator coordinate.

method render

render: (gl: WebGLRenderingContext, matrix: number[]) => void;

Called during a render frame allowing the layer to draw into the GL context.
The layer can assume blending and depth state is set to allow the layer to properly blend and clip other layers. The layer cannot make any other assumptions about the current GL state.
If the layer needs to render to a texture, it should implement the prerender method to do this and only use the render method for drawing directly into the main framebuffer.
The blend function is set to gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA). This expects colors to be provided in premultiplied alpha form where the r, g and b values are already multiplied by the a value. If you are unable to provide colors in premultiplied form you may want to change the blend function to gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA).
Parameter gl
The map's gl context.
Parameter matrix
The map's camera matrix. It projects spherical mercator coordinates to gl coordinates. The mercator coordinate [0, 0] represents the top left corner of the mercator world and [1, 1] represents the bottom right corner. When the renderingMode is "3d" , the z coordinate is conformal. A box with identical x, y, and z lengths in mercator units would be rendered as a cube. MercatorCoordinate .fromLatLng can be used to project a LngLat to a mercator coordinate.

interface CustomSource

interface CustomSource<T> extends Source {}

property attribution

attribution: string;

property id

id: string;

property maxzoom

maxzoom: number;

property minzoom

minzoom: number;

property scheme

scheme: string;

property tileSize

tileSize: number;

property type

type: 'custom';

interface CustomSourceInterface

interface CustomSourceInterface<T> {}

property attribution

attribution?: string;

property bounds

bounds?: [number, number, number, number];

property dataType

dataType: 'raster';

property hasTile

hasTile?: (tileID: { z: number; x: number; y: number }) => boolean;

property id

id: string;

property loadTile

loadTile: (
    tileID: { z: number; x: number; y: number },
    options: { signal: AbortSignal }
) => Promise<T>;

property maxzoom

maxzoom?: number;

property minzoom

minzoom?: number;

property onAdd

onAdd?: (map: Map) => void;

property onRemove

onRemove?: (map: Map) => void;

property prepareTile

prepareTile?: (tileID: { z: number; x: number; y: number }) => T | undefined;

property scheme

scheme?: string;

property tileSize

tileSize?: number;

property type

type: 'custom';

property unloadTile

unloadTile?: (tileID: { z: number; x: number; y: number }) => void;

interface EaseToOptions

interface EaseToOptions extends AnimationOptions, CameraOptions {}

EaseToOptions

property delayEndEvents

delayEndEvents?: number | undefined;

interface FeatureIdentifier

interface FeatureIdentifier {}

property id

id?: string | number | undefined;

property source

source: string;

property sourceLayer

sourceLayer?: string | undefined;

interface FillExtrusionLayer

interface FillExtrusionLayer extends Layer {}

property layout

layout?: FillExtrusionLayout | undefined;

property paint

paint?: FillExtrusionPaint | undefined;

property type

type: 'fill-extrusion';

interface FillExtrusionLayout

interface FillExtrusionLayout extends Layout {}

interface FillExtrusionPaint

interface FillExtrusionPaint {}

property "fill-extrusion-base-transition"

'fill-extrusion-base-transition'?: Transition | undefined;

property "fill-extrusion-base"

'fill-extrusion-base'?: number | StyleFunction | Expression | undefined;

property "fill-extrusion-color-transition"

'fill-extrusion-color-transition'?: Transition | undefined;

property "fill-extrusion-color"

'fill-extrusion-color'?: string | StyleFunction | Expression | undefined;

property "fill-extrusion-height-transition"

'fill-extrusion-height-transition'?: Transition | undefined;

property "fill-extrusion-height"

'fill-extrusion-height'?: number | StyleFunction | Expression | undefined;

property "fill-extrusion-opacity-transition"

'fill-extrusion-opacity-transition'?: Transition | undefined;

property "fill-extrusion-opacity"

'fill-extrusion-opacity'?: number | Expression | undefined;

property "fill-extrusion-pattern-transition"

'fill-extrusion-pattern-transition'?: Transition | undefined;

property "fill-extrusion-pattern"

'fill-extrusion-pattern'?: string | Expression | undefined;

property "fill-extrusion-translate-anchor"

'fill-extrusion-translate-anchor'?: 'map' | 'viewport' | undefined;

property "fill-extrusion-translate-transition"

'fill-extrusion-translate-transition'?: Transition | undefined;

property "fill-extrusion-translate"

'fill-extrusion-translate'?: number[] | Expression | undefined;

property "fill-extrusion-vertical-gradient"

'fill-extrusion-vertical-gradient'?: boolean | undefined;

interface FillLayer

interface FillLayer extends Layer {}

property layout

layout?: FillLayout | undefined;

property paint

paint?: FillPaint | undefined;

property type

type: 'fill';

interface FillLayout

interface FillLayout extends Layout {}

property "fill-sort-key"

'fill-sort-key'?: number | Expression | undefined;

interface FillPaint

interface FillPaint {}

property "fill-antialias"

'fill-antialias'?: boolean | Expression | undefined;

property "fill-color-transition"

'fill-color-transition'?: Transition | undefined;

property "fill-color"

'fill-color'?: string | StyleFunction | Expression | undefined;

property "fill-emissive-strength"

'fill-emissive-strength'?: number | Expression | undefined;

property "fill-extrusion-ambient-occlusion-ground-attenuation"

'fill-extrusion-ambient-occlusion-ground-attenuation'?:
    | number
    | Expression
    | undefined;

property "fill-extrusion-ambient-occlusion-ground-radius"

'fill-extrusion-ambient-occlusion-ground-radius'?:
    | number
    | Expression
    | undefined;

property "fill-extrusion-ambient-occlusion-wall-radius"

'fill-extrusion-ambient-occlusion-wall-radius'?: number | Expression | undefined;

property "fill-extrusion-flood-light-color"

'fill-extrusion-flood-light-color'?:
    | string
    | StyleFunction
    | Expression
    | undefined;

property "fill-extrusion-flood-light-ground-attenuation"

'fill-extrusion-flood-light-ground-attenuation'?:
    | number
    | Expression
    | undefined;

property "fill-extrusion-flood-light-ground-radius"

'fill-extrusion-flood-light-ground-radius'?: number | Expression | undefined;

property "fill-extrusion-flood-light-intensity"

'fill-extrusion-flood-light-intensity'?: number | Expression | undefined;

property "fill-extrusion-flood-light-wall-radius"

'fill-extrusion-flood-light-wall-radius'?: number | Expression | undefined;

property "fill-extrusion-vertical-scale"

'fill-extrusion-vertical-scale'?: number | Expression | undefined;

property "fill-opacity-transition"

'fill-opacity-transition'?: Transition | undefined;

property "fill-opacity"

'fill-opacity'?: number | StyleFunction | Expression | undefined;

property "fill-outline-color-transition"

'fill-outline-color-transition'?: Transition | undefined;

property "fill-outline-color"

'fill-outline-color'?: string | StyleFunction | Expression | undefined;

property "fill-pattern-transition"

'fill-pattern-transition'?: Transition | undefined;

property "fill-pattern"

'fill-pattern'?: string | Expression | undefined;

property "fill-translate-anchor"

'fill-translate-anchor'?: 'map' | 'viewport' | undefined;

property "fill-translate-transition"

'fill-translate-transition'?: Transition | undefined;

property "fill-translate"

'fill-translate'?: number[] | undefined;

interface FilterOptions {}

FilterOptions

validate?: boolean | null | undefined;

Whether to check if the filter conforms to the Mapbox GL Style Specification. Disabling validation is a performance optimization that should only be used if you have previously validated the values you will be passing to this function.

interface FitBoundsOptions

interface FitBoundsOptions extends mapboxgl.FlyToOptions {}

property linear

linear?: boolean

@types/mapbox-gl

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable accessToken

variable baseApiUrl

variable maxParallelImageRequests

variable version

variable workerCount

Functions

function clearPrewarmedResources

function clearStorage

function getRTLTextPluginStatus

function prewarm

function setRTLTextPlugin

function supported

Classes

class AttributionControl

class BoxZoomHandler

method disable

method enable

method isActive

method isEnabled

class CanvasSource

property canvas

property coordinates

property type

method getCanvas

method pause

method play

method setCoordinates

class Control

property getDefaultPosition

method onAdd

method onRemove

class DoubleClickZoomHandler

method disable

method enable

method isEnabled

class DragPanHandler

method disable

method enable

method isActive

method isEnabled

class DragRotateHandler

method disable

method enable

method isActive

method isEnabled

class ErrorEvent

property error

property type

class Evented

method fire

method off

method on

method once

class FreeCameraOptions

Parameter position

Parameter orientation

property position

method lookAtPoint

Parameter location

Parameter up

method setPitchBearing

Parameter pitch

Parameter bearing

class FullscreenControl

class GeoJSONSource

property type

method getClusterChildren

method getClusterExpansionZoom

method getClusterLeaves

method setData