@types/ol

Version 6.5.3
Published 10 months ago
651 kB
4 dependencies
MIT license

Install

npm i @types/ol

yarn add @types/ol

pnpm add @types/ol

Overview

TypeScript definitions for ol

Index

Variables

variable VERSION

const VERSION: string;

OpenLayers version.

Functions

function getUid

getUid: (obj: any) => string;

Gets a unique ID for an object. This mutates the object so that further calls with the same object as a parameter returns the same value. Unique IDs are generated as a strictly increasing sequence. Adapted from goog.getUid.

Classes

class AssertionError

class AssertionError extends Error {}

constructor

constructor(code: number);

property code

code: number;

Error code. The meaning of the code can be found on https://openlayers.org/en/latest/doc/errors/ (replace latest with the version found in the OpenLayers script's header comment if a version other than the latest is used).

class Collection

class Collection<T> extends BaseObject {}

constructor

constructor(opt_array?: T[], opt_options?: Options);

method clear

clear: () => void;

Remove all elements from the collection.

method extend

extend: (arr: T[]) => Collection<T>;

Add elements to the collection. This pushes each item in the provided array to the end of the collection.

method forEach

forEach: (f: (p0: T, p1: number, p2: T[]) => any) => void;

Iterate over each element, calling the provided callback.

method getArray

getArray: () => T[];

Get a reference to the underlying Array object. Warning: if the array is mutated, no events will be dispatched by the collection, and the collection's "length" property won't be in sync with the actual length of the array.

method getLength

getLength: () => number;

Get the length of this collection.

method insertAt

insertAt: (index: number, elem: T) => void;

Insert an element at the provided index.

method item

item: (index: number) => T;

Get the element at the provided index.

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'add', listener: (evt: CollectionEvent<T>) => void): EventsKey;
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:length', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'remove', listener: (evt: CollectionEvent<T>) => void): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'add', listener: (evt: CollectionEvent<T>) => void): EventsKey;
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:length', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'remove', listener: (evt: CollectionEvent<T>) => void): EventsKey;
};

method pop

pop: () => T | undefined;

Remove the last element of the collection and return it. Return undefined if the collection is empty.

method push

push: (elem: T) => number;

Insert the provided element at the end of the collection.

method remove

remove: (elem: T) => T | undefined;

Remove the first occurrence of an element from the collection.

method removeAt

removeAt: (index: number) => T | undefined;

Remove the element at the provided index and return it. Return undefined if the collection does not contain this index.

method setAt

setAt: (index: number, elem: T) => void;

Set the element at the provided index.

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'add', listener: (evt: CollectionEvent<T>) => void): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'change:length', listener: (evt: ObjectEvent) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
    (type: 'remove', listener: (evt: CollectionEvent<T>) => void): void;
};

class Disposable

class Disposable {}

constructor

constructor();

property disposed

protected disposed: boolean;

The object has already been disposed.

method dispose

dispose: () => void;

Clean up.

method disposeInternal

protected disposeInternal: () => void;

Extension point for disposable objects.

class Feature

class Feature<GeomType extends Geometry = Geometry> extends BaseObject {}

constructor

constructor(opt_geometryOrProperties?: GeomType | { [key: string]: any });

method clone

clone: () => Feature<Geometry>;

Clone this feature. If the original feature has a geometry it is also cloned. The feature id is not set in the clone.

method getGeometry

getGeometry: () => GeomType | undefined;

Get the feature's default geometry. A feature may have any number of named geometries. The "default" geometry (the one that is rendered by default) is set when calling .

method getGeometryName

getGeometryName: () => string;

Get the name of the feature's default geometry. By default, the default geometry is named geometry.

method getId

getId: () => number | string | undefined;

Get the feature identifier. This is a stable identifier for the feature and is either set when reading data from a remote source or set explicitly by calling .

method getStyle

getStyle: () => StyleLike | undefined;

Get the feature's style. Will return what was provided to the method.

method getStyleFunction

getStyleFunction: () => StyleFunction | undefined;

Get the feature's style function.

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:geometry', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:geometry', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method setGeometry

setGeometry: (geometry: GeomType | undefined) => void;

Set the default geometry for the feature. This will update the property with the name returned by .

method setGeometryName

setGeometryName: (name: string) => void;

Set the property name to be used when getting the feature's default geometry. When calling , the value of the property with this name will be returned.

method setId

setId: (id: number | string | undefined) => void;

Set the feature id. The feature id is considered stable and may be used when requesting features or comparing identifiers returned from a remote source. The feature id can be used with the method.

method setStyle

setStyle: (opt_style?: StyleLike) => void;

Set the style for the feature to override the layer style. This can be a single style object, an array of styles, or a function that takes a resolution and returns an array of styles. To unset the feature style, call setStyle() without arguments or a falsey value.

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'change:geometry', listener: (evt: ObjectEvent) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
};

class Geolocation

class Geolocation extends BaseObject {}

constructor

constructor(opt_options?: Options);

method disposeInternal

disposeInternal: () => void;

Clean up.

method getAccuracy

getAccuracy: () => number | undefined;

Get the accuracy of the position in meters.

method getAccuracyGeometry

getAccuracyGeometry: () => Polygon;

Get a geometry of the position accuracy.

method getAltitude

getAltitude: () => number | undefined;

Get the altitude associated with the position.

method getAltitudeAccuracy

getAltitudeAccuracy: () => number | undefined;

Get the altitude accuracy of the position.

method getHeading

getHeading: () => number | undefined;

Get the heading as radians clockwise from North. Note: depending on the browser, the heading is only defined if the enableHighAccuracy is set to true in the tracking options.

method getPosition

getPosition: () => Coordinate | undefined;

Get the position of the device.

method getProjection

getProjection: () => Projection | undefined;

Get the projection associated with the position.

method getSpeed

getSpeed: () => number | undefined;

Get the speed in meters per second.

method getTracking

getTracking: () => boolean;

Determine if the device location is being tracked.

method getTrackingOptions

getTrackingOptions: () => PositionOptions | undefined;

Get the tracking options. See http://www.w3.org/TR/geolocation-API/#position-options.

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:accuracy', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:accuracyGeometry',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'change:altitude', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:altitudeAccuracy',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'change:heading', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:projection', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:speed', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:tracking', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:trackingOptions',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'error', listener: (evt: GeolocationError) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:accuracy', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:accuracyGeometry',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'change:altitude', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:altitudeAccuracy',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'change:heading', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:projection', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:speed', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:tracking', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:trackingOptions',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'error', listener: (evt: GeolocationError) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method setProjection

setProjection: (projection: ProjectionLike) => void;

Set the projection to use for transforming the coordinates.

method setTracking

setTracking: (tracking: boolean) => void;

Enable or disable tracking.

method setTrackingOptions

setTrackingOptions: (options: PositionOptions) => void;

Set the tracking options. See http://www.w3.org/TR/geolocation-API/#position-options.

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'change:accuracy', listener: (evt: ObjectEvent) => void): void;
    (
        type: 'change:accuracyGeometry',
        listener: (evt: ObjectEvent) => void
    ): void;
    (type: 'change:altitude', listener: (evt: ObjectEvent) => void): void;
    (
        type: 'change:altitudeAccuracy',
        listener: (evt: ObjectEvent) => void
    ): void;
    (type: 'change:heading', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:position', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:projection', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:speed', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:tracking', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:trackingOptions', listener: (evt: ObjectEvent) => void): void;
    (type: 'error', listener: (evt: GeolocationError) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
};

class Graticule

class Graticule extends VectorLayer {}

constructor

constructor(opt_options?: Options);

method getMeridians

getMeridians: () => LineString[];

Get the list of meridians. Meridians are lines of equal longitude.

method getParallels

getParallels: () => LineString[];

Get the list of parallels. Parallels are lines of equal latitude.

method loaderFunction

loaderFunction: (
    extent: Extent,
    resolution: number,
    projection: Projection
) => void;

Update geometries in the source based on current view

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:maxResolution',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'change:maxZoom', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:minResolution',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'change:minZoom', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'postrender', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'prerender', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:maxResolution',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'change:maxZoom', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:minResolution',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'change:minZoom', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'postrender', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'prerender', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
};

method strategyFunction

strategyFunction: (extent: Extent, resolution: number) => Extent[];

Strategy function for loading features based on the view's extent and resolution.

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'change:extent', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:maxZoom', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:minZoom', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:opacity', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:source', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:visible', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): void;
    (type: 'postrender', listener: (evt: RenderEvent) => void): void;
    (type: 'precompose', listener: (evt: RenderEvent) => void): void;
    (type: 'prerender', listener: (evt: RenderEvent) => void): void;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): void;
};

class Image

class ImageWrapper extends ImageBase {}

constructor

constructor(
    extent: Extent,
    resolution: number,
    pixelRatio: number,
    src: string,
    crossOrigin: string,
    imageLoadFunction: LoadFunction
);

property state

protected state: ImageState;

method getImage

getImage: () => HTMLCanvasElement | HTMLImageElement | HTMLVideoElement;

method load

load: () => void;

Load the image or retry if loading previously failed. Loading is taken care of by the tile queue, and calling this method is only needed for preloading or for reloading in case of an error.

method setImage

setImage: (
    image: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement
) => void;

class ImageBase

abstract class ImageBase extends Target {}

constructor

constructor(
    extent: Extent,
    resolution: number,
    pixelRatio: number,
    state: ImageState
);

property extent

protected extent: Extent;

property resolution

protected resolution: number;

property state

protected state: ImageState;

method changed

protected changed: () => void;

method getExtent

getExtent: () => Extent;

method getImage

abstract getImage: () => HTMLCanvasElement | HTMLImageElement | HTMLVideoElement;

method getPixelRatio

getPixelRatio: () => number;

method getResolution

getResolution: () => number;

method getState

getState: () => ImageState;

method load

abstract load: () => void;

Load not yet loaded URI.

class ImageCanvas

class ImageCanvas extends ImageBase {}

constructor

constructor(
    extent: Extent,
    resolution: number,
    pixelRatio: number,
    canvas: HTMLCanvasElement,
    opt_loader?: Loader
);

method getError

getError: () => Error;

Get any error associated with asynchronous rendering.

method getImage

getImage: () => HTMLCanvasElement;

method load

load: () => void;

Load not yet loaded URI.

class ImageTile

class ImageTile extends Tile {}

constructor

constructor(
    tileCoord: TileCoord,
    state: TileState,
    src: string,
    crossOrigin: string,
    tileLoadFunction: LoadFunction,
    opt_options?: Options
);

method getImage

getImage: () => HTMLCanvasElement | HTMLImageElement | HTMLVideoElement;

Get the HTML image element for this tile (may be a Canvas, Image, or Video).

method load

load: () => void;

Load not yet loaded URI.

class Kinetic

class Kinetic {}

constructor

constructor(decay: number, minVelocity: number, delay: number);

method begin

begin: () => void;

FIXME empty description for jsdoc

method end

end: () => boolean;

method getAngle

getAngle: () => number;

method getDistance

getDistance: () => number;

method update

update: (x: number, y: number) => void;

class Map

class Map extends PluggableMap {}

constructor

constructor(options: MapOptions);

method createRenderer

createRenderer: () => MapRenderer;

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'click',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (
        type: 'dblclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'moveend', listener: (evt: MapEvent) => void): EventsKey;
    (type: 'movestart', listener: (evt: MapEvent) => void): EventsKey;
    (
        type: 'pointerdrag',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (
        type: 'pointermove',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'postrender', listener: (evt: MapEvent) => void): EventsKey;
    (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
    (
        type: 'singleclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'click',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (
        type: 'dblclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'moveend', listener: (evt: MapEvent) => void): EventsKey;
    (type: 'movestart', listener: (evt: MapEvent) => void): EventsKey;
    (
        type: 'pointerdrag',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (
        type: 'pointermove',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'postrender', listener: (evt: MapEvent) => void): EventsKey;
    (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
    (
        type: 'singleclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
};

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:size', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:target', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:view', listener: (evt: ObjectEvent) => void): void;
    (type: 'click', listener: (evt: MapBrowserEvent<UIEvent>) => void): void;
    (type: 'dblclick', listener: (evt: MapBrowserEvent<UIEvent>) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
    (type: 'moveend', listener: (evt: MapEvent) => void): void;
    (type: 'movestart', listener: (evt: MapEvent) => void): void;
    (
        type: 'pointerdrag',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): void;
    (
        type: 'pointermove',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): void;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): void;
    (type: 'postrender', listener: (evt: MapEvent) => void): void;
    (type: 'precompose', listener: (evt: RenderEvent) => void): void;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): void;
    (
        type: 'singleclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): void;
};

class MapBrowserEvent

class MapBrowserEvent<EVENT extends UIEvent = UIEvent> extends MapEvent {}

constructor

constructor(
    type: string,
    map: PluggableMap,
    originalEvent: UIEvent,
    opt_dragging?: boolean,
    opt_frameState?: FrameState
);

property coordinate

coordinate: Coordinate;

The coordinate corresponding to the original browser event. This will be in the user projection if one is set. Otherwise it will be in the view projection.

property dragging

dragging: boolean;

Indicates if the map is currently being dragged. Only set for POINTERDRAG and POINTERMOVE events. Default is false.

property originalEvent

originalEvent: UIEvent;

The original browser event.

property pixel

pixel: Pixel;

The map pixel relative to the viewport corresponding to the original event.

method preventDefault

preventDefault: () => void;

Prevents the default browser action. See https://developer.mozilla.org/en-US/docs/Web/API/event.preventDefault.

method stopPropagation

stopPropagation: () => void;

Prevents further propagation of the current event. See https://developer.mozilla.org/en-US/docs/Web/API/event.stopPropagation.

class MapBrowserEventHandler

class MapBrowserEventHandler extends Target {}

constructor

constructor(map: PluggableMap, moveTolerance?: number);

method disposeInternal

disposeInternal: () => void;

Clean up.

class MapEvent

class MapEvent extends BaseEvent {}

constructor

constructor(type: string, map: PluggableMap, opt_frameState?: FrameState);

property frameState

frameState: FrameState;

The frame state at the time of the event.

property map

map: PluggableMap;

The map where the event occurred.

class Object

class BaseObject extends Observable {}

constructor

constructor(opt_values?: { [key: string]: any });

method applyProperties

protected applyProperties: (source: BaseObject) => void;

Apply any properties from another object without triggering events.

method get

get: (key: string) => any;

Gets a value.

method getKeys

getKeys: () => string[];

Get a list of object property names.

method getProperties

getProperties: () => { [key: string]: any };

Get an object of all property names and values.

method hasProperties

hasProperties: () => boolean;

method notify

notify: (key: string, oldValue: any) => void;

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method set

set: (key: string, value: any, opt_silent?: boolean) => void;

Sets a value.

method setProperties

setProperties: (values: { [key: string]: any }, opt_silent?: boolean) => void;

Sets a collection of key-value pairs. Note that this changes any existing properties and adds new ones (it does not remove any existing properties).

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
};

method unset

unset: (key: string, opt_silent?: boolean) => void;

Unsets a property.

class Observable

class Observable extends Target {}

constructor

constructor();

method changed

changed: () => void;

Increases the revision counter and dispatches a 'change' event.

method getRevision

getRevision: () => number;

Get the version number for this object. Each time the object is modified, its version number will be incremented.

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
};

Listen for a certain type of event.

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
};

Listen once for a certain type of event.

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
};

Unlisten for a certain type of event.

class Overlay

class Overlay extends BaseObject {}

constructor

constructor(options: Options);

property autoPan

protected autoPan: false | PanIntoViewOptions;

property element

protected element: HTMLElement;

property id

protected id: string | number;

property insertFirst

protected insertFirst: boolean;

property mapPostrenderListenerKey

protected mapPostrenderListenerKey: EventsKey;

property options

protected options: Options;

property rendered

protected rendered: any;

property stopEvent

protected stopEvent: boolean;

method getElement

getElement: () => HTMLElement | undefined;

Get the DOM element of this overlay.

method getId

getId: () => number | string | undefined;

Get the overlay identifier which is set on constructor.

method getMap

getMap: () => PluggableMap | undefined;

Get the map associated with this overlay.

method getOffset

getOffset: () => number[];

Get the offset of this overlay.

method getOptions

getOptions: () => Options;

returns the options this Overlay has been created with

method getPosition

getPosition: () => Coordinate | undefined;

Get the current position of this overlay.

method getPositioning

getPositioning: () => OverlayPositioning;

Get the current positioning of this overlay.

method getRect

protected getRect: (element: HTMLElement, size: Size) => Extent;

Get the extent of an element relative to the document

method handleElementChanged

protected handleElementChanged: () => void;

method handleMapChanged

protected handleMapChanged: () => void;

method handleOffsetChanged

protected handleOffsetChanged: () => void;

method handlePositionChanged

protected handlePositionChanged: () => void;

method handlePositioningChanged

protected handlePositioningChanged: () => void;

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:element', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:map', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:offset', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:positioning',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:element', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:map', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:offset', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'change:positioning',
        listener: (evt: ObjectEvent) => void
    ): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method panIntoView

panIntoView: (opt_panIntoViewOptions?: PanIntoViewOptions) => void;

Pan the map so that the overlay is entirely visible in the current viewport (if necessary).

method performAutoPan

protected performAutoPan: () => void;

Pan the map so that the overlay is entirely visisble in the current viewport (if necessary) using the configured autoPan parameters

method render

protected render: () => void;

method setElement

setElement: (element: HTMLElement | undefined) => void;

Set the DOM element to be associated with this overlay.

method setMap

setMap: (map: PluggableMap | undefined) => void;

Set the map to be associated with this overlay.

method setOffset

setOffset: (offset: number[]) => void;

Set the offset for this overlay.

method setPosition

setPosition: (position: Coordinate | undefined) => void;

Set the position for this overlay. If the position is undefined the overlay is hidden.

method setPositioning

setPositioning: (positioning: OverlayPositioning) => void;

Set the positioning for this overlay.

method setVisible

protected setVisible: (visible: boolean) => void;

Modify the visibility of the element.

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'change:element', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:map', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:offset', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:position', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:positioning', listener: (evt: ObjectEvent) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
};

method updatePixelPosition

protected updatePixelPosition: () => void;

Update pixel position.

method updateRenderedPosition

protected updateRenderedPosition: (
    pixel: Pixel,
    mapSize: Size | undefined
) => void;

class PluggableMap

class PluggableMap extends BaseObject {}

constructor

constructor(options: MapOptions);

property controls

protected controls: Collection<Control>;

property interactions

protected interactions: Collection<Interaction>;

method addControl

addControl: (control: Control) => void;

Add the given control to the map.

method addInteraction

addInteraction: (interaction: Interaction) => void;

Add the given interaction to the map. If you want to add an interaction at another point of the collection use getInteraction() and the methods available on . This can be used to stop the event propagation from the handleEvent function. The interactions get to handle the events in the reverse order of this collection.

method addLayer

addLayer: (layer: BaseLayer) => void;

Adds the given layer to the top of this map. If you want to add a layer elsewhere in the stack, use getLayers() and the methods available on .

method addOverlay

addOverlay: (overlay: Overlay) => void;

Add the given overlay to the map.

method createRenderer

createRenderer: () => MapRenderer;

method disposeInternal

disposeInternal: () => void;

Clean up.

method forEachFeatureAtPixel

forEachFeatureAtPixel: <S, T>(
    pixel: Pixel,
    callback: (p0: FeatureLike, p1: Layer<Source>, p2: SimpleGeometry) => T,
    opt_options?: AtPixelOptions
) => T | undefined;

Detect features that intersect a pixel on the viewport, and execute a callback with each intersecting feature. Layers included in the detection can be configured through the layerFilter option in opt_options.

method forEachLayerAtPixel

forEachLayerAtPixel: <S, T>(
    pixel: Pixel,
    callback: (
        this: S,
        p0: Layer<Source>,
        p1: Uint8ClampedArray | Uint8Array
    ) => T,
    opt_options?: AtPixelOptions
) => T | undefined;

Detect layers that have a color value at a pixel on the viewport, and execute a callback with each matching layer. Layers included in the detection can be configured through opt_layerFilter. Note: this may give false positives unless the map layers have had different className properties assigned to them.

method getControls

getControls: () => Collection<Control>;

Get the map controls. Modifying this collection changes the controls associated with the map.

method getCoordinateFromPixel

getCoordinateFromPixel: (pixel: Pixel) => Coordinate;

Get the coordinate for a given pixel. This returns a coordinate in the user projection.

method getCoordinateFromPixelInternal

getCoordinateFromPixelInternal: (pixel: Pixel) => Coordinate;

Get the coordinate for a given pixel. This returns a coordinate in the map view projection.

method getEventCoordinate

getEventCoordinate: (event: MouseEvent) => Coordinate;

Returns the coordinate in user projection for a browser event.

method getEventCoordinateInternal

getEventCoordinateInternal: (event: MouseEvent) => Coordinate;

Returns the coordinate in view projection for a browser event.

method getEventPixel

getEventPixel: (event: UIEvent) => Pixel;

Returns the map pixel position for a browser event relative to the viewport.

method getFeaturesAtPixel

getFeaturesAtPixel: (
    pixel: Pixel,
    opt_options?: AtPixelOptions
) => FeatureLike[];

Get all features that intersect a pixel on the viewport.

method getInteractions

getInteractions: () => Collection<Interaction>;

Get the map interactions. Modifying this collection changes the interactions associated with the map. Interactions are used for e.g. pan, zoom and rotate.

method getLayerGroup

getLayerGroup: () => LayerGroup;

Get the layergroup associated with this map.

method getLayers

getLayers: () => Collection<BaseLayer>;

Get the collection of layers associated with this map.

method getLoading

getLoading: () => boolean;

method getOverlayById

getOverlayById: (id: string | number) => Overlay;

Get an overlay by its identifier (the value returned by overlay.getId()). Note that the index treats string and numeric identifiers as the same. So map.getOverlayById(2) will return an overlay with id '2' or 2.

method getOverlayContainer

getOverlayContainer: () => HTMLElement;

Get the element that serves as the container for overlays. Elements added to this container will let mousedown and touchstart events through to the map, so clicks and gestures on an overlay will trigger events.

method getOverlayContainerStopEvent

getOverlayContainerStopEvent: () => HTMLElement;

Get the element that serves as a container for overlays that don't allow event propagation. Elements added to this container won't let mousedown and touchstart events through to the map, so clicks and gestures on an overlay don't trigger any .

method getOverlays

getOverlays: () => Collection<Overlay>;

Get the map overlays. Modifying this collection changes the overlays associated with the map.

method getOwnerDocument

getOwnerDocument: () => Document;

method getPixelFromCoordinate

getPixelFromCoordinate: (coordinate: Coordinate) => Pixel;

Get the pixel for a coordinate. This takes a coordinate in the user projection and returns the corresponding pixel.

method getPixelFromCoordinateInternal

getPixelFromCoordinateInternal: (coordinate: Coordinate) => Pixel;

Get the pixel for a coordinate. This takes a coordinate in the map view projection and returns the corresponding pixel.

method getRenderer

getRenderer: () => MapRenderer;

Get the map renderer.

method getSize

getSize: () => Size | undefined;

Get the size of this map.

method getTarget

getTarget: () => HTMLElement | string | undefined;

Get the target in which this map is rendered. Note that this returns what is entered as an option or in setTarget: if that was an element, it returns an element; if a string, it returns that.

method getTargetElement

getTargetElement: () => HTMLElement;

Get the DOM element into which this map is rendered. In contrast to getTarget this method always return an Element, or null if the map has no target.

method getTilePriority

getTilePriority: (
    tile: Tile,
    tileSourceKey: string,
    tileCenter: Coordinate,
    tileResolution: number
) => number;

method getView

getView: () => View;

Get the view associated with this map. A view manages properties such as center and resolution.

method getViewport

getViewport: () => HTMLElement;

Get the element that serves as the map viewport.

method handleBrowserEvent

handleBrowserEvent: (browserEvent: UIEvent, opt_type?: string) => void;

method handleMapBrowserEvent

handleMapBrowserEvent: (mapBrowserEvent: MapBrowserEvent<UIEvent>) => void;

method handlePostRender

protected handlePostRender: () => void;

method hasFeatureAtPixel

hasFeatureAtPixel: (pixel: Pixel, opt_options?: AtPixelOptions) => boolean;

Detect if features intersect a pixel on the viewport. Layers included in the detection can be configured through opt_layerFilter.

method isRendered

isRendered: () => boolean;

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'click',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (
        type: 'dblclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'moveend', listener: (evt: MapEvent) => void): EventsKey;
    (type: 'movestart', listener: (evt: MapEvent) => void): EventsKey;
    (
        type: 'pointerdrag',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (
        type: 'pointermove',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'postrender', listener: (evt: MapEvent) => void): EventsKey;
    (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
    (
        type: 'singleclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey;
    (
        type: 'click',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (
        type: 'dblclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'moveend', listener: (evt: MapEvent) => void): EventsKey;
    (type: 'movestart', listener: (evt: MapEvent) => void): EventsKey;
    (
        type: 'pointerdrag',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (
        type: 'pointermove',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'postrender', listener: (evt: MapEvent) => void): EventsKey;
    (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
    (
        type: 'singleclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): EventsKey;
};

method redrawText

redrawText: () => void;

Redraws all text after new fonts have loaded

method removeControl

removeControl: (control: Control) => Control | undefined;

Remove the given control from the map.

method removeInteraction

removeInteraction: (interaction: Interaction) => Interaction | undefined;

Remove the given interaction from the map.

method removeLayer

removeLayer: (layer: BaseLayer) => BaseLayer | undefined;

Removes the given layer from the map.

method removeOverlay

removeOverlay: (overlay: Overlay) => Overlay | undefined;

Remove the given overlay from the map.

method render

render: () => void;

Request a map rendering (at the next animation frame).

method renderSync

renderSync: () => void;

Requests an immediate render in a synchronous manner.

method setLayerGroup

setLayerGroup: (layerGroup: LayerGroup) => void;

Sets the layergroup of this map.

method setSize

setSize: (size: Size | undefined) => void;

Set the size of this map.

method setTarget

setTarget: (target: HTMLElement | string | undefined) => void;

Set the target element to render this map into.

method setView

setView: (view: View) => void;

Set the view for this map.

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:size', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:target', listener: (evt: ObjectEvent) => void): void;
    (type: 'change:view', listener: (evt: ObjectEvent) => void): void;
    (type: 'click', listener: (evt: MapBrowserEvent<UIEvent>) => void): void;
    (type: 'dblclick', listener: (evt: MapBrowserEvent<UIEvent>) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
    (type: 'moveend', listener: (evt: MapEvent) => void): void;
    (type: 'movestart', listener: (evt: MapEvent) => void): void;
    (
        type: 'pointerdrag',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): void;
    (
        type: 'pointermove',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): void;
    (type: 'postcompose', listener: (evt: RenderEvent) => void): void;
    (type: 'postrender', listener: (evt: MapEvent) => void): void;
    (type: 'precompose', listener: (evt: RenderEvent) => void): void;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): void;
    (
        type: 'singleclick',
        listener: (evt: MapBrowserEvent<UIEvent>) => void
    ): void;
};

method updateSize

updateSize: () => void;

Force a recalculation of the map viewport size. This should be called when third-party code changes the size of the map viewport.

class Tile

abstract class Tile extends Target {}

constructor

constructor(tileCoord: TileCoord, state: TileState, opt_options?: Options);

property state

protected state: TileState;

method changed

protected changed: () => void;

method endTransition

endTransition: (id: string) => void;

Mark a transition as complete.

method getAlpha

getAlpha: (id: string, time: number) => number;

Get the alpha value for rendering.

method getInterimTile

getInterimTile: () => Tile;

Get the interim tile most suitable for rendering using the chain of interim tiles. This corresponds to the most recent tile that has been loaded, if no such tile exists, the original tile is returned.

method getKey

getKey: () => string;

method getState

getState: () => TileState;

method getTileCoord

getTileCoord: () => TileCoord;

Get the tile coordinate for this tile.

method inTransition

inTransition: (id: string) => boolean;

Determine if a tile is in an alpha transition. A tile is considered in transition if tile.getAlpha() has not yet been called or has been called and returned 1.

method load

abstract load: () => void;

Load the image or retry if loading previously failed. Loading is taken care of by the tile queue, and calling this method is only needed for preloading or for reloading in case of an error.

method refreshInterimChain

refreshInterimChain: () => void;

Goes through the chain of interim tiles and discards sections of the chain that are no longer relevant.

method release

release: () => void;

Called by the tile cache when the tile is removed from the cache due to expiry

method setState

setState: (state: TileState) => void;

Sets the state of this tile. If you write your own , it is important to set the state correctly to when the tile cannot be loaded. Otherwise the tile cannot be removed from the tile queue and will block other requests.

class TileCache

class TileCache extends LRUCache<any> {}

constructor

constructor();

method expireCache

expireCache: (usedTiles: { [key: string]: boolean }) => void;

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
};

method pruneExceptNewestZ

pruneExceptNewestZ: () => void;

Prune all tiles from the cache that don't have the same z as the newest tile.

method un

un: {
    (type: string | string[], listener: (p0: any) => any): void;
    (type: 'change', listener: (evt: BaseEvent) => void): void;
    (type: 'error', listener: (evt: BaseEvent) => void): void;
};

class TileQueue

class TileQueue extends PriorityQueue<any> {}

constructor

constructor(
    tilePriorityFunction: PriorityFunction,
    tileChangeCallback: () => any
);

method enqueue

enqueue: (element: any[]) => boolean;

method getTilesLoading

getTilesLoading: () => number;

method handleTileChange

protected handleTileChange: (event: BaseEvent) => void;

method loadMoreTiles

loadMoreTiles: (maxTotalLoading: number, maxNewLoads: number) => void;

class TileRange

class TileRange {}

constructor

constructor(minX: number, maxX: number, minY: number, maxY: number);

method contains

contains: (tileCoord: TileCoord) => boolean;

method containsTileRange

containsTileRange: (tileRange: TileRange) => boolean;

method containsXY

containsXY: (x: number, y: number) => boolean;

method equals

equals: (tileRange: TileRange) => boolean;

method extend

extend: (tileRange: TileRange) => void;

method getHeight

getHeight: () => number;

method getSize

getSize: () => Size;

method getWidth

getWidth: () => number;

method intersects

intersects: (tileRange: TileRange) => boolean;

class VectorRenderTile

class VectorRenderTile extends Tile {}

constructor

constructor(
    tileCoord: TileCoord,
    state: TileState,
    urlTileCoord: TileCoord,
    getSourceTiles: (p0: VectorRenderTile) => VectorTile[]
);

method getContext

getContext: (layer: Layer<Source>) => CanvasRenderingContext2D;

method getImage

getImage: (layer: Layer<Source>) => HTMLCanvasElement;

Get the Canvas for this tile.

method getReplayState

getReplayState: (layer: Layer<Source>) => ReplayState;

method hasContext

hasContext: (layer: Layer<Source>) => boolean;

method load

load: () => void;

Load the tile.

method release

release: () => void;

Remove from the cache due to expiry

class VectorTile

class VectorTile extends Tile {}

constructor

constructor(
    tileCoord: TileCoord,
    state: TileState,
    src: string,
    format: FeatureFormat,
    tileLoadFunction: LoadFunction,
    opt_options?: Options
);

method getFeatures

getFeatures: () => FeatureLike[];

Get the features for this tile. Geometries will be in the view projection.

method getFormat

getFormat: () => FeatureFormat;

Get the feature format assigned for reading this tile's features.

method load

load: () => void;

Load not yet loaded URI.

method onError

onError: () => void;

Handler for tile load errors.

method onLoad

onLoad: (features: Feature<Geometry>[], dataProjection: Projection) => void;

Handler for successful tile load.

method setFeatures

setFeatures: (features: Feature<Geometry>[]) => void;

Function for use in an 's tileLoadFunction. Sets the features for the tile.

method setLoader

setLoader: (loader: FeatureLoader) => void;

Set the feature loader for reading this tile's features.

class View

class View extends BaseObject {}

constructor

constructor(opt_options?: ViewOptions);

property padding

padding: number[];

Padding (in css pixels). If the map viewport is partially covered with other content (overlays) along its edges, this setting allows to shift the center of the viewport away from that content. The order of the values in the array is top, right, bottom, left. The default is no padding, which is equivalent to [0, 0, 0, 0].

method adjustCenter

adjustCenter: (deltaCoordinates: Coordinate) => void;

Adds relative coordinates to the center of the view. Any extent constraint will apply.

method adjustCenterInternal

adjustCenterInternal: (deltaCoordinates: Coordinate) => void;

Adds relative coordinates to the center of the view. Any extent constraint will apply.

method adjustResolution

adjustResolution: (ratio: number, opt_anchor?: Coordinate) => void;

Multiply the view resolution by a ratio, optionally using an anchor. Any resolution constraint will apply.

method adjustResolutionInternal

adjustResolutionInternal: (ratio: number, opt_anchor?: Coordinate) => void;

Multiply the view resolution by a ratio, optionally using an anchor. Any resolution constraint will apply.

method adjustRotation

adjustRotation: (delta: number, opt_anchor?: Coordinate) => void;

Adds a value to the view rotation, optionally using an anchor. Any rotation constraint will apply.

method adjustRotationInternal

adjustRotationInternal: (delta: number, opt_anchor?: Coordinate) => void;

method adjustZoom

adjustZoom: (delta: number, opt_anchor?: Coordinate) => void;

Adds a value to the view zoom level, optionally using an anchor. Any resolution constraint will apply.

method animate

animate: (...var_args: (AnimationOptions | ((p0: boolean) => void))[]) => void;

Animate the view. The view's center, zoom (or resolution), and rotation can be animated for smooth transitions between view states. For example, to animate the view to a new zoom level: view.animate({zoom: view.getZoom() + 1});By default, the animation lasts one second and uses in-and-out easing. You can customize this behavior by including duration (in milliseconds) and easing options (see ). To chain together multiple animations, call the method with multiple animation objects. For example, to first zoom and then pan: view.animate({zoom: 10}, {center: [0, 0]});If you provide a function as the last argument to the animate method, it will get called at the end of an animation series. The callback will be called with true if the animation series completed on its own or false if it was cancelled. Animations are cancelled by user interactions (e.g. dragging the map) or by calling view.setCenter(), view.setResolution(), or view.setRotation() (or another method that calls one of these).

method animateInternal

animateInternal: (
    ...var_args: (AnimationOptions | ((p0: boolean) => void))[]
) => void;

method applyOptions_

applyOptions_: (options: ViewOptions) => void;

Set up the view with the given options.

method beginInteraction

beginInteraction: () => void;

Notify the View that an interaction has started. The view state will be resolved to a stable one if needed (depending on its constraints).

method calculateCenterRotate

calculateCenterRotate: (
    rotation: number,
    anchor: Coordinate
) => Coordinate | undefined;

method calculateCenterShift

calculateCenterShift: (
    center: Coordinate,
    resolution: number,
    rotation: number,
    size: Size
) => number[] | undefined;

Calculates the shift between map and viewport center.

method calculateCenterZoom

calculateCenterZoom: (
    resolution: number,
    anchor: Coordinate
) => Coordinate | undefined;

method calculateExtent

calculateExtent: (opt_size?: Size) => Extent;

Calculate the extent for the current view state and the passed size. The size is the pixel dimensions of the box into which the calculated extent should fit. In most cases you want to get the extent of the entire map, that is map.getSize().

method calculateExtentInternal

calculateExtentInternal: (opt_size?: Size) => Extent;

method cancelAnimations

cancelAnimations: () => void;

Cancel any ongoing animations.

method centerOn

centerOn: (coordinate: Coordinate, size: Size, position: Pixel) => void;

Center on coordinate and view position.

method centerOnInternal

centerOnInternal: (coordinate: Coordinate, size: Size, position: Pixel) => void;

method endInteraction

endInteraction: (
    opt_duration?: number,
    opt_resolutionDirection?: number,
    opt_anchor?: Coordinate
) => void;

Notify the View that an interaction has ended. The view state will be resolved to a stable one if needed (depending on its constraints).

method endInteractionInternal

endInteractionInternal: (
    opt_duration?: number,
    opt_resolutionDirection?: number,
    opt_anchor?: Coordinate
) => void;

Notify the View that an interaction has ended. The view state will be resolved to a stable one if needed (depending on its constraints).

method fit

fit: (
    geometryOrExtent: SimpleGeometry | Extent,
    opt_options?: FitOptions
) => void;

Fit the given geometry or extent based on the given map size and border. The size is pixel dimensions of the box to fit the extent into. In most cases you will want to use the map size, that is map.getSize(). Takes care of the map angle.

method fitInternal

fitInternal: (geometry: SimpleGeometry, opt_options?: FitOptions) => void;

method getAnimating

getAnimating: () => boolean;

Determine if the view is being animated.

method getCenter

getCenter: () => Coordinate | undefined;

Get the view center.

method getCenterInternal

getCenterInternal: () => Coordinate | undefined;

Get the view center without transforming to user projection.

method getConstrainedCenter

getConstrainedCenter: (
    targetCenter: Coordinate | undefined,
    opt_targetResolution?: number
) => Coordinate | undefined;

Get a valid position for the view center according to the current constraints.

method getConstrainedResolution

getConstrainedResolution: (
    targetResolution: number | undefined,
    opt_direction?: number
) => number | undefined;

Get a valid resolution according to the current view constraints.

method getConstrainedZoom

getConstrainedZoom: (
    targetZoom: number | undefined,
    opt_direction?: number
) => number | undefined;

Get a valid zoom level according to the current view constraints.

method getConstrainResolution

getConstrainResolution: () => boolean;

method getConstraints

getConstraints: () => Constraints;

method getHints

getHints: (opt_hints?: number[]) => number[];

method getInteracting

getInteracting: () => boolean;

Determine if the user is interacting with the view, such as panning or zooming.

method getMaxResolution

getMaxResolution: () => number;

Get the maximum resolution of the view.

method getMaxZoom

getMaxZoom: () => number;

Get the maximum zoom level for the view.

method getMinResolution

getMinResolution: () => number;

Get the minimum resolution of the view.

method getMinZoom

getMinZoom: () => number;

Get the minimum zoom level for the view.

method getProjection

getProjection: () => Projection;

Get the view projection.

method getResolution

getResolution: () => number | undefined;

Get the view resolution.

method getResolutionForExtent

getResolutionForExtent: (extent: Extent, opt_size?: Size) => number;

Get the resolution for a provided extent (in map units) and size (in pixels).

method getResolutionForExtentInternal

getResolutionForExtentInternal: (extent: Extent, opt_size?: Size) => number;

Get the resolution for a provided extent (in map units) and size (in pixels).

method getResolutionForValueFunction

getResolutionForValueFunction: (opt_power?: number) => (p0: number) => number;

Return a function that returns a value between 0 and 1 for a resolution. Exponential scaling is assumed.

method getResolutionForZoom

getResolutionForZoom: (zoom: number) => number;

Get the resolution for a zoom level.

method getResolutions

getResolutions: () => number[] | undefined;

Get the resolutions for the view. This returns the array of resolutions passed to the constructor of the View, or undefined if none were given.

method getRotation

getRotation: () => number;

Get the view rotation.

method getState

getState: () => State;

method getUpdatedOptions_

getUpdatedOptions_: (newOptions: ViewOptions) => ViewOptions;

Get an updated version of the view options used to construct the view. The current resolution (or zoom), center, and rotation are applied to any stored options. The provided options can be used to apply new min/max zoom or resolution limits.

method getValueForResolutionFunction

getValueForResolutionFunction: (opt_power?: number) => (p0: number) => number;

Return a function that returns a resolution for a value between 0 and 1. Exponential scaling is assumed.

method getZoom

getZoom: () => number | undefined;

Get the current zoom level. This method may return non-integer zoom levels if the view does not constrain the resolution, or if an interaction or animation is underway.

method getZoomForResolution

getZoomForResolution: (resolution: number) => number | undefined;

Get the zoom level for a resolution.

method isDef

isDef: () => boolean;

method on

on: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:center', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:resolution', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:rotation', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method once

once: {
    (type: string | string[], listener: (p0: any) => any):
        | EventsKey
        | EventsKey[];
    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'change:center', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:resolution', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'change:rotation', listener: (evt: ObjectEvent) => void): EventsKey;
    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
};

method resolveConstraints

resolveConstraints: (
    opt_duration?: number,
    opt_resolutionDirection?: number,
    opt_anchor?: Coordinate</