diff --git a/types/ol/AssertionError.d.ts b/types/ol/AssertionError.d.ts new file mode 100644 index 0000000000..f000d1c71d --- /dev/null +++ b/types/ol/AssertionError.d.ts @@ -0,0 +1,4 @@ +export default class AssertionError extends Error { + constructor(code: number); + code: number; +} diff --git a/types/ol/AssertionError/index.d.ts b/types/ol/AssertionError/index.d.ts deleted file mode 100644 index 3585cd64da..0000000000 --- a/types/ol/AssertionError/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.AssertionError; diff --git a/types/ol/Attribution/index.d.ts b/types/ol/Attribution/index.d.ts deleted file mode 100644 index 71eb87ff73..0000000000 --- a/types/ol/Attribution/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Attribution; diff --git a/types/ol/Collection.d.ts b/types/ol/Collection.d.ts new file mode 100644 index 0000000000..4d04f02521 --- /dev/null +++ b/types/ol/Collection.d.ts @@ -0,0 +1,43 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +export class CollectionEvent extends Event { + constructor(); + element: T; +} +export default class Collection extends BaseObject { + constructor(opt_array?: T[], opt_options?: Options); + item(index: number): T; + clear(): void; + forEach(f: ((param0: T, param1: number, param2: T[]) => void)): void; + getArray(): T[]; + getLength(): number; + insertAt(index: number, elem: T): void; + extend(arr: T[]): Collection; + pop(): T; + push(elem: T): number; + remove(elem: T): T; + removeAt(index: number): T; + setAt(index: number, elem: T): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'add', listener: (evt: CollectionEvent) => void): EventsKey; + once(type: 'add', listener: (evt: CollectionEvent) => void): EventsKey; + un(type: 'add', listener: (evt: CollectionEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:length', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:length', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:length', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'remove', listener: (evt: CollectionEvent) => void): EventsKey; + once(type: 'remove', listener: (evt: CollectionEvent) => void): EventsKey; + un(type: 'remove', listener: (evt: CollectionEvent) => void): void; +} +export interface Options { + unique?: boolean; +} diff --git a/types/ol/Collection/index.d.ts b/types/ol/Collection/index.d.ts deleted file mode 100644 index 5943115188..0000000000 --- a/types/ol/Collection/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Collection; diff --git a/types/ol/CollectionEventType.d.ts b/types/ol/CollectionEventType.d.ts new file mode 100644 index 0000000000..5f759b950c --- /dev/null +++ b/types/ol/CollectionEventType.d.ts @@ -0,0 +1,6 @@ +declare enum CollectionEventType { + ADD = 'add', + REMOVE = 'remove', +} + +export default CollectionEventType; diff --git a/types/ol/Disposable.d.ts b/types/ol/Disposable.d.ts new file mode 100644 index 0000000000..8627e60467 --- /dev/null +++ b/types/ol/Disposable.d.ts @@ -0,0 +1,5 @@ +export default class Disposable { + constructor(); + protected disposeInternal(): void; + dispose(): void; +} diff --git a/types/ol/Disposable/index.d.ts b/types/ol/Disposable/index.d.ts deleted file mode 100644 index dd3aca2bff..0000000000 --- a/types/ol/Disposable/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Disposable; diff --git a/types/ol/Feature.d.ts b/types/ol/Feature.d.ts new file mode 100644 index 0000000000..4782b9c4a7 --- /dev/null +++ b/types/ol/Feature.d.ts @@ -0,0 +1,34 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Geometry from 'ol/geom/Geometry'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import RenderFeature from 'ol/render/Feature'; +import Style, { StyleFunction, StyleLike } from 'ol/style/Style'; +export function createStyleFunction(obj: StyleFunction | Style[] | Style): StyleFunction; +export default class Feature extends BaseObject { + constructor(opt_geometryOrProperties?: Geometry | { [key: string]: any }); + clone(): Feature; + getGeometry(): Geometry; + getGeometryName(): string; + getId(): number | string; + getStyle(): StyleLike; + getStyleFunction(): StyleFunction; + setGeometry(geometry: Geometry): void; + setGeometryName(name: string): void; + setId(id: number | string): void; + setStyle(style: StyleLike): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:geometry', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:geometry', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:geometry', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export type FeatureClass = Feature | RenderFeature; +export type FeatureLike = Feature | RenderFeature; diff --git a/types/ol/Feature/index.d.ts b/types/ol/Feature/index.d.ts deleted file mode 100644 index ba86ca0ad0..0000000000 --- a/types/ol/Feature/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Feature; diff --git a/types/ol/Geolocation.d.ts b/types/ol/Geolocation.d.ts new file mode 100644 index 0000000000..df6871e203 --- /dev/null +++ b/types/ol/Geolocation.d.ts @@ -0,0 +1,70 @@ +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Polygon from 'ol/geom/Polygon'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +export default class Geolocation extends BaseObject { + constructor(opt_options?: Options); + getProjection(): Projection; + getAccuracy(): number; + getAltitude(): number; + getAltitudeAccuracy(): number; + getHeading(): number; + getPosition(): Coordinate; + getAccuracyGeometry(): Polygon; + getSpeed(): number; + getTracking(): boolean; + getTrackingOptions(): PositionOptions; + setProjection(projection: ProjectionLike): void; + setTracking(tracking: boolean): void; + setTrackingOptions(options: PositionOptions): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:accuracy', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:accuracy', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:accuracy', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:accuracyGeometry', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:accuracyGeometry', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:accuracyGeometry', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:altitude', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:altitude', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:altitude', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:altitudeAccuracy', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:altitudeAccuracy', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:altitudeAccuracy', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:heading', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:heading', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:heading', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:position', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:projection', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:projection', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:projection', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:speed', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:speed', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:speed', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:tracking', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:tracking', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:tracking', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:trackingOptions', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:trackingOptions', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:trackingOptions', listener: (evt: ObjectEvent) => void): void; + on(type: 'error', listener: (evt: any) => void): EventsKey; + once(type: 'error', listener: (evt: any) => void): EventsKey; + un(type: 'error', listener: (evt: any) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + tracking?: boolean; + trackingOptions?: PositionOptions; + projection?: ProjectionLike; +} diff --git a/types/ol/Geolocation/index.d.ts b/types/ol/Geolocation/index.d.ts deleted file mode 100644 index a08c095e0c..0000000000 --- a/types/ol/Geolocation/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Geolocation; diff --git a/types/ol/Graticule.d.ts b/types/ol/Graticule.d.ts new file mode 100644 index 0000000000..4046c53381 --- /dev/null +++ b/types/ol/Graticule.d.ts @@ -0,0 +1,30 @@ +import LineString from 'ol/geom/LineString'; +import Point from 'ol/geom/Point'; +import PluggableMap from 'ol/PluggableMap'; +import Stroke from 'ol/style/Stroke'; +import Text from 'ol/style/Text'; +export default class Graticule { + constructor(opt_options?: Options); + getMap(): PluggableMap; + getMeridians(): LineString[]; + getParallels(): LineString[]; + setMap(map: PluggableMap): void; +} +export interface GraticuleLabelDataType { + geom: Point; + text: string; +} +export interface Options { + map?: PluggableMap; + maxLines?: number; + strokeStyle?: Stroke; + targetSize?: number; + showLabels?: boolean; + lonLabelFormatter?: ((param0: number) => string); + latLabelFormatter?: ((param0: number) => string); + lonLabelPosition?: number; + latLabelPosition?: number; + lonLabelStyle?: Text; + latLabelStyle?: Text; + intervals?: number[]; +} diff --git a/types/ol/Graticule/index.d.ts b/types/ol/Graticule/index.d.ts deleted file mode 100644 index 97bd1e8e2d..0000000000 --- a/types/ol/Graticule/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Graticule; diff --git a/types/ol/Image.d.ts b/types/ol/Image.d.ts new file mode 100644 index 0000000000..c1dd7891d6 --- /dev/null +++ b/types/ol/Image.d.ts @@ -0,0 +1,9 @@ +import { Extent } from 'ol/extent'; +import ImageBase from 'ol/ImageBase'; +import ImageState from 'ol/ImageState'; +export default class ImageWrapper extends ImageBase { + constructor(extent: Extent, resolution: number, pixelRatio: number, src: string, crossOrigin: string, imageLoadFunction: LoadFunction); + protected state: ImageState; + setImage(image: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement): void; +} +export type LoadFunction = ((param0: ImageWrapper, param1: string) => void); diff --git a/types/ol/Image/index.d.ts b/types/ol/Image/index.d.ts deleted file mode 100644 index 5a4c9a304b..0000000000 --- a/types/ol/Image/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Image; diff --git a/types/ol/ImageBase.d.ts b/types/ol/ImageBase.d.ts new file mode 100644 index 0000000000..38e31c0cd4 --- /dev/null +++ b/types/ol/ImageBase.d.ts @@ -0,0 +1,16 @@ +import Target from 'ol/events/Target'; +import { Extent } from 'ol/extent'; +import ImageState from 'ol/ImageState'; +export default class ImageBase extends Target { + constructor(extent: Extent, resolution: number, pixelRatio: number, state: ImageState); + protected extent: Extent; + protected resolution: number; + protected state: ImageState; + protected changed(): void; + getExtent(): Extent; + getImage(): HTMLCanvasElement | HTMLImageElement | HTMLVideoElement; + getPixelRatio(): number; + getResolution(): number; + getState(): ImageState; + load(): void; +} diff --git a/types/ol/ImageBase/index.d.ts b/types/ol/ImageBase/index.d.ts deleted file mode 100644 index 91e7971e27..0000000000 --- a/types/ol/ImageBase/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.ImageBase; diff --git a/types/ol/ImageCanvas.d.ts b/types/ol/ImageCanvas.d.ts new file mode 100644 index 0000000000..fcc14d63e0 --- /dev/null +++ b/types/ol/ImageCanvas.d.ts @@ -0,0 +1,9 @@ +import { Extent } from 'ol/extent'; +import ImageBase from 'ol/ImageBase'; +export default class ImageCanvas extends ImageBase { + constructor(extent: Extent, resolution: number, pixelRatio: number, canvas: HTMLCanvasElement, opt_loader?: Loader); + getError(): Error; + getImage(): HTMLCanvasElement; + getImage(): HTMLCanvasElement | HTMLImageElement | HTMLVideoElement; +} +export type Loader = ((param0: (() => void)) => void); diff --git a/types/ol/ImageState.d.ts b/types/ol/ImageState.d.ts new file mode 100644 index 0000000000..2d8d90370d --- /dev/null +++ b/types/ol/ImageState.d.ts @@ -0,0 +1,8 @@ +declare enum ImageState { + IDLE = 0, + LOADING = 1, + LOADED = 2, + ERROR = 3, +} + +export default ImageState; diff --git a/types/ol/ImageTile.d.ts b/types/ol/ImageTile.d.ts new file mode 100644 index 0000000000..96671d48dd --- /dev/null +++ b/types/ol/ImageTile.d.ts @@ -0,0 +1,7 @@ +import Tile, { LoadFunction, Options } from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileState from 'ol/TileState'; +export default class ImageTile extends Tile { + constructor(tileCoord: TileCoord, state: TileState, src: string, crossOrigin: string, tileLoadFunction: LoadFunction, opt_options?: Options); + getImage(): HTMLCanvasElement | HTMLImageElement | HTMLVideoElement; +} diff --git a/types/ol/ImageTile/index.d.ts b/types/ol/ImageTile/index.d.ts deleted file mode 100644 index 57b9b1c9fa..0000000000 --- a/types/ol/ImageTile/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.ImageTile; diff --git a/types/ol/Kinetic.d.ts b/types/ol/Kinetic.d.ts new file mode 100644 index 0000000000..16ccef8fe0 --- /dev/null +++ b/types/ol/Kinetic.d.ts @@ -0,0 +1,8 @@ +export default class Kinetic { + constructor(decay: number, minVelocity: number, delay: number); + begin(): void; + end(): boolean; + getAngle(): number; + getDistance(): number; + update(x: number, y: number): void; +} diff --git a/types/ol/Kinetic/index.d.ts b/types/ol/Kinetic/index.d.ts deleted file mode 100644 index ba283fca68..0000000000 --- a/types/ol/Kinetic/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Kinetic; diff --git a/types/ol/LayerType.d.ts b/types/ol/LayerType.d.ts new file mode 100644 index 0000000000..be9a0e1315 --- /dev/null +++ b/types/ol/LayerType.d.ts @@ -0,0 +1,8 @@ +declare enum LayerType { + IMAGE = 'IMAGE', + TILE = 'TILE', + VECTOR_TILE = 'VECTOR_TILE', + VECTOR = 'VECTOR', +} + +export default LayerType; diff --git a/types/ol/Map.d.ts b/types/ol/Map.d.ts new file mode 100644 index 0000000000..16a2df3946 --- /dev/null +++ b/types/ol/Map.d.ts @@ -0,0 +1,64 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import MapEvent from 'ol/MapEvent'; +import { ObjectEvent } from 'ol/Object'; +import PluggableMap, { MapOptions } from 'ol/PluggableMap'; +import RenderEvent from 'ol/render/Event'; +export default class Map extends PluggableMap { + constructor(options: MapOptions); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:size', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:target', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:view', listener: (evt: ObjectEvent) => void): void; + on(type: 'click', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'click', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'click', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'moveend', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'moveend', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'moveend', listener: (evt: MapEvent) => void): void; + on(type: 'movestart', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'movestart', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'movestart', listener: (evt: MapEvent) => void): void; + on(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'postrender', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'postrender', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'postrender', listener: (evt: MapEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; + on(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): void; +} diff --git a/types/ol/Map/index.d.ts b/types/ol/Map/index.d.ts deleted file mode 100644 index 58f635d45a..0000000000 --- a/types/ol/Map/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Map; diff --git a/types/ol/MapBrowserEvent.d.ts b/types/ol/MapBrowserEvent.d.ts new file mode 100644 index 0000000000..83ff5d9c6f --- /dev/null +++ b/types/ol/MapBrowserEvent.d.ts @@ -0,0 +1,11 @@ +import { Coordinate } from 'ol/coordinate'; +import MapEvent from 'ol/MapEvent'; +import { Pixel } from 'ol/pixel'; +import PluggableMap, { FrameState } from 'ol/PluggableMap'; +export default class MapBrowserEvent extends MapEvent { + constructor(type: string, map: PluggableMap, browserEvent: Event, opt_dragging?: boolean, opt_frameState?: FrameState); + coordinate: Coordinate; + dragging: boolean; + pixel: Pixel; + originalEvent: Event; +} diff --git a/types/ol/MapBrowserEvent/index.d.ts b/types/ol/MapBrowserEvent/index.d.ts deleted file mode 100644 index 048fc22481..0000000000 --- a/types/ol/MapBrowserEvent/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.MapBrowserEvent; diff --git a/types/ol/MapBrowserEventHandler.d.ts b/types/ol/MapBrowserEventHandler.d.ts new file mode 100644 index 0000000000..fb28be567d --- /dev/null +++ b/types/ol/MapBrowserEventHandler.d.ts @@ -0,0 +1,5 @@ +import Target from 'ol/events/Target'; +import PluggableMap from 'ol/PluggableMap'; +export default class MapBrowserEventHandler extends Target { + constructor(map: PluggableMap, moveTolerance?: number); +} diff --git a/types/ol/MapBrowserEventType.d.ts b/types/ol/MapBrowserEventType.d.ts new file mode 100644 index 0000000000..890e7d0310 --- /dev/null +++ b/types/ol/MapBrowserEventType.d.ts @@ -0,0 +1,16 @@ +declare enum MapBrowserEventType { + SINGLECLICK = 'singleclick', + CLICK = 'click', + DBLCLICK = 'dblclick', + POINTERDRAG = 'pointerdrag', + POINTERMOVE = 'pointermove', + POINTERDOWN = 'pointerdown', + POINTERUP = 'pointerup', + POINTEROVER = 'pointerover', + POINTEROUT = 'pointerout', + POINTERENTER = 'pointerenter', + POINTERLEAVE = 'pointerleave', + POINTERCANCEL = 'pointercancel', +} + +export default MapBrowserEventType; diff --git a/types/ol/MapBrowserPointerEvent.d.ts b/types/ol/MapBrowserPointerEvent.d.ts new file mode 100644 index 0000000000..e107cd5e9b --- /dev/null +++ b/types/ol/MapBrowserPointerEvent.d.ts @@ -0,0 +1,6 @@ +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import PluggableMap, { FrameState } from 'ol/PluggableMap'; +import PointerEvent from 'ol/pointer/PointerEvent'; +export default class MapBrowserPointerEvent extends MapBrowserEvent { + constructor(type: string, map: PluggableMap, pointerEvent: PointerEvent, opt_dragging?: boolean, opt_frameState?: FrameState); +} diff --git a/types/ol/MapBrowserPointerEvent/index.d.ts b/types/ol/MapBrowserPointerEvent/index.d.ts deleted file mode 100644 index 616325e218..0000000000 --- a/types/ol/MapBrowserPointerEvent/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.MapBrowserPointerEvent; diff --git a/types/ol/MapEvent.d.ts b/types/ol/MapEvent.d.ts new file mode 100644 index 0000000000..5a155039d7 --- /dev/null +++ b/types/ol/MapEvent.d.ts @@ -0,0 +1,7 @@ +import Event from 'ol/events/Event'; +import PluggableMap, { FrameState } from 'ol/PluggableMap'; +export default class MapEvent extends Event { + constructor(type: string, map: PluggableMap, opt_frameState?: FrameState); + frameState: FrameState; + map: PluggableMap; +} diff --git a/types/ol/MapEvent/index.d.ts b/types/ol/MapEvent/index.d.ts deleted file mode 100644 index 6e7487ec29..0000000000 --- a/types/ol/MapEvent/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.MapEvent; diff --git a/types/ol/MapEventType.d.ts b/types/ol/MapEventType.d.ts new file mode 100644 index 0000000000..c01df5ed6d --- /dev/null +++ b/types/ol/MapEventType.d.ts @@ -0,0 +1,7 @@ +declare enum MapEventType { + POSTRENDER = 'postrender', + MOVESTART = 'movestart', + MOVEEND = 'moveend', +} + +export default MapEventType; diff --git a/types/ol/MapProperty.d.ts b/types/ol/MapProperty.d.ts new file mode 100644 index 0000000000..a67d74c4fe --- /dev/null +++ b/types/ol/MapProperty.d.ts @@ -0,0 +1,8 @@ +declare enum MapProperty { + LAYERGROUP = 'layergroup', + SIZE = 'size', + TARGET = 'target', + VIEW = 'view', +} + +export default MapProperty; diff --git a/types/ol/Object.d.ts b/types/ol/Object.d.ts new file mode 100644 index 0000000000..d847f63940 --- /dev/null +++ b/types/ol/Object.d.ts @@ -0,0 +1,28 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Observable from 'ol/Observable'; +export function getChangeEventType(key: string): string; +export class ObjectEvent extends Event { + constructor(); + key: string; + oldValue: any; +} +export default class BaseObject extends Observable { + constructor(opt_values?: { [key: string]: any }); + get(key: string): any; + getKeys(): string[]; + getProperties(): { [key: string]: any }; + notify(key: string, oldValue: any): void; + set(key: string, value: any, opt_silent?: boolean): void; + setProperties(values: { [key: string]: any }, opt_silent?: boolean): void; + unset(key: string, opt_silent?: boolean): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/Object/index.d.ts b/types/ol/Object/index.d.ts deleted file mode 100644 index e4580cd0ce..0000000000 --- a/types/ol/Object/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Object; diff --git a/types/ol/ObjectEventType.d.ts b/types/ol/ObjectEventType.d.ts new file mode 100644 index 0000000000..54b75b94d3 --- /dev/null +++ b/types/ol/ObjectEventType.d.ts @@ -0,0 +1,5 @@ +declare enum ObjectEventType { + PROPERTYCHANGE = 'propertychange', +} + +export default ObjectEventType; diff --git a/types/ol/Observable.d.ts b/types/ol/Observable.d.ts new file mode 100644 index 0000000000..d5ce43d074 --- /dev/null +++ b/types/ol/Observable.d.ts @@ -0,0 +1,15 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Target from 'ol/events/Target'; +export function unByKey(key: EventsKey | EventsKey[]): void; +export default class Observable extends Target { + constructor(); + changed(): void; + getRevision(): number; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/Observable/index.d.ts b/types/ol/Observable/index.d.ts deleted file mode 100644 index 09489e7382..0000000000 --- a/types/ol/Observable/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Observable; diff --git a/types/ol/Overlay.d.ts b/types/ol/Overlay.d.ts new file mode 100644 index 0000000000..0dd5fff5d8 --- /dev/null +++ b/types/ol/Overlay.d.ts @@ -0,0 +1,86 @@ +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import OverlayPositioning from 'ol/OverlayPositioning'; +import { Pixel } from 'ol/pixel'; +import PluggableMap from 'ol/PluggableMap'; +import { Size } from 'ol/size'; +export interface Options { + id?: number | string; + element?: HTMLElement; + offset?: number[]; + position?: Coordinate; + positioning?: OverlayPositioning; + stopEvent?: boolean; + insertFirst?: boolean; + autoPan?: boolean; + autoPanAnimation?: PanOptions; + autoPanMargin?: number; + className?: string; +} +export default class Overlay extends BaseObject { + constructor(options: Options); + protected autoPan: boolean; + protected autoPanMargin: number; + protected element: HTMLElement; + protected stopEvent: boolean; + protected rendered: { [key: string]: any }; + protected options: Options; + protected autoPanAnimation: PanOptions; + protected id: number | string; + protected insertFirst: boolean; + protected mapPostrenderListenerKey: EventsKey; + protected updateRenderedPosition(pixel: Pixel, mapSize: Size): void; + protected getRect(element: HTMLElement, size: Size): Extent; + protected handleElementChanged(): void; + protected handleMapChanged(): void; + protected handleOffsetChanged(): void; + protected handlePositionChanged(): void; + protected setVisible(visible: boolean): void; + protected updatePixelPosition(): void; + protected render(): void; + protected panIntoView(): void; + protected handlePositioningChanged(): void; + getPositioning(): OverlayPositioning; + getOptions(): Options; + getOffset(): number[]; + setElement(element: HTMLElement): void; + setMap(map: PluggableMap): void; + getPosition(): Coordinate; + setPosition(position: Coordinate): void; + setPositioning(positioning: OverlayPositioning): void; + getMap(): PluggableMap; + getId(): number | string; + getElement(): HTMLElement; + setOffset(offset: number[]): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:element', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:element', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:element', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:map', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:map', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:map', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:offset', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:offset', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:offset', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:position', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:positioning', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:positioning', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:positioning', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface PanOptions { + duration?: number; + easing?: ((param0: number) => number); +} diff --git a/types/ol/Overlay/index.d.ts b/types/ol/Overlay/index.d.ts deleted file mode 100644 index d350f1c828..0000000000 --- a/types/ol/Overlay/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Overlay; diff --git a/types/ol/OverlayPositioning.d.ts b/types/ol/OverlayPositioning.d.ts new file mode 100644 index 0000000000..169108a97d --- /dev/null +++ b/types/ol/OverlayPositioning.d.ts @@ -0,0 +1,13 @@ +declare enum OverlayPositioning { + BOTTOM_LEFT = 'bottom-left', + BOTTOM_CENTER = 'bottom-center', + BOTTOM_RIGHT = 'bottom-right', + CENTER_LEFT = 'center-left', + CENTER_CENTER = 'center-center', + CENTER_RIGHT = 'center-right', + TOP_LEFT = 'top-left', + TOP_CENTER = 'top-center', + TOP_RIGHT = 'top-right', +} + +export default OverlayPositioning; diff --git a/types/ol/PluggableMap.d.ts b/types/ol/PluggableMap.d.ts new file mode 100644 index 0000000000..710fba53af --- /dev/null +++ b/types/ol/PluggableMap.d.ts @@ -0,0 +1,174 @@ +import Collection from 'ol/Collection'; +import Control from 'ol/control/Control'; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Feature, { FeatureLike } from 'ol/Feature'; +import Interaction from 'ol/interaction/Interaction'; +import BaseLayer from 'ol/layer/Base'; +import LayerGroup from 'ol/layer/Group'; +import Layer, { State as State_1 } from 'ol/layer/Layer'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import MapEvent from 'ol/MapEvent'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import Overlay from 'ol/Overlay'; +import { Pixel } from 'ol/pixel'; +import RenderEvent from 'ol/render/Event'; +import MapRenderer from 'ol/renderer/Map'; +import { Size } from 'ol/size'; +import Tile from 'ol/Tile'; +import TileQueue from 'ol/TileQueue'; +import TileRange from 'ol/TileRange'; +import { Transform } from 'ol/transform'; +import View, { State } from 'ol/View'; +export interface AtPixelOptions { + layerFilter: ((param0: Layer) => boolean); + hitTolerance?: number; +} +export interface FrameState { + pixelRatio: number; + time: number; + viewState: State; + animate: boolean; + coordinateToPixelTransform: Transform; + extent: Extent; + focus: Coordinate; + index: number; + layerStates: { [key: string]: State_1 }; + layerStatesArray: State_1[]; + pixelToCoordinateTransform: Transform; + postRenderFunctions: PostRenderFunction[]; + size: Size; + skippedFeatureUids: { [key: string]: boolean }; + tileQueue: TileQueue; + usedTiles: { [key: string]: { [key: string]: TileRange } }; + viewHints: number[]; + wantedTiles: { [key: string]: { [key: string]: boolean } }; +} +export interface MapOptions { + controls?: Collection | Control[]; + pixelRatio?: number; + interactions?: Collection | Interaction[]; + keyboardEventTarget?: HTMLElement | Document | string; + layers?: BaseLayer[] | Collection | LayerGroup; + maxTilesLoading?: number; + loadTilesWhileAnimating?: boolean; + loadTilesWhileInteracting?: boolean; + moveTolerance?: number; + overlays?: Collection | Overlay[]; + target?: HTMLElement | string; + view?: View; +} +export interface MapOptionsInternal { + controls?: Collection; + interactions?: Collection; + keyboardEventTarget: HTMLElement | Document; + overlays: Collection; + values: { [key: string]: any }; +} +export default class PluggableMap extends BaseObject { + constructor(options: MapOptions); + protected controls: Collection; + protected interactions: Collection; + protected handlePostRender(): void; + getTarget(): HTMLElement | string; + addControl(control: Control): void; + createRenderer(): MapRenderer; + forEachFeatureAtPixel(pixel: Pixel, callback: ((this: S, param1: FeatureLike, param2: Layer) => T), opt_options?: AtPixelOptions): T; + forEachLayerAtPixel(pixel: Pixel, callback: ((this: S, param1: Layer, param2: Uint8ClampedArray | Uint8Array) => T), opt_options?: AtPixelOptions): T; + getControls(): Collection; + getCoordinateFromPixel(pixel: Pixel): Coordinate; + getEventCoordinate(event: Event): Coordinate; + getEventPixel(event: Event | TouchEvent): Pixel; + getFeaturesAtPixel(pixel: Pixel, opt_options?: AtPixelOptions): FeatureLike[]; + getInteractions(): Collection; + getLayerGroup(): LayerGroup; + getLayers(): Collection; + getOverlayById(id: string | number): Overlay; + getOverlayContainer(): HTMLElement; + getOverlayContainerStopEvent(): HTMLElement; + getOverlays(): Collection; + getPixelFromCoordinate(coordinate: Coordinate): Pixel; + getRenderer(): MapRenderer; + getSize(): Size; + addInteraction(interaction: Interaction): void; + getTargetElement(): HTMLElement; + getTilePriority(tile: Tile, tileSourceKey: string, tileCenter: Coordinate, tileResolution: number): number; + getView(): View; + getViewport(): HTMLElement; + handleBrowserEvent(browserEvent: Event, opt_type?: string): void; + handleMapBrowserEvent(mapBrowserEvent: MapBrowserEvent): void; + addLayer(layer: BaseLayer): void; + hasFeatureAtPixel(pixel: Pixel, opt_options?: AtPixelOptions): boolean; + addOverlay(overlay: Overlay): void; + isRendered(): boolean; + removeControl(control: Control): Control; + removeInteraction(interaction: Interaction): Interaction; + removeLayer(layer: BaseLayer): BaseLayer; + removeOverlay(overlay: Overlay): Overlay; + render(): void; + renderSync(): void; + setLayerGroup(layerGroup: LayerGroup): void; + setSize(size: Size): void; + setTarget(target: HTMLElement | string): void; + setView(view: View): void; + skipFeature(feature: Feature): void; + unskipFeature(feature: Feature): void; + updateSize(): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:size', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:target', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:view', listener: (evt: ObjectEvent) => void): void; + on(type: 'click', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'click', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'click', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'moveend', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'moveend', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'moveend', listener: (evt: MapEvent) => void): void; + on(type: 'movestart', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'movestart', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'movestart', listener: (evt: MapEvent) => void): void; + on(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'postrender', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'postrender', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'postrender', listener: (evt: MapEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; + on(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): void; +} +export type PostRenderFunction = ((param0: PluggableMap, param1?: FrameState) => boolean); diff --git a/types/ol/Tile.d.ts b/types/ol/Tile.d.ts new file mode 100644 index 0000000000..d96fcb69c6 --- /dev/null +++ b/types/ol/Tile.d.ts @@ -0,0 +1,24 @@ +import Target from 'ol/events/Target'; +import Projection from 'ol/proj/Projection'; +import { TileCoord } from 'ol/tilecoord'; +import TileState from 'ol/TileState'; +export type LoadFunction = ((param0: Tile, param1: string) => void); +export interface Options { + transition?: number; +} +export default class Tile extends Target { + constructor(tileCoord: TileCoord, state: TileState, opt_options?: Options); + protected state: TileState; + protected changed(): void; + getAlpha(id: string, time: number): number; + getInterimTile(): Tile; + getKey(): string; + getState(): TileState; + endTransition(id: string): void; + inTransition(id: string): boolean; + load(): void; + refreshInterimChain(): void; + setState(state: TileState): void; + getTileCoord(): TileCoord; +} +export type UrlFunction = ((param0: TileCoord, param1: number, param2: Projection) => string); diff --git a/types/ol/Tile/index.d.ts b/types/ol/Tile/index.d.ts deleted file mode 100644 index 61e802d921..0000000000 --- a/types/ol/Tile/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Tile; diff --git a/types/ol/TileCache.d.ts b/types/ol/TileCache.d.ts new file mode 100644 index 0000000000..24f430bdbf --- /dev/null +++ b/types/ol/TileCache.d.ts @@ -0,0 +1,15 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import LRUCache from 'ol/structs/LRUCache'; +import TileRange from 'ol/TileRange'; +export default class TileCache extends LRUCache { + constructor(opt_highWaterMark?: number); + expireCache(usedTiles: { [key: string]: TileRange }): void; + pruneExceptNewestZ(): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/TileQueue.d.ts b/types/ol/TileQueue.d.ts new file mode 100644 index 0000000000..2a16ce6b74 --- /dev/null +++ b/types/ol/TileQueue.d.ts @@ -0,0 +1,11 @@ +import { Coordinate } from 'ol/coordinate'; +import Event from 'ol/events/Event'; +import PriorityQueue from 'ol/structs/PriorityQueue'; +import Tile from 'ol/Tile'; +export type PriorityFunction = ((param0: Tile, param1: string, param2: Coordinate, param3: number) => number); +export default class TileQueue extends PriorityQueue { + constructor(tilePriorityFunction: PriorityFunction, tileChangeCallback: (() => void)); + protected handleTileChange(event: Event): void; + getTilesLoading(): number; + loadMoreTiles(maxTotalLoading: number, maxNewLoads: number): void; +} diff --git a/types/ol/TileRange.d.ts b/types/ol/TileRange.d.ts new file mode 100644 index 0000000000..3875643a36 --- /dev/null +++ b/types/ol/TileRange.d.ts @@ -0,0 +1,15 @@ +import { Size } from 'ol/size'; +import { TileCoord } from 'ol/tilecoord'; +export function createOrUpdate(minX: number, maxX: number, minY: number, maxY: number, tileRange?: TileRange): TileRange; +export default class TileRange { + constructor(minX: number, maxX: number, minY: number, maxY: number); + contains(tileCoord: TileCoord): boolean; + containsTileRange(tileRange: TileRange): boolean; + containsXY(x: number, y: number): boolean; + equals(tileRange: TileRange): boolean; + extend(tileRange: TileRange): void; + getHeight(): number; + getSize(): Size; + getWidth(): number; + intersects(tileRange: TileRange): boolean; +} diff --git a/types/ol/TileState.d.ts b/types/ol/TileState.d.ts new file mode 100644 index 0000000000..5543db6e01 --- /dev/null +++ b/types/ol/TileState.d.ts @@ -0,0 +1,10 @@ +declare enum TileState { + IDLE = 0, + LOADING = 1, + LOADED = 2, + ERROR = 3, + EMPTY = 4, + ABORT = 5, +} + +export default TileState; diff --git a/types/ol/VectorImageTile.d.ts b/types/ol/VectorImageTile.d.ts new file mode 100644 index 0000000000..36e9cb7ca6 --- /dev/null +++ b/types/ol/VectorImageTile.d.ts @@ -0,0 +1,25 @@ +import Event from 'ol/events/Event'; +import FeatureFormat from 'ol/format/Feature'; +import Layer from 'ol/layer/Layer'; +import Projection from 'ol/proj/Projection'; +import { OrderFunction } from 'ol/render'; +import VectorTile_1 from 'ol/source/VectorTile'; +import Tile, { LoadFunction, UrlFunction } from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +import TileState from 'ol/TileState'; +import VectorTile from 'ol/VectorTile'; +export function defaultLoadFunction(tile: VectorTile, url: string): void; +export interface ReplayState { + dirty: boolean; + renderedRenderOrder: OrderFunction; + renderedTileRevision: number; + renderedRevision: number; +} +export default class VectorImageTile extends Tile { + constructor(tileCoord: TileCoord, state: TileState, sourceRevision: number, format: FeatureFormat, tileLoadFunction: LoadFunction, urlTileCoord: TileCoord, tileUrlFunction: UrlFunction, sourceTileGrid: TileGrid, tileGrid: TileGrid, sourceTiles: { [key: string]: VectorTile }, pixelRatio: number, projection: Projection, tileClass: VectorTile, handleTileChange: ((this: VectorTile_1, param1: Event) => void), zoom: number); + getContext(layer: Layer): CanvasRenderingContext2D; + getImage(layer: Layer): HTMLCanvasElement; + getReplayState(layer: Layer): ReplayState; + getTile(tileKey: string): VectorTile; +} diff --git a/types/ol/VectorTile.d.ts b/types/ol/VectorTile.d.ts new file mode 100644 index 0000000000..d2720ca4e5 --- /dev/null +++ b/types/ol/VectorTile.d.ts @@ -0,0 +1,25 @@ +import { Extent } from 'ol/extent'; +import Feature, { FeatureLike } from 'ol/Feature'; +import { FeatureLoader } from 'ol/featureloader'; +import FeatureFormat from 'ol/format/Feature'; +import Layer from 'ol/layer/Layer'; +import Projection from 'ol/proj/Projection'; +import ReplayGroup from 'ol/render/ReplayGroup'; +import Tile, { LoadFunction, Options } from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileState from 'ol/TileState'; +export default class VectorTile extends Tile { + constructor(tileCoord: TileCoord, state: TileState, src: string, format: FeatureFormat, tileLoadFunction: LoadFunction, opt_options?: Options); + onLoad(features: Feature[], dataProjection: Projection, extent: Extent): void; + getExtent(): Extent; + getFormat(): FeatureFormat; + getProjection(): Projection; + getReplayGroup(layer: Layer, key: string): ReplayGroup; + onError(): void; + getFeatures(): FeatureLike[]; + setExtent(extent: Extent): void; + setFeatures(features: Feature[]): void; + setLoader(loader: FeatureLoader): void; + setProjection(projection: Projection): void; + setReplayGroup(layer: Layer, key: string, replayGroup: ReplayGroup): void; +} diff --git a/types/ol/VectorTile/index.d.ts b/types/ol/VectorTile/index.d.ts deleted file mode 100644 index 21b2ed9297..0000000000 --- a/types/ol/VectorTile/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.VectorTile; diff --git a/types/ol/View.d.ts b/types/ol/View.d.ts new file mode 100644 index 0000000000..51913d4d0c --- /dev/null +++ b/types/ol/View.d.ts @@ -0,0 +1,143 @@ +import { Type } from 'ol/centerconstraint'; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import { Pixel } from 'ol/pixel'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import { Type as Type_2 } from 'ol/resolutionconstraint'; +import { Type as Type_1 } from 'ol/rotationconstraint'; +import { Size } from 'ol/size'; +import ViewHint from 'ol/ViewHint'; +export function createCenterConstraint(options: ViewOptions): Type; +export function createResolutionConstraint(options: ViewOptions): { [key: string]: any }; +export function createRotationConstraint(options: ViewOptions): Type_1; +export function isNoopAnimation(animation: Animation): boolean; +export interface Animation { + sourceCenter?: Coordinate; + targetCenter?: Coordinate; + sourceResolution?: number; + targetResolution?: number; + sourceRotation?: number; + targetRotation?: number; + anchor?: Coordinate; + start: number; + duration: number; + complete: boolean; + easing: ((param0: number) => number); + callback: ((param0: boolean) => void); +} +export interface AnimationOptions { + center?: Coordinate; + zoom?: number; + resolution?: number; + rotation?: number; + anchor?: Coordinate; + duration?: number; + easing?: ((param0: number) => number); +} +export interface Constraints { + center: Type; + resolution: Type_2; + rotation: Type_1; +} +export interface FitOptions { + size?: Size; + padding?: number[]; + constrainResolution?: boolean; + nearest?: boolean; + minResolution?: number; + maxZoom?: number; + duration?: number; + easing?: ((param0: number) => number); + callback?: ((param0: boolean) => void); +} +export interface State { + center: Coordinate; + projection: Projection; + resolution: number; + rotation: number; + zoom: number; +} +export default class View extends BaseObject { + constructor(opt_options?: ViewOptions); + getResolution(): number; + animate(...var_args: (AnimationOptions | ((param0: boolean) => void))[]): void; + calculateCenterRotate(rotation: number, anchor: Coordinate): Coordinate; + calculateCenterZoom(resolution: number, anchor: Coordinate): Coordinate; + calculateExtent(opt_size?: Size): Extent; + cancelAnimations(): void; + centerOn(coordinate: Coordinate, size: Size, position: Pixel): void; + constrainCenter(center: Coordinate): Coordinate; + constrainResolution(resolution: number, opt_delta?: number, opt_direction?: number): number; + constrainRotation(rotation: number, opt_delta?: number): number; + fit(geometryOrExtent: SimpleGeometry | Extent, opt_options?: FitOptions): void; + getAnimating(): boolean; + getCenter(): Coordinate; + getConstraints(): Constraints; + getHints(opt_hints?: number[]): number[]; + getInteracting(): boolean; + getMaxResolution(): number; + getMaxZoom(): number; + getMinResolution(): number; + getMinZoom(): number; + getProjection(): Projection; + applyOptions_(options: ViewOptions): void; + getResolutionForExtent(extent: Extent, opt_size?: Size): number; + getResolutionForValueFunction(opt_power?: number): ((param0: number) => number); + getResolutionForZoom(zoom: number): number; + getResolutions(): number[]; + getRotation(): number; + getState(pixelRatio: number): State; + getUpdatedOptions_(newOptions: ViewOptions): ViewOptions; + getValueForResolutionFunction(opt_power?: number): ((param0: number) => number); + getZoom(): number; + getZoomForResolution(resolution: number): number; + isDef(): boolean; + rotate(rotation: number, opt_anchor?: Coordinate): void; + setCenter(center: Coordinate): void; + setHint(hint: ViewHint, delta: number): number; + setMaxZoom(zoom: number): void; + setMinZoom(zoom: number): void; + setResolution(resolution: number): void; + setRotation(rotation: number): void; + setZoom(zoom: number): void; + updateAnimations_(): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:center', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:center', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:center', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:resolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:resolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:resolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:rotation', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:rotation', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:rotation', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface ViewOptions { + center?: Coordinate; + constrainRotation?: boolean | number; + enableRotation?: boolean; + extent?: Extent; + maxResolution?: number; + minResolution?: number; + maxZoom?: number; + minZoom?: number; + projection?: ProjectionLike; + resolution?: number; + resolutions?: number[]; + rotation?: number; + zoom?: number; + zoomFactor?: number; +} diff --git a/types/ol/View/index.d.ts b/types/ol/View/index.d.ts deleted file mode 100644 index 6df86cd89d..0000000000 --- a/types/ol/View/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.View; diff --git a/types/ol/ViewHint.d.ts b/types/ol/ViewHint.d.ts new file mode 100644 index 0000000000..f866df2210 --- /dev/null +++ b/types/ol/ViewHint.d.ts @@ -0,0 +1,6 @@ +declare enum ViewHint { + ANIMATING = 0, + INTERACTING = 1, +} + +export default ViewHint; diff --git a/types/ol/ViewProperty.d.ts b/types/ol/ViewProperty.d.ts new file mode 100644 index 0000000000..00a0347b2d --- /dev/null +++ b/types/ol/ViewProperty.d.ts @@ -0,0 +1,7 @@ +declare enum ViewProperty { + CENTER = 'center', + RESOLUTION = 'resolution', + ROTATION = 'rotation', +} + +export default ViewProperty; diff --git a/types/ol/WebGLMap.d.ts b/types/ol/WebGLMap.d.ts new file mode 100644 index 0000000000..b2b6db90cf --- /dev/null +++ b/types/ol/WebGLMap.d.ts @@ -0,0 +1,64 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import MapEvent from 'ol/MapEvent'; +import { ObjectEvent } from 'ol/Object'; +import PluggableMap, { MapOptions } from 'ol/PluggableMap'; +import RenderEvent from 'ol/render/Event'; +export default class WebGLMap extends PluggableMap { + constructor(options: MapOptions); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:size', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:target', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:view', listener: (evt: ObjectEvent) => void): void; + on(type: 'click', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'click', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'click', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'dblclick', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'moveend', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'moveend', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'moveend', listener: (evt: MapEvent) => void): void; + on(type: 'movestart', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'movestart', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'movestart', listener: (evt: MapEvent) => void): void; + on(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'pointerdrag', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'pointermove', listener: (evt: MapBrowserEvent) => void): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'postrender', listener: (evt: MapEvent) => void): EventsKey; + once(type: 'postrender', listener: (evt: MapEvent) => void): EventsKey; + un(type: 'postrender', listener: (evt: MapEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; + on(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + once(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): EventsKey; + un(type: 'singleclick', listener: (evt: MapBrowserEvent) => void): void; +} diff --git a/types/ol/array.d.ts b/types/ol/array.d.ts new file mode 100644 index 0000000000..572df14948 --- /dev/null +++ b/types/ol/array.d.ts @@ -0,0 +1,12 @@ +export function binarySearch(haystack: any[], needle: any, opt_comparator?: (() => void)): number; +export function equals(arr1: any[] | Uint8ClampedArray, arr2: any[] | Uint8ClampedArray): boolean; +export function extend(arr: VALUE[], data: VALUE[] | VALUE): void; +export function find(arr: VALUE[], func: (() => void)): VALUE; +export function findIndex(arr: any[], func: (() => void)): number; +export function includes(arr: any[], obj: any): boolean; +export function isSorted(arr: any[], opt_func?: (() => void), opt_strict?: boolean): boolean; +export function linearFindNearest(arr: number[], target: number, direction: number): number; +export function numberSafeCompareFunction(a: any, b: any): number; +export function remove(arr: VALUE[], obj: VALUE): boolean; +export function reverseSubArray(arr: any[], begin: number, end: number): void; +export function stableSort(arr: any[], compareFnc: (() => void)): void; diff --git a/types/ol/asserts.d.ts b/types/ol/asserts.d.ts new file mode 100644 index 0000000000..981fd95d5c --- /dev/null +++ b/types/ol/asserts.d.ts @@ -0,0 +1 @@ +export function assert(assertion: any, errorCode: number): void; diff --git a/types/ol/centerconstraint.d.ts b/types/ol/centerconstraint.d.ts new file mode 100644 index 0000000000..0704f6be31 --- /dev/null +++ b/types/ol/centerconstraint.d.ts @@ -0,0 +1,5 @@ +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +export function createExtent(extent: Extent): Type; +export function none(center?: Coordinate): Coordinate; +export type Type = ((param0: Coordinate) => Coordinate); diff --git a/types/ol/color.d.ts b/types/ol/color.d.ts new file mode 100644 index 0000000000..6d63087dca --- /dev/null +++ b/types/ol/color.d.ts @@ -0,0 +1,5 @@ +export function asArray(color: Color | string): Color; +export function asString(color: Color | string): string; +export function normalize(color: Color): Color; +export function toString(color: Color): string; +export type Color = number[]; diff --git a/types/ol/color/index.d.ts b/types/ol/color/index.d.ts deleted file mode 100644 index 92407b2fa4..0000000000 --- a/types/ol/color/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.color; diff --git a/types/ol/colorlike.d.ts b/types/ol/colorlike.d.ts new file mode 100644 index 0000000000..d7ce2bc15d --- /dev/null +++ b/types/ol/colorlike.d.ts @@ -0,0 +1,3 @@ +import { Color } from 'ol/color'; +export function asColorLike(color: Color | ColorLike): ColorLike; +export type ColorLike = string | CanvasPattern | CanvasGradient; diff --git a/types/ol/colorlike/index.d.ts b/types/ol/colorlike/index.d.ts deleted file mode 100644 index 5cf7ed88a8..0000000000 --- a/types/ol/colorlike/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.colorlike; diff --git a/types/ol/control/Attribution.d.ts b/types/ol/control/Attribution.d.ts index 9157d3ea5e..a3927cae01 100644 --- a/types/ol/control/Attribution.d.ts +++ b/types/ol/control/Attribution.d.ts @@ -1,3 +1,32 @@ -import * as ol from 'openlayers'; - -export default ol.control.Attribution; +import Control from 'ol/control/Control'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapEvent from 'ol/MapEvent'; +import { ObjectEvent } from 'ol/Object'; +export function render(mapEvent: MapEvent): void; +export default class Attribution extends Control { + constructor(opt_options?: Options); + getCollapsed(): boolean; + getCollapsible(): boolean; + setCollapsed(collapsed: boolean): void; + setCollapsible(collapsible: boolean): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + className?: string; + target?: HTMLElement | string; + collapsible?: boolean; + collapsed?: boolean; + tipLabel?: string; + label?: string | HTMLElement; + collapseLabel?: string | HTMLElement; + render?: ((param0: MapEvent) => void); +} diff --git a/types/ol/control/Control.d.ts b/types/ol/control/Control.d.ts index 221bc895aa..c50e3a42d2 100644 --- a/types/ol/control/Control.d.ts +++ b/types/ol/control/Control.d.ts @@ -1,3 +1,27 @@ -import * as ol from 'openlayers'; - -export default ol.control.Control; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapEvent from 'ol/MapEvent'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import PluggableMap from 'ol/PluggableMap'; +export default class Control extends BaseObject { + constructor(options: Options); + protected element: HTMLElement; + protected listenerKeys: EventsKey[]; + getMap(): PluggableMap; + setMap(map: PluggableMap): void; + setTarget(target: HTMLElement | string): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + element?: HTMLElement; + render?: ((param0: MapEvent) => void); + target?: HTMLElement | string; +} diff --git a/types/ol/control/FullScreen.d.ts b/types/ol/control/FullScreen.d.ts new file mode 100644 index 0000000000..e20d424b8c --- /dev/null +++ b/types/ol/control/FullScreen.d.ts @@ -0,0 +1,25 @@ +import Control from 'ol/control/Control'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +export default class FullScreen extends Control { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + className?: string; + label?: string | Text | HTMLElement; + labelActive?: string | Text | HTMLElement; + tipLabel?: string; + keys?: boolean; + target?: HTMLElement | string; + source?: HTMLElement | string; +} diff --git a/types/ol/control/Fullscreen.d.ts b/types/ol/control/Fullscreen.d.ts deleted file mode 100644 index 5f0112dd06..0000000000 --- a/types/ol/control/Fullscreen.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.control.FullScreen; diff --git a/types/ol/control/MousePosition.d.ts b/types/ol/control/MousePosition.d.ts index f8d89d4dff..a8470087be 100644 --- a/types/ol/control/MousePosition.d.ts +++ b/types/ol/control/MousePosition.d.ts @@ -1,3 +1,41 @@ -import * as ol from 'openlayers'; - -export default ol.control.MousePosition; +import Control from 'ol/control/Control'; +import { CoordinateFormat } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapEvent from 'ol/MapEvent'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +export function render(mapEvent: MapEvent): void; +export default class MousePosition extends Control { + constructor(opt_options?: Options); + protected handleMouseMove(event: Event): void; + protected handleMouseOut(event: Event): void; + getCoordinateFormat(): CoordinateFormat; + getProjection(): Projection; + setCoordinateFormat(format: CoordinateFormat): void; + setProjection(projection: ProjectionLike): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:coordinateFormat', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:coordinateFormat', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:coordinateFormat', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:projection', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:projection', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:projection', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + className?: string; + coordinateFormat?: CoordinateFormat; + projection?: ProjectionLike; + render?: ((param0: MapEvent) => void); + target?: HTMLElement | string; + undefinedHTML?: string; +} diff --git a/types/ol/control/OverviewMap.d.ts b/types/ol/control/OverviewMap.d.ts index 60dd9b8900..068a9ae1cc 100644 --- a/types/ol/control/OverviewMap.d.ts +++ b/types/ol/control/OverviewMap.d.ts @@ -1,3 +1,39 @@ -import * as ol from 'openlayers'; - -export default ol.control.OverviewMap; +import Collection from 'ol/Collection'; +import Control from 'ol/control/Control'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Layer from 'ol/layer/Layer'; +import MapEvent from 'ol/MapEvent'; +import { ObjectEvent } from 'ol/Object'; +import PluggableMap from 'ol/PluggableMap'; +import View from 'ol/View'; +export function render(mapEvent: MapEvent): void; +export interface Options { + className?: string; + collapsed?: boolean; + collapseLabel?: string | HTMLElement; + collapsible?: boolean; + label?: string | HTMLElement; + layers?: Layer[] | Collection; + render?: ((param0: MapEvent) => void); + target?: HTMLElement | string; + tipLabel?: string; + view?: View; +} +export default class OverviewMap extends Control { + constructor(opt_options?: Options); + getCollapsed(): boolean; + getCollapsible(): boolean; + getOverviewMap(): PluggableMap; + setCollapsed(collapsed: boolean): void; + setCollapsible(collapsible: boolean): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/control/Rotate.d.ts b/types/ol/control/Rotate.d.ts index 136db4ddeb..cdf4fe9c25 100644 --- a/types/ol/control/Rotate.d.ts +++ b/types/ol/control/Rotate.d.ts @@ -1,3 +1,28 @@ -import * as ol from 'openlayers'; - -export default ol.control.Rotate; +import Control from 'ol/control/Control'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapEvent from 'ol/MapEvent'; +import { ObjectEvent } from 'ol/Object'; +export function render(mapEvent: MapEvent): void; +export interface Options { + className?: string; + label?: string | HTMLElement; + tipLabel?: string; + duration?: number; + autoHide?: boolean; + render?: ((param0: MapEvent) => void); + resetNorth?: (() => void); + target?: HTMLElement | string; +} +export default class Rotate extends Control { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/control/ScaleLine.d.ts b/types/ol/control/ScaleLine.d.ts index bbcad827f3..fa0f27aab7 100644 --- a/types/ol/control/ScaleLine.d.ts +++ b/types/ol/control/ScaleLine.d.ts @@ -1,3 +1,37 @@ -import * as ol from 'openlayers'; - -export default ol.control.ScaleLine; +import Control from 'ol/control/Control'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapEvent from 'ol/MapEvent'; +import { ObjectEvent } from 'ol/Object'; +export function render(mapEvent: MapEvent): void; +export interface Options { + className?: string; + minWidth?: number; + render?: ((param0: MapEvent) => void); + target?: HTMLElement | string; + units?: Units | string; +} +export default class ScaleLine extends Control { + constructor(opt_options?: Options); + getUnits(): Units; + setUnits(units: Units): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:units', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:units', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:units', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export enum Units { + DEGREES = 'degrees', + IMPERIAL = 'imperial', + NAUTICAL = 'nautical', + METRIC = 'metric', + US = 'us', +} diff --git a/types/ol/control/Zoom.d.ts b/types/ol/control/Zoom.d.ts index 550d98c300..385f10b8cd 100644 --- a/types/ol/control/Zoom.d.ts +++ b/types/ol/control/Zoom.d.ts @@ -1,3 +1,26 @@ -import * as ol from 'openlayers'; - -export default ol.control.Zoom; +import Control from 'ol/control/Control'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +export interface Options { + duration?: number; + className?: string; + zoomInLabel?: string | HTMLElement; + zoomOutLabel?: string | HTMLElement; + zoomInTipLabel?: string; + zoomOutTipLabel?: string; + delta?: number; + target?: HTMLElement | string; +} +export default class Zoom extends Control { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/control/ZoomSlider.d.ts b/types/ol/control/ZoomSlider.d.ts index 4f5845939c..27c284d55f 100644 --- a/types/ol/control/ZoomSlider.d.ts +++ b/types/ol/control/ZoomSlider.d.ts @@ -1,3 +1,23 @@ -import * as ol from 'openlayers'; - -export default ol.control.ZoomSlider; +import Control from 'ol/control/Control'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapEvent from 'ol/MapEvent'; +import { ObjectEvent } from 'ol/Object'; +export function render(mapEvent: MapEvent): void; +export interface Options { + className?: string; + duration?: number; + render?: ((param0: MapEvent) => void); +} +export default class ZoomSlider extends Control { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/control/ZoomToExtent.d.ts b/types/ol/control/ZoomToExtent.d.ts index d536325932..ac094398ce 100644 --- a/types/ol/control/ZoomToExtent.d.ts +++ b/types/ol/control/ZoomToExtent.d.ts @@ -1,3 +1,26 @@ -import * as ol from 'openlayers'; - -export default ol.control.ZoomToExtent; +import Control from 'ol/control/Control'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import { ObjectEvent } from 'ol/Object'; +export interface Options { + className?: string; + target?: HTMLElement | string; + label?: string | HTMLElement; + tipLabel?: string; + extent?: Extent; +} +export default class ZoomToExtent extends Control { + constructor(opt_options?: Options); + protected extent: Extent; + protected handleZoomToExtent(): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/control/index.d.ts b/types/ol/control/index.d.ts index 551c3303d8..628d72f93e 100644 --- a/types/ol/control/index.d.ts +++ b/types/ol/control/index.d.ts @@ -1,3 +1,14 @@ -import * as ol from 'openlayers'; - -export default ol.control; +import Collection from 'ol/Collection'; +import Control from 'ol/control/Control'; +import { DefaultsOptions } from 'ol/control/util'; +export { default as Attribution } from 'ol/control/Attribution'; +export { default as Control } from 'ol/control/Control'; +export { default as FullScreen } from 'ol/control/FullScreen'; +export { default as MousePosition } from 'ol/control/MousePosition'; +export { default as OverviewMap } from 'ol/control/OverviewMap'; +export { default as Rotate } from 'ol/control/Rotate'; +export { default as ScaleLine } from 'ol/control/ScaleLine'; +export { default as Zoom } from 'ol/control/Zoom'; +export { default as ZoomSlider } from 'ol/control/ZoomSlider'; +export { default as ZoomToExtent } from 'ol/control/ZoomToExtent'; +export function defaults(opt_options?: DefaultsOptions): Collection; diff --git a/types/ol/control/util.d.ts b/types/ol/control/util.d.ts new file mode 100644 index 0000000000..391ed3e441 --- /dev/null +++ b/types/ol/control/util.d.ts @@ -0,0 +1,11 @@ +import { Options } from 'ol/control/Attribution'; +import { Options as Options_1 } from 'ol/control/Rotate'; +import { Options as Options_2 } from 'ol/control/Zoom'; +export interface DefaultsOptions { + attribution?: boolean; + attributionOptions?: Options; + rotate?: boolean; + rotateOptions?: Options_1; + zoom?: boolean; + zoomOptions?: Options_2; +} diff --git a/types/ol/coordinate.d.ts b/types/ol/coordinate.d.ts new file mode 100644 index 0000000000..c4ec695e75 --- /dev/null +++ b/types/ol/coordinate.d.ts @@ -0,0 +1,17 @@ +import Circle from 'ol/geom/Circle'; +export function add(coordinate: Coordinate, delta: Coordinate): Coordinate; +export function closestOnCircle(coordinate: Coordinate, circle: Circle): Coordinate; +export function closestOnSegment(coordinate: Coordinate, segment: Coordinate[]): Coordinate; +export function createStringXY(opt_fractionDigits?: number): CoordinateFormat; +export function degreesToStringHDMS(hemispheres: string, degrees: number, opt_fractionDigits?: number): string; +export function distance(coord1: Coordinate, coord2: Coordinate): number; +export function equals(coordinate1: Coordinate, coordinate2: Coordinate): boolean; +export function format(coordinate: Coordinate, template: string, opt_fractionDigits?: number): string; +export function rotate(coordinate: Coordinate, angle: number): Coordinate; +export function scale(coordinate: Coordinate, scale: number): Coordinate; +export function squaredDistance(coord1: Coordinate, coord2: Coordinate): number; +export function squaredDistanceToSegment(coordinate: Coordinate, segment: Coordinate[]): number; +export function toStringHDMS(coordinate: Coordinate, opt_fractionDigits?: number): string; +export function toStringXY(coordinate: Coordinate, opt_fractionDigits?: number): string; +export type Coordinate = number[]; +export type CoordinateFormat = ((param0: Coordinate) => string); diff --git a/types/ol/coordinate/index.d.ts b/types/ol/coordinate/index.d.ts deleted file mode 100644 index 9d95bc2f5b..0000000000 --- a/types/ol/coordinate/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.coordinate; diff --git a/types/ol/css.d.ts b/types/ol/css.d.ts new file mode 100644 index 0000000000..274592e4e6 --- /dev/null +++ b/types/ol/css.d.ts @@ -0,0 +1,7 @@ +export const CLASS_COLLAPSED: string; +export const CLASS_CONTROL: string; +export const CLASS_HIDDEN: string; +export const CLASS_SELECTABLE: string; +export const CLASS_UNSELECTABLE: string; +export const CLASS_UNSUPPORTED: string; +export const getFontFamilies: ((param0: string) => { [key: string]: any }); diff --git a/types/ol/deviceorientation/index.d.ts b/types/ol/deviceorientation/index.d.ts deleted file mode 100644 index 53ce703660..0000000000 --- a/types/ol/deviceorientation/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.DeviceOrientation; diff --git a/types/ol/dom.d.ts b/types/ol/dom.d.ts new file mode 100644 index 0000000000..3a61e5d8fa --- /dev/null +++ b/types/ol/dom.d.ts @@ -0,0 +1,6 @@ +export function createCanvasContext2D(opt_width?: number, opt_height?: number): CanvasRenderingContext2D; +export function outerHeight(element: HTMLElement): number; +export function outerWidth(element: HTMLElement): number; +export function removeChildren(node: Node): void; +export function removeNode(node: Node): Node; +export function replaceNode(newNode: Node, oldNode: Node): void; diff --git a/types/ol/easing.d.ts b/types/ol/easing.d.ts new file mode 100644 index 0000000000..046a8e92b0 --- /dev/null +++ b/types/ol/easing.d.ts @@ -0,0 +1,5 @@ +export function easeIn(t: number): number; +export function easeOut(t: number): number; +export function inAndOut(t: number): number; +export function linear(t: number): number; +export function upAndDown(t: number): number; diff --git a/types/ol/easing/index.d.ts b/types/ol/easing/index.d.ts deleted file mode 100644 index 28e1552f42..0000000000 --- a/types/ol/easing/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.easing; diff --git a/types/ol/events/Event.d.ts b/types/ol/events/Event.d.ts index 5aefb9f530..60441c5eb6 100644 --- a/types/ol/events/Event.d.ts +++ b/types/ol/events/Event.d.ts @@ -1,3 +1,9 @@ -import * as ol from 'openlayers'; - -export default ol.events.Event; +export function preventDefault(evt: Event | Event): void; +export function stopPropagation(evt: Event | Event): void; +export default class Event { + constructor(type: string); + target: { [key: string]: any }; + type: string; + preventDefault(): void; + stopPropagation(): void; +} diff --git a/types/ol/events/EventTarget.d.ts b/types/ol/events/EventTarget.d.ts deleted file mode 100644 index 898b74ee65..0000000000 --- a/types/ol/events/EventTarget.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.events.EventTarget; diff --git a/types/ol/events/EventType.d.ts b/types/ol/events/EventType.d.ts new file mode 100644 index 0000000000..08fb0459fc --- /dev/null +++ b/types/ol/events/EventType.d.ts @@ -0,0 +1,27 @@ +declare enum EventType { + CHANGE = 'change', + CLEAR = 'clear', + CONTEXTMENU = 'contextmenu', + CLICK = 'click', + DBLCLICK = 'dblclick', + DRAGENTER = 'dragenter', + DRAGOVER = 'dragover', + DROP = 'drop', + ERROR = 'error', + KEYDOWN = 'keydown', + KEYPRESS = 'keypress', + LOAD = 'load', + MOUSEDOWN = 'mousedown', + MOUSEMOVE = 'mousemove', + MOUSEOUT = 'mouseout', + MOUSEUP = 'mouseup', + MOUSEWHEEL = 'mousewheel', + MSPOINTERDOWN = 'MSPointerDown', + RESIZE = 'resize', + TOUCHSTART = 'touchstart', + TOUCHMOVE = 'touchmove', + TOUCHEND = 'touchend', + WHEEL = 'wheel', +} + +export default EventType; diff --git a/types/ol/events/KeyCode.d.ts b/types/ol/events/KeyCode.d.ts new file mode 100644 index 0000000000..8b3b17be33 --- /dev/null +++ b/types/ol/events/KeyCode.d.ts @@ -0,0 +1,8 @@ +declare enum KeyCode { + LEFT = 37, + UP = 38, + RIGHT = 39, + DOWN = 40, +} + +export default KeyCode; diff --git a/types/ol/events/Target.d.ts b/types/ol/events/Target.d.ts new file mode 100644 index 0000000000..179b13547c --- /dev/null +++ b/types/ol/events/Target.d.ts @@ -0,0 +1,12 @@ +import Disposable from 'ol/Disposable'; +import { ListenerFunction } from 'ol/events'; +import Event from 'ol/events/Event'; +export type EventTargetLike = EventTarget | Target; +export default class Target extends Disposable { + constructor(); + addEventListener(type: string, listener: ListenerFunction): void; + dispatchEvent(event: { [key: string]: any } | Event | string): boolean; + getListeners(type: string): ListenerFunction[]; + hasListener(opt_type?: string): boolean; + removeEventListener(type: string, listener: ListenerFunction): void; +} diff --git a/types/ol/events/condition.d.ts b/types/ol/events/condition.d.ts index bb43999775..4838d7c11f 100644 --- a/types/ol/events/condition.d.ts +++ b/types/ol/events/condition.d.ts @@ -1,3 +1,19 @@ -import * as ol from 'openlayers'; - -export default ol.events.condition; +import { TRUE, FALSE } from 'ol/functions'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +export function altKeyOnly(mapBrowserEvent: MapBrowserEvent): boolean; +export function altShiftKeysOnly(mapBrowserEvent: MapBrowserEvent): boolean; +export const always: typeof TRUE; +export function click(mapBrowserEvent: MapBrowserEvent): boolean; +export type Condition = ((this: any, param1: MapBrowserEvent) => boolean); +export function doubleClick(mapBrowserEvent: MapBrowserEvent): boolean; +export function focus(event: MapBrowserEvent): boolean; +export function mouseActionButton(mapBrowserEvent: MapBrowserEvent): boolean; +export function mouseOnly(mapBrowserEvent: MapBrowserEvent): boolean; +export const never: typeof FALSE; +export function noModifierKeys(mapBrowserEvent: MapBrowserEvent): boolean; +export function platformModifierKeyOnly(mapBrowserEvent: MapBrowserEvent): boolean; +export function pointerMove(mapBrowserEvent: MapBrowserEvent): boolean; +export function primaryAction(mapBrowserEvent: MapBrowserEvent): boolean; +export function shiftKeyOnly(mapBrowserEvent: MapBrowserEvent): boolean; +export function singleClick(mapBrowserEvent: MapBrowserEvent): boolean; +export function targetNotEditable(mapBrowserEvent: MapBrowserEvent): boolean; diff --git a/types/ol/events/index.d.ts b/types/ol/events/index.d.ts index defc980e5a..4b594f3ab1 100644 --- a/types/ol/events/index.d.ts +++ b/types/ol/events/index.d.ts @@ -1,3 +1,20 @@ -import * as ol from 'openlayers'; - -export default ol.events; +import Event from 'ol/events/Event'; +import { EventTargetLike } from 'ol/events/Target'; +export function bindListener(listenerObj: EventsKey): ListenerFunction; +export function findListener(listeners: EventsKey[], listener: (() => void), opt_this?: { [key: string]: any }, opt_setDeleteIndex?: boolean): EventsKey; +export function getListeners(target: EventTargetLike, type: string): EventsKey[]; +export function listen(target: EventTargetLike, type: string, listener: ListenerFunction, opt_this?: { [key: string]: any }, opt_once?: boolean): EventsKey; +export function listenOnce(target: EventTargetLike, type: string, listener: ListenerFunction, opt_this?: { [key: string]: any }): EventsKey; +export function unlisten(target: EventTargetLike, type: string, listener: ListenerFunction, opt_this?: { [key: string]: any }): void; +export function unlistenAll(target: EventTargetLike): void; +export function unlistenByKey(key: EventsKey): void; +export interface EventsKey { + bindTo?: { [key: string]: any }; + boundListener?: ListenerFunction; + callOnce: boolean; + deleteIndex?: number; + listener: ListenerFunction; + target: EventTargetLike; + type: string; +} +export type ListenerFunction = ((param0: Event | Event) => void | boolean); diff --git a/types/ol/extent/Corner.d.ts b/types/ol/extent/Corner.d.ts new file mode 100644 index 0000000000..0cfec54d3a --- /dev/null +++ b/types/ol/extent/Corner.d.ts @@ -0,0 +1,8 @@ +declare enum Corner { + BOTTOM_LEFT = 'bottom-left', + BOTTOM_RIGHT = 'bottom-right', + TOP_LEFT = 'top-left', + TOP_RIGHT = 'top-right', +} + +export default Corner; diff --git a/types/ol/extent/Relationship.d.ts b/types/ol/extent/Relationship.d.ts new file mode 100644 index 0000000000..b7fb6080f4 --- /dev/null +++ b/types/ol/extent/Relationship.d.ts @@ -0,0 +1,10 @@ +declare enum Relationship { + UNKNOWN = 0, + INTERSECTING = 1, + ABOVE = 2, + RIGHT = 4, + BELOW = 8, + LEFT = 16, +} + +export default Relationship; diff --git a/types/ol/extent/index.d.ts b/types/ol/extent/index.d.ts index a4c284b29e..9031790bd9 100644 --- a/types/ol/extent/index.d.ts +++ b/types/ol/extent/index.d.ts @@ -1,3 +1,50 @@ -import * as ol from 'openlayers'; - -export default ol.extent; +import { Coordinate } from 'ol/coordinate'; +import Corner from 'ol/extent/Corner'; +import Relationship from 'ol/extent/Relationship'; +import { TransformFunction } from 'ol/proj'; +import { Size } from 'ol/size'; +export function applyTransform(extent: Extent, transformFn: TransformFunction, opt_extent?: Extent): Extent; +export function boundingExtent(coordinates: Coordinate[]): Extent; +export function buffer(extent: Extent, value: number, opt_extent?: Extent): Extent; +export function clone(extent: Extent, opt_extent?: Extent): Extent; +export function closestSquaredDistanceXY(extent: Extent, x: number, y: number): number; +export function containsCoordinate(extent: Extent, coordinate: Coordinate): boolean; +export function containsExtent(extent1: Extent, extent2: Extent): boolean; +export function containsXY(extent: Extent, x: number, y: number): boolean; +export function coordinateRelationship(extent: Extent, coordinate: Coordinate): Relationship; +export function createEmpty(): Extent; +export function createOrUpdate(minX: number, minY: number, maxX: number, maxY: number, opt_extent?: Extent): Extent; +export function createOrUpdateEmpty(opt_extent?: Extent): Extent; +export function createOrUpdateFromCoordinate(coordinate: Coordinate, opt_extent?: Extent): Extent; +export function createOrUpdateFromCoordinates(coordinates: Coordinate[], opt_extent?: Extent): Extent; +export function createOrUpdateFromFlatCoordinates(flatCoordinates: number[], offset: number, end: number, stride: number, opt_extent?: Extent): Extent; +export function createOrUpdateFromRings(rings: Coordinate[][], opt_extent?: Extent): Extent; +export function equals(extent1: Extent, extent2: Extent): boolean; +export function extend(extent1: Extent, extent2: Extent): Extent; +export function extendCoordinate(extent: Extent, coordinate: Coordinate): void; +export function extendCoordinates(extent: Extent, coordinates: Coordinate[]): Extent; +export function extendFlatCoordinates(extent: Extent, flatCoordinates: number[], offset: number, end: number, stride: number): Extent; +export function extendRings(extent: Extent, rings: Coordinate[][]): Extent; +export function extendXY(extent: Extent, x: number, y: number): void; +export function forEachCorner(extent: Extent, callback: ((this: T, param1: Coordinate) => S), opt_this?: T): S | boolean; +export function getArea(extent: Extent): number; +export function getBottomLeft(extent: Extent): Coordinate; +export function getBottomRight(extent: Extent): Coordinate; +export function getCenter(extent: Extent): Coordinate; +export function getCorner(extent: Extent, corner: Corner): Coordinate; +export function getEnlargedArea(extent1: Extent, extent2: Extent): number; +export function getForViewAndSize(center: Coordinate, resolution: number, rotation: number, size: Size, opt_extent?: Extent): Extent; +export function getHeight(extent: Extent): number; +export function getIntersection(extent1: Extent, extent2: Extent, opt_extent?: Extent): Extent; +export function getIntersectionArea(extent1: Extent, extent2: Extent): number; +export function getMargin(extent: Extent): number; +export function getSize(extent: Extent): Size; +export function getTopLeft(extent: Extent): Coordinate; +export function getTopRight(extent: Extent): Coordinate; +export function getWidth(extent: Extent): number; +export function intersects(extent1: Extent, extent2: Extent): boolean; +export function intersectsSegment(extent: Extent, start: Coordinate, end: Coordinate): boolean; +export function isEmpty(extent: Extent): boolean; +export function returnOrUpdate(extent: Extent, opt_extent?: Extent): Extent; +export function scaleFromCenter(extent: Extent, value: number): void; +export type Extent = number[]; diff --git a/types/ol/featureloader.d.ts b/types/ol/featureloader.d.ts new file mode 100644 index 0000000000..f8ac9f37c6 --- /dev/null +++ b/types/ol/featureloader.d.ts @@ -0,0 +1,9 @@ +import { Extent } from 'ol/extent'; +import FeatureFormat from 'ol/format/Feature'; +import Projection from 'ol/proj/Projection'; +import VectorSource from 'ol/source/Vector'; +import VectorTile from 'ol/VectorTile'; +export function loadFeaturesXhr(url: string | FeatureUrlFunction, format: FeatureFormat, success: (() => void) | (() => void), failure: ((this: VectorSource) => void) | (() => void)): FeatureLoader; +export function xhr(url: string | FeatureUrlFunction, format: FeatureFormat): FeatureLoader; +export type FeatureLoader = ((this: VectorSource | VectorTile, param1: Extent, param2: number, param3: Projection) => void); +export type FeatureUrlFunction = ((param0: Extent, param1: number, param2: Projection) => string); diff --git a/types/ol/featureloader/index.d.ts b/types/ol/featureloader/index.d.ts deleted file mode 100644 index 3d3d4a1105..0000000000 --- a/types/ol/featureloader/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.featureloader; diff --git a/types/ol/format/EsriJSON.d.ts b/types/ol/format/EsriJSON.d.ts index 5145422ade..895cd120a6 100644 --- a/types/ol/format/EsriJSON.d.ts +++ b/types/ol/format/EsriJSON.d.ts @@ -1,3 +1,39 @@ -import * as ol from 'openlayers'; - -export default ol.format.EsriJSON; +import { + Feature, + FeatureSet, + Geometry, + HasZM, + Multipoint, + Point, + Polygon, + Polyline, + Position, + SpatialReferenceWkid +} from 'arcgis-rest-api'; +import { ReadOptions, WriteOptions } from 'ol/format/Feature'; +import JSONFeature from 'ol/format/JSONFeature'; +import Geometry_1 from 'ol/geom/Geometry'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +export default class EsriJSON extends JSONFeature { + constructor(opt_options?: Options); +} +export type EsriJSONFeature = Feature; +export type EsriJSONFeatureSet = FeatureSet; +export type EsriJSONGeometry = Geometry; +export type EsriJSONHasZM = HasZM; +export type EsriJSONMultipoint = Multipoint; +export interface EsriJSONMultiPolygon { + rings: number[][][][]; + hasM?: boolean; + hasZ?: boolean; + spatialReference?: EsriJSONSpatialReferenceWkid; +} +export type EsriJSONPoint = Point; +export type EsriJSONPolygon = Polygon; +export type EsriJSONPolyline = Polyline; +export type EsriJSONPosition = Position; +export type EsriJSONSpatialReferenceWkid = SpatialReferenceWkid; +export interface Options { + geometryName?: string; +} diff --git a/types/ol/format/Feature.d.ts b/types/ol/format/Feature.d.ts index dc53e6709a..3b1dcb41ea 100644 --- a/types/ol/format/Feature.d.ts +++ b/types/ol/format/Feature.d.ts @@ -1,3 +1,34 @@ -import * as ol from 'openlayers'; - -export default ol.format.Feature; +import { Extent } from 'ol/extent'; +import Feature, { FeatureLike } from 'ol/Feature'; +import FormatType from 'ol/format/FormatType'; +import Geometry from 'ol/geom/Geometry'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +export function transformWithOptions(geometry: Geometry | Extent, write: boolean, opt_options?: WriteOptions | ReadOptions): Geometry | Extent; +export default class FeatureFormat { + constructor(); + protected defaultFeatureProjection: Projection; + protected dataProjection: Projection; + protected adaptOptions(options: WriteOptions | ReadOptions): WriteOptions | ReadOptions; + protected getReadOptions(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): ReadOptions; + writeGeometry(geometry: Geometry, opt_options?: WriteOptions): string; + getType(): FormatType; + getLastExtent(): Extent; + readFeatures(source: Document | Node | ArrayBuffer | { [key: string]: any } | string, opt_options?: ReadOptions): FeatureLike[]; + readGeometry(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Geometry; + readProjection(source: Document | Node | { [key: string]: any } | string): Projection; + writeFeature(feature: Feature, opt_options?: WriteOptions): string; + writeFeatures(features: Feature[], opt_options?: WriteOptions): string; + readFeature(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): FeatureLike; +} +export interface ReadOptions { + dataProjection?: ProjectionLike; + extent?: Extent; + featureProjection?: ProjectionLike; +} +export interface WriteOptions { + dataProjection?: ProjectionLike; + featureProjection?: ProjectionLike; + rightHanded?: boolean; + decimals?: number; +} diff --git a/types/ol/format/FormatType.d.ts b/types/ol/format/FormatType.d.ts new file mode 100644 index 0000000000..40ab273942 --- /dev/null +++ b/types/ol/format/FormatType.d.ts @@ -0,0 +1,8 @@ +declare enum FormatType { + ARRAY_BUFFER = 'arraybuffer', + JSON = 'json', + TEXT = 'text', + XML = 'xml', +} + +export default FormatType; diff --git a/types/ol/format/GML.d.ts b/types/ol/format/GML.d.ts new file mode 100644 index 0000000000..2cb15664e6 --- /dev/null +++ b/types/ol/format/GML.d.ts @@ -0,0 +1,4 @@ +import GML3 from 'ol/format/GML3'; +declare const GML: GML3; + +export default GML; diff --git a/types/ol/format/GML2.d.ts b/types/ol/format/GML2.d.ts index 95cdee80b7..41d089d172 100644 --- a/types/ol/format/GML2.d.ts +++ b/types/ol/format/GML2.d.ts @@ -1,3 +1,13 @@ -import * as ol from 'openlayers'; - -export default ol.format.GML2; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import GMLBase, { Options } from 'ol/format/GMLBase'; +import Geometry from 'ol/geom/Geometry'; +import { Parser } from 'ol/xml'; +export default class GML2 extends GMLBase { + constructor(opt_options?: Options); + protected FLAT_LINEAR_RINGS_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected GEOMETRY_FLAT_COORDINATES_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected GEOMETRY_PARSERS: { [key: string]: { [key: string]: Parser } }; + writeFeatureElement(node: Element, feature: Feature, objectStack: any[]): void; + writeGeometryElement(node: Node, geometry: Geometry | Extent, objectStack: any[]): void; +} diff --git a/types/ol/format/GML3.d.ts b/types/ol/format/GML3.d.ts index 416fc64c24..edae6d4afa 100644 --- a/types/ol/format/GML3.d.ts +++ b/types/ol/format/GML3.d.ts @@ -1,3 +1,16 @@ -import * as ol from 'openlayers'; - -export default ol.format.GML3; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import { WriteOptions } from 'ol/format/Feature'; +import GMLBase, { Options } from 'ol/format/GMLBase'; +import Geometry from 'ol/geom/Geometry'; +import { Parser } from 'ol/xml'; +export default class GML3 extends GMLBase { + constructor(opt_options?: Options); + protected FLAT_LINEAR_RINGS_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected GEOMETRY_FLAT_COORDINATES_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected GEOMETRY_PARSERS: { [key: string]: { [key: string]: Parser } }; + writeEnvelope(node: Element, extent: Extent, objectStack: any[]): void; + writeFeatureElement(node: Element, feature: Feature, objectStack: any[]): void; + writeFeatures(features: Feature[], opt_options?: WriteOptions): string; + writeGeometryElement(node: Node, geometry: Geometry | Extent, objectStack: any[]): void; +} diff --git a/types/ol/format/GML32.d.ts b/types/ol/format/GML32.d.ts new file mode 100644 index 0000000000..45fa05afa7 --- /dev/null +++ b/types/ol/format/GML32.d.ts @@ -0,0 +1,10 @@ +import GML3 from 'ol/format/GML3'; +import { Options } from 'ol/format/GMLBase'; +import { Parser } from 'ol/xml'; +export default class GML32 extends GML3 { + constructor(opt_options?: Options); + protected FLAT_LINEAR_RINGS_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected GEOMETRY_FLAT_COORDINATES_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected GEOMETRY_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected RING_PARSERS: { [key: string]: { [key: string]: Parser } }; +} diff --git a/types/ol/format/GMLBase.d.ts b/types/ol/format/GMLBase.d.ts index 5d495bc5c0..a353a6a90c 100644 --- a/types/ol/format/GMLBase.d.ts +++ b/types/ol/format/GMLBase.d.ts @@ -1,3 +1,45 @@ -import * as ol from 'openlayers'; - -export default ol.format.GMLBase; +import Feature from 'ol/Feature'; +import XMLFeature from 'ol/format/XMLFeature'; +import Geometry from 'ol/geom/Geometry'; +import LinearRing from 'ol/geom/LinearRing'; +import LineString from 'ol/geom/LineString'; +import MultiLineString from 'ol/geom/MultiLineString'; +import MultiPoint from 'ol/geom/MultiPoint'; +import MultiPolygon from 'ol/geom/MultiPolygon'; +import Point from 'ol/geom/Point'; +import Polygon from 'ol/geom/Polygon'; +import { Parser } from 'ol/xml'; +export default class GMLBase extends XMLFeature { + constructor(opt_options?: Options); + protected featureNS: { [key: string]: string } | string; + protected srsName: string; + protected schemaLocation: string; + protected featureType: string[] | string; + protected GEOMETRY_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected GEOMETRY_FLAT_COORDINATES_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected RING_PARSERS: { [key: string]: { [key: string]: Parser } }; + protected FLAT_LINEAR_RINGS_PARSERS: { [key: string]: { [key: string]: Parser } }; + readGeometryElement(node: Element, objectStack: any[]): Geometry; + readLinearRing(node: Element, objectStack: any[]): LinearRing; + readLineString(node: Element, objectStack: any[]): LineString; + readFeatureElement(node: Element, objectStack: any[]): Feature; + readMultiPoint(node: Element, objectStack: any[]): MultiPoint; + readMultiPolygon(node: Element, objectStack: any[]): MultiPolygon; + readPoint(node: Element, objectStack: any[]): Point; + readPolygon(node: Element, objectStack: any[]): Polygon; + readFeatureElementInternal(node: Element, objectStack: any[], asFeature: boolean): Feature | { [key: string]: any }; + readFeaturesInternal(node: Element, objectStack: any[]): Feature[]; + readMultiLineString(node: Element, objectStack: any[]): MultiLineString; +} +export const GMLNS: string; +export interface Options { + featureNS?: { [key: string]: string } | string; + featureType?: string[] | string; + srsName: string; + surface?: boolean; + curve?: boolean; + multiCurve?: boolean; + multiSurface?: boolean; + schemaLocation?: string; + hasZ?: boolean; +} diff --git a/types/ol/format/GPX.d.ts b/types/ol/format/GPX.d.ts index 3094e44275..344c9651fa 100644 --- a/types/ol/format/GPX.d.ts +++ b/types/ol/format/GPX.d.ts @@ -1,3 +1,15 @@ -import * as ol from 'openlayers'; - -export default ol.format.GPX; +import { Coordinate } from 'ol/coordinate'; +import Feature from 'ol/Feature'; +import XMLFeature from 'ol/format/XMLFeature'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import LineString from 'ol/geom/LineString'; +export default class GPX extends XMLFeature { + constructor(opt_options?: Options); +} +export interface LayoutOptions { + hasZ?: boolean; + hasM?: boolean; +} +export interface Options { + readExtensions?: ((param0: Feature, param1: Node) => void); +} diff --git a/types/ol/format/GeoJSON.d.ts b/types/ol/format/GeoJSON.d.ts index d954287590..6821682441 100644 --- a/types/ol/format/GeoJSON.d.ts +++ b/types/ol/format/GeoJSON.d.ts @@ -1,3 +1,43 @@ -import * as ol from 'openlayers'; - -export default ol.format.GeoJSON; +import { + Feature, + FeatureCollection, + Geometry, + GeometryCollection, + LineString, + MultiLineString, + MultiPoint, + MultiPolygon, + Point, + Polygon +} from 'geojson'; +import { ReadOptions, WriteOptions } from 'ol/format/Feature'; +import JSONFeature from 'ol/format/JSONFeature'; +import Geometry_1 from 'ol/geom/Geometry'; +import GeometryCollection_1 from 'ol/geom/GeometryCollection'; +import LineString_1 from 'ol/geom/LineString'; +import MultiLineString_1 from 'ol/geom/MultiLineString'; +import MultiPoint_1 from 'ol/geom/MultiPoint'; +import MultiPolygon_1 from 'ol/geom/MultiPolygon'; +import Point_1 from 'ol/geom/Point'; +import Polygon_1 from 'ol/geom/Polygon'; +import { ProjectionLike } from 'ol/proj'; +export default class GeoJSON extends JSONFeature { + constructor(opt_options?: Options); +} +export type GeoJSONFeature = Feature; +export type GeoJSONFeatureCollection = FeatureCollection; +export type GeoJSONGeometry = Geometry; +export type GeoJSONGeometryCollection = GeometryCollection; +export type GeoJSONLineString = LineString; +export type GeoJSONMultiLineString = MultiLineString; +export type GeoJSONMultiPoint = MultiPoint; +export type GeoJSONMultiPolygon = MultiPolygon; +export type GeoJSONObject = GeoJSON; +export type GeoJSONPoint = Point; +export type GeoJSONPolygon = Polygon; +export interface Options { + dataProjection?: ProjectionLike; + featureProjection?: ProjectionLike; + geometryName?: string; + extractGeometryName?: boolean; +} diff --git a/types/ol/format/IGC.d.ts b/types/ol/format/IGC.d.ts index d358419696..c21982c464 100644 --- a/types/ol/format/IGC.d.ts +++ b/types/ol/format/IGC.d.ts @@ -1,3 +1,12 @@ -import * as ol from 'openlayers'; - -export default ol.format.IGC; +import TextFeature from 'ol/format/TextFeature'; +export default class IGC extends TextFeature { + constructor(opt_options?: Options); +} +export enum IGCZ { + BAROMETRIC = 'barometric', + GPS = 'gps', + NONE = 'none', +} +export interface Options { + altitudeMode?: IGCZ | string; +} diff --git a/types/ol/format/JSONFeature.d.ts b/types/ol/format/JSONFeature.d.ts index cf76949b70..67342b2530 100644 --- a/types/ol/format/JSONFeature.d.ts +++ b/types/ol/format/JSONFeature.d.ts @@ -1,3 +1,25 @@ -import * as ol from 'openlayers'; - -export default ol.format.JSONFeature; +import Feature, { FeatureLike } from 'ol/Feature'; +import FeatureFormat, { ReadOptions, WriteOptions } from 'ol/format/Feature'; +import Geometry from 'ol/geom/Geometry'; +import Projection from 'ol/proj/Projection'; +export default class JSONFeature extends FeatureFormat { + constructor(); + protected readProjectionFromObject(object: { [key: string]: any }): Projection; + protected readFeaturesFromObject(object: { [key: string]: any }, opt_options?: ReadOptions): Feature[]; + protected readGeometryFromObject(object: { [key: string]: any }, opt_options?: ReadOptions): Geometry; + protected readFeatureFromObject(object: { [key: string]: any }, opt_options?: ReadOptions): Feature; + readGeometry(source: ArrayBuffer | Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Geometry; + readGeometry(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Geometry; + readFeatures(source: ArrayBuffer | Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Feature[]; + readFeatures(source: Document | Node | ArrayBuffer | { [key: string]: any } | string, opt_options?: ReadOptions): FeatureLike[]; + readProjection(source: ArrayBuffer | Document | Node | { [key: string]: any } | string): Projection; + readProjection(source: Document | Node | { [key: string]: any } | string): Projection; + readFeature(source: ArrayBuffer | Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Feature; + readFeature(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): FeatureLike; + writeFeature(feature: Feature, opt_options?: WriteOptions): string; + writeFeatureObject(feature: Feature, opt_options?: WriteOptions): { [key: string]: any }; + writeFeatures(features: Feature[], opt_options?: WriteOptions): string; + writeFeaturesObject(features: Feature[], opt_options?: WriteOptions): { [key: string]: any }; + writeGeometry(geometry: Geometry, opt_options?: WriteOptions): string; + writeGeometryObject(geometry: Geometry, opt_options?: WriteOptions): { [key: string]: any }; +} diff --git a/types/ol/format/KML.d.ts b/types/ol/format/KML.d.ts index 6f45f45005..cca9c0eb1f 100644 --- a/types/ol/format/KML.d.ts +++ b/types/ol/format/KML.d.ts @@ -1,3 +1,56 @@ -import * as ol from 'openlayers'; - -export default ol.format.KML; +import { Color } from 'ol/color'; +import Feature from 'ol/Feature'; +import XMLFeature from 'ol/format/XMLFeature'; +import Geometry from 'ol/geom/Geometry'; +import LinearRing from 'ol/geom/LinearRing'; +import LineString from 'ol/geom/LineString'; +import MultiLineString from 'ol/geom/MultiLineString'; +import MultiPoint from 'ol/geom/MultiPoint'; +import MultiPolygon from 'ol/geom/MultiPolygon'; +import Point from 'ol/geom/Point'; +import Polygon from 'ol/geom/Polygon'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import Fill from 'ol/style/Fill'; +import Icon from 'ol/style/Icon'; +import IconAnchorUnits from 'ol/style/IconAnchorUnits'; +import IconOrigin from 'ol/style/IconOrigin'; +import ImageStyle from 'ol/style/Image'; +import Stroke from 'ol/style/Stroke'; +import Style, { StyleFunction } from 'ol/style/Style'; +import Text from 'ol/style/Text'; +export function getDefaultFillStyle(): Fill; +export function getDefaultImageStyle(): ImageStyle; +export function getDefaultStrokeStyle(): Stroke; +export function getDefaultStyle(): Style; +export function getDefaultStyleArray(): Style[]; +export function getDefaultTextStyle(): Text; +export function readFlatCoordinates(node: Node): number[]; +export interface GxTrackObject { + flatCoordinates: number[]; + whens: number[]; +} +export default class KML extends XMLFeature { + constructor(opt_options?: Options); + readName(source: Document | Element | string): string; + readNameFromDocument(doc: Document): string; + readNameFromNode(node: Element): string; + readNetworkLinks(source: Document | Element | string): { [key: string]: any }[]; + readNetworkLinksFromDocument(doc: Document): { [key: string]: any }[]; + readNetworkLinksFromNode(node: Element): { [key: string]: any }[]; + readRegion(source: Document | Element | string): { [key: string]: any }[]; + readRegionFromDocument(doc: Document): { [key: string]: any }[]; + readRegionFromNode(node: Element): { [key: string]: any }[]; +} +export interface Options { + extractStyles?: boolean; + showPointNames?: boolean; + defaultStyle?: Style[]; + writeStyles?: boolean; +} +export interface Vec2 { + x: number; + xunits: IconAnchorUnits; + y: number; + yunits: IconAnchorUnits; + origin: IconOrigin; +} diff --git a/types/ol/format/MVT.d.ts b/types/ol/format/MVT.d.ts index 857aaea5e7..c136024754 100644 --- a/types/ol/format/MVT.d.ts +++ b/types/ol/format/MVT.d.ts @@ -1,3 +1,13 @@ -import * as ol from 'openlayers'; - -export default ol.format.MVT; +import { FeatureClass } from 'ol/Feature'; +import FeatureFormat from 'ol/format/Feature'; +import GeometryType from 'ol/geom/GeometryType'; +export default class MVT extends FeatureFormat { + constructor(opt_options?: Options); + setLayers(layers: string[]): void; +} +export interface Options { + featureClass?: FeatureClass; + geometryName?: string; + layerName?: string; + layers?: string[]; +} diff --git a/types/ol/format/OSMXML.d.ts b/types/ol/format/OSMXML.d.ts index 67029aa020..7e80fa4bde 100644 --- a/types/ol/format/OSMXML.d.ts +++ b/types/ol/format/OSMXML.d.ts @@ -1,3 +1,4 @@ -import * as ol from 'openlayers'; - -export default ol.format.OSMXML; +import XMLFeature from 'ol/format/XMLFeature'; +export default class OSMXML extends XMLFeature { + constructor(); +} diff --git a/types/ol/format/OWS.d.ts b/types/ol/format/OWS.d.ts new file mode 100644 index 0000000000..efcd8ddf6a --- /dev/null +++ b/types/ol/format/OWS.d.ts @@ -0,0 +1,4 @@ +import XML from 'ol/format/XML'; +export default class OWS extends XML { + constructor(); +} diff --git a/types/ol/format/Polyline.d.ts b/types/ol/format/Polyline.d.ts index 6c60d844c3..41e0f8aecb 100644 --- a/types/ol/format/Polyline.d.ts +++ b/types/ol/format/Polyline.d.ts @@ -1,3 +1,18 @@ -import * as ol from 'openlayers'; - -export default ol.format.Polyline; +import TextFeature from 'ol/format/TextFeature'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +export function decodeDeltas(encoded: string, stride: number, opt_factor?: number): number[]; +export function decodeFloats(encoded: string, opt_factor?: number): number[]; +export function decodeSignedIntegers(encoded: string): number[]; +export function decodeUnsignedIntegers(encoded: string): number[]; +export function encodeDeltas(numbers: number[], stride: number, opt_factor?: number): string; +export function encodeFloats(numbers: number[], opt_factor?: number): string; +export function encodeSignedIntegers(numbers: number[]): string; +export function encodeUnsignedInteger(num: number): string; +export function encodeUnsignedIntegers(numbers: number[]): string; +export interface Options { + factor?: number; + geometryLayout?: GeometryLayout; +} +export default class Polyline extends TextFeature { + constructor(opt_options?: Options); +} diff --git a/types/ol/format/TextFeature.d.ts b/types/ol/format/TextFeature.d.ts index 13c50b8f80..7552a7f923 100644 --- a/types/ol/format/TextFeature.d.ts +++ b/types/ol/format/TextFeature.d.ts @@ -1,3 +1,23 @@ -import * as ol from 'openlayers'; - -export default ol.format.TextFeature; +import Feature, { FeatureLike } from 'ol/Feature'; +import FeatureFormat, { WriteOptions, ReadOptions } from 'ol/format/Feature'; +import Geometry from 'ol/geom/Geometry'; +import Projection from 'ol/proj/Projection'; +export default class TextFeature extends FeatureFormat { + constructor(); + protected readProjectionFromText(text: string): Projection; + protected writeGeometryText(geometry: Geometry, opt_options?: WriteOptions): string; + protected writeFeatureText(feature: Feature, opt_options?: WriteOptions): string; + protected readFeaturesFromText(text: string, opt_options?: ReadOptions): Feature[]; + protected writeFeaturesText(features: Feature[], opt_options?: WriteOptions): string; + protected readGeometryFromText(text: string, opt_options?: ReadOptions): Geometry; + protected readFeatureFromText(text: string, opt_options?: ReadOptions): Feature; + readProjection(source: Document | Node | { [key: string]: any } | string): Projection; + writeFeature(feature: Feature, opt_options?: WriteOptions): string; + writeFeatures(features: Feature[], opt_options?: WriteOptions): string; + readGeometry(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Geometry; + readFeatures(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Feature[]; + readFeatures(source: Document | Node | ArrayBuffer | { [key: string]: any } | string, opt_options?: ReadOptions): FeatureLike[]; + writeGeometry(geometry: Geometry, opt_options?: WriteOptions): string; + readFeature(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Feature; + readFeature(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): FeatureLike; +} diff --git a/types/ol/format/TopoJSON.d.ts b/types/ol/format/TopoJSON.d.ts index af1258d5a2..bb97ca28b2 100644 --- a/types/ol/format/TopoJSON.d.ts +++ b/types/ol/format/TopoJSON.d.ts @@ -1,3 +1,39 @@ -import * as ol from 'openlayers'; - -export default ol.format.TopoJSON; +import { Coordinate } from 'ol/coordinate'; +import Feature from 'ol/Feature'; +import { ReadOptions } from 'ol/format/Feature'; +import JSONFeature from 'ol/format/JSONFeature'; +import LineString from 'ol/geom/LineString'; +import MultiLineString from 'ol/geom/MultiLineString'; +import MultiPoint from 'ol/geom/MultiPoint'; +import MultiPolygon from 'ol/geom/MultiPolygon'; +import Point from 'ol/geom/Point'; +import Polygon from 'ol/geom/Polygon'; +import { ProjectionLike } from 'ol/proj'; +import { + GeometryObject, + GeometryCollection, + LineString as LineString_1, + MultiLineString as MultiLineString_1, + MultiPoint as MultiPoint_1, + MultiPolygon as MultiPolygon_1, + Point as Point_1, + Polygon as Polygon_1, + Topology +} from 'topojson-specification'; +export interface Options { + dataProjection?: ProjectionLike; + layerName?: string; + layers?: string[]; +} +export default class TopoJSON extends JSONFeature { + constructor(opt_options?: Options); +} +export type TopoJSONGeometry = GeometryObject; +export type TopoJSONGeometryCollection = GeometryCollection; +export type TopoJSONLineString = LineString_1; +export type TopoJSONMultiLineString = MultiLineString_1; +export type TopoJSONMultiPoint = MultiPoint_1; +export type TopoJSONMultiPolygon = MultiPolygon_1; +export type TopoJSONPoint = Point_1; +export type TopoJSONPolygon = Polygon_1; +export type TopoJSONTopology = Topology; diff --git a/types/ol/format/WFS.d.ts b/types/ol/format/WFS.d.ts index b2ee31971a..34601ca5ab 100644 --- a/types/ol/format/WFS.d.ts +++ b/types/ol/format/WFS.d.ts @@ -1,3 +1,74 @@ -import * as ol from 'openlayers'; - -export default ol.format.WFS; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import Bbox from 'ol/format/filter/Bbox'; +import ComparisonBinary from 'ol/format/filter/ComparisonBinary'; +import Contains from 'ol/format/filter/Contains'; +import During from 'ol/format/filter/During'; +import Filter from 'ol/format/filter/Filter'; +import Intersects from 'ol/format/filter/Intersects'; +import IsBetween from 'ol/format/filter/IsBetween'; +import IsLike from 'ol/format/filter/IsLike'; +import IsNull from 'ol/format/filter/IsNull'; +import LogicalNary from 'ol/format/filter/LogicalNary'; +import Not from 'ol/format/filter/Not'; +import Within from 'ol/format/filter/Within'; +import GMLBase, { Options as Options_1 } from 'ol/format/GMLBase'; +import XMLFeature from 'ol/format/XMLFeature'; +export function writeFilter(filter: Filter): Node; +export interface FeatureCollectionMetadata { + numberOfFeatures: number; + bounds: Extent; +} +export interface Options { + featureNS?: { [key: string]: string } | string; + featureType?: string[] | string; + gmlFormat?: GMLBase; + schemaLocation?: string; +} +export interface TransactionResponse { + totalDeleted: number; + totalInserted: number; + totalUpdated: number; + insertIds: string[]; +} +export default class WFS extends XMLFeature { + constructor(opt_options?: Options); + getFeatureType(): string[] | string; + readFeatureCollectionMetadata(source: Document | Element | { [key: string]: any } | string): FeatureCollectionMetadata; + readFeatureCollectionMetadataFromDocument(doc: Document): FeatureCollectionMetadata; + readFeatureCollectionMetadataFromNode(node: Element): FeatureCollectionMetadata; + readTransactionResponse(source: Document | Element | { [key: string]: any } | string): TransactionResponse; + readTransactionResponseFromDocument(doc: Document): TransactionResponse; + readTransactionResponseFromNode(node: Element): TransactionResponse; + setFeatureType(featureType: string[] | string): void; + writeGetFeature(options: WriteGetFeatureOptions): Node; + writeTransaction(inserts: Feature[], updates: Feature[], deletes: Feature[], options: WriteTransactionOptions): Node; +} +export interface WriteGetFeatureOptions { + featureNS: string; + featurePrefix: string; + featureTypes: string[]; + srsName?: string; + handle?: string; + outputFormat?: string; + maxFeatures?: number; + geometryName?: string; + propertyNames?: string[]; + viewParams?: string; + startIndex?: number; + count?: number; + bbox?: Extent; + filter?: Filter; + resultType?: string; +} +export interface WriteTransactionOptions { + featureNS: string; + featurePrefix: string; + featureType: string; + srsName?: string; + handle?: string; + hasZ?: boolean; + nativeElements: { [key: string]: any }[]; + gmlOptions?: Options_1; + version?: string; +} diff --git a/types/ol/format/WKT.d.ts b/types/ol/format/WKT.d.ts index 68bfbee10f..f93fea7831 100644 --- a/types/ol/format/WKT.d.ts +++ b/types/ol/format/WKT.d.ts @@ -1,3 +1,22 @@ -import * as ol from 'openlayers'; - -export default ol.format.WKT; +import TextFeature from 'ol/format/TextFeature'; +import Geometry from 'ol/geom/Geometry'; +import GeometryCollection from 'ol/geom/GeometryCollection'; +import LinearRing from 'ol/geom/LinearRing'; +import LineString from 'ol/geom/LineString'; +import MultiLineString from 'ol/geom/MultiLineString'; +import MultiPoint from 'ol/geom/MultiPoint'; +import MultiPolygon from 'ol/geom/MultiPolygon'; +import Point from 'ol/geom/Point'; +import Polygon from 'ol/geom/Polygon'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +export interface Options { + splitCollection?: boolean; +} +export interface Token { + type: number; + value?: number | string; + position: number; +} +export default class WKT extends TextFeature { + constructor(opt_options?: Options); +} diff --git a/types/ol/format/WMSCapabilities.d.ts b/types/ol/format/WMSCapabilities.d.ts index c727c689c6..83948169a1 100644 --- a/types/ol/format/WMSCapabilities.d.ts +++ b/types/ol/format/WMSCapabilities.d.ts @@ -1,3 +1,5 @@ -import * as ol from 'openlayers'; - -export default ol.format.WMSCapabilities; +import { Extent } from 'ol/extent'; +import XML from 'ol/format/XML'; +export default class WMSCapabilities extends XML { + constructor(); +} diff --git a/types/ol/format/WMSGetFeatureInfo.d.ts b/types/ol/format/WMSGetFeatureInfo.d.ts index 6aaffa7b5e..2e150e614a 100644 --- a/types/ol/format/WMSGetFeatureInfo.d.ts +++ b/types/ol/format/WMSGetFeatureInfo.d.ts @@ -1,3 +1,9 @@ -import * as ol from 'openlayers'; - -export default ol.format.WMSGetFeatureInfo; +import XMLFeature from 'ol/format/XMLFeature'; +export interface Options { + layers?: string[]; +} +export default class WMSGetFeatureInfo extends XMLFeature { + constructor(opt_options?: Options); + getLayers(): string[]; + setLayers(layers: string[]): void; +} diff --git a/types/ol/format/WMTSCapabilities.d.ts b/types/ol/format/WMTSCapabilities.d.ts index c17cdf8f2d..de2a639836 100644 --- a/types/ol/format/WMTSCapabilities.d.ts +++ b/types/ol/format/WMTSCapabilities.d.ts @@ -1,3 +1,4 @@ -import * as ol from 'openlayers'; - -export default ol.format.WMTSCapabilities; +import XML from 'ol/format/XML'; +export default class WMTSCapabilities extends XML { + constructor(); +} diff --git a/types/ol/format/XLink.d.ts b/types/ol/format/XLink.d.ts new file mode 100644 index 0000000000..3e7315f4df --- /dev/null +++ b/types/ol/format/XLink.d.ts @@ -0,0 +1 @@ +export function readHref(node: Element): string; diff --git a/types/ol/format/XML.d.ts b/types/ol/format/XML.d.ts index 4032d4758e..e3dac6a344 100644 --- a/types/ol/format/XML.d.ts +++ b/types/ol/format/XML.d.ts @@ -1,3 +1,6 @@ -import * as ol from 'openlayers'; - -export default ol.format.XML; +export default class XML { + constructor(); + read(source: Document | Element | string): { [key: string]: any }; + readFromDocument(doc: Document): { [key: string]: any }; + readFromNode(node: Element): { [key: string]: any }; +} diff --git a/types/ol/format/XMLFeature.d.ts b/types/ol/format/XMLFeature.d.ts index 28b544565b..9aa06364e7 100644 --- a/types/ol/format/XMLFeature.d.ts +++ b/types/ol/format/XMLFeature.d.ts @@ -1,3 +1,24 @@ -import * as ol from 'openlayers'; - -export default ol.format.XMLFeature; +import Feature, { FeatureLike } from 'ol/Feature'; +import FeatureFormat, { ReadOptions, WriteOptions } from 'ol/format/Feature'; +import Geometry from 'ol/geom/Geometry'; +import Projection from 'ol/proj/Projection'; +export default class XMLFeature extends FeatureFormat { + constructor(); + protected readGeometryFromNode(node: Node, opt_options?: ReadOptions): Geometry; + protected readFeaturesFromDocument(doc: Document, opt_options?: ReadOptions): Feature[]; + protected readFeaturesFromNode(node: Node, opt_options?: ReadOptions): Feature[]; + protected readGeometryFromDocument(doc: Document, opt_options?: ReadOptions): Geometry; + protected readProjectionFromDocument(doc: Document): Projection; + protected readProjectionFromNode(node: Node): Projection; + protected writeFeatureNode(feature: Feature, opt_options?: WriteOptions): Node; + readFeatureFromDocument(doc: Document, opt_options?: ReadOptions): Feature; + readProjection(source: Document | Node | { [key: string]: any } | string): Projection; + readFeature(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Feature; + readFeature(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): FeatureLike; + readFeatureFromNode(node: Node, opt_options?: ReadOptions): Feature; + readFeatures(source: Document | Node | { [key: string]: any } | string, opt_options?: ReadOptions): Feature[]; + readFeatures(source: Document | Node | ArrayBuffer | { [key: string]: any } | string, opt_options?: ReadOptions): FeatureLike[]; + writeFeatures(features: Feature[], opt_options?: WriteOptions): string; + writeFeaturesNode(features: Feature[], opt_options?: WriteOptions): Node; + writeGeometryNode(geometry: Geometry, opt_options?: WriteOptions): Node; +} diff --git a/types/ol/format/filter.d.ts b/types/ol/format/filter.d.ts deleted file mode 100644 index 1fb2086477..0000000000 --- a/types/ol/format/filter.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.format.filter; diff --git a/types/ol/format/filter/And.d.ts b/types/ol/format/filter/And.d.ts new file mode 100644 index 0000000000..ffd1051e12 --- /dev/null +++ b/types/ol/format/filter/And.d.ts @@ -0,0 +1,5 @@ +import Filter from 'ol/format/filter/Filter'; +import LogicalNary from 'ol/format/filter/LogicalNary'; +export default class And extends LogicalNary { + constructor(...conditions: Filter[]); +} diff --git a/types/ol/format/filter/Bbox.d.ts b/types/ol/format/filter/Bbox.d.ts new file mode 100644 index 0000000000..d2472ecd63 --- /dev/null +++ b/types/ol/format/filter/Bbox.d.ts @@ -0,0 +1,5 @@ +import { Extent } from 'ol/extent'; +import Filter from 'ol/format/filter/Filter'; +export default class Bbox extends Filter { + constructor(geometryName: string, extent: Extent, opt_srsName?: string); +} diff --git a/types/ol/format/filter/Comparison.d.ts b/types/ol/format/filter/Comparison.d.ts new file mode 100644 index 0000000000..025bb17dcc --- /dev/null +++ b/types/ol/format/filter/Comparison.d.ts @@ -0,0 +1,4 @@ +import Filter from 'ol/format/filter/Filter'; +export default class Comparison extends Filter { + constructor(tagName: string, propertyName: string); +} diff --git a/types/ol/format/filter/ComparisonBinary.d.ts b/types/ol/format/filter/ComparisonBinary.d.ts new file mode 100644 index 0000000000..b6c1713920 --- /dev/null +++ b/types/ol/format/filter/ComparisonBinary.d.ts @@ -0,0 +1,4 @@ +import Comparison from 'ol/format/filter/Comparison'; +export default class ComparisonBinary extends Comparison { + constructor(tagName: string, propertyName: string, expression: string | number, opt_matchCase?: boolean); +} diff --git a/types/ol/format/filter/Contains.d.ts b/types/ol/format/filter/Contains.d.ts new file mode 100644 index 0000000000..8b486f6820 --- /dev/null +++ b/types/ol/format/filter/Contains.d.ts @@ -0,0 +1,5 @@ +import Spatial from 'ol/format/filter/Spatial'; +import Geometry from 'ol/geom/Geometry'; +export default class Contains extends Spatial { + constructor(geometryName: string, geometry: Geometry, opt_srsName?: string); +} diff --git a/types/ol/format/filter/During.d.ts b/types/ol/format/filter/During.d.ts new file mode 100644 index 0000000000..3cd6a8d697 --- /dev/null +++ b/types/ol/format/filter/During.d.ts @@ -0,0 +1,4 @@ +import Comparison from 'ol/format/filter/Comparison'; +export default class During extends Comparison { + constructor(propertyName: string, begin: string, end: string); +} diff --git a/types/ol/format/filter/EqualTo.d.ts b/types/ol/format/filter/EqualTo.d.ts new file mode 100644 index 0000000000..bceaf270c7 --- /dev/null +++ b/types/ol/format/filter/EqualTo.d.ts @@ -0,0 +1,4 @@ +import ComparisonBinary from 'ol/format/filter/ComparisonBinary'; +export default class EqualTo extends ComparisonBinary { + constructor(propertyName: string, expression: string | number, opt_matchCase?: boolean); +} diff --git a/types/ol/format/filter/Filter.d.ts b/types/ol/format/filter/Filter.d.ts new file mode 100644 index 0000000000..b53af587e9 --- /dev/null +++ b/types/ol/format/filter/Filter.d.ts @@ -0,0 +1,4 @@ +export default class Filter { + constructor(tagName: string); + getTagName(): string; +} diff --git a/types/ol/format/filter/GreaterThan.d.ts b/types/ol/format/filter/GreaterThan.d.ts new file mode 100644 index 0000000000..d0e3b1e93e --- /dev/null +++ b/types/ol/format/filter/GreaterThan.d.ts @@ -0,0 +1,4 @@ +import ComparisonBinary from 'ol/format/filter/ComparisonBinary'; +export default class GreaterThan extends ComparisonBinary { + constructor(propertyName: string, expression: number); +} diff --git a/types/ol/format/filter/GreaterThanOrEqualTo.d.ts b/types/ol/format/filter/GreaterThanOrEqualTo.d.ts new file mode 100644 index 0000000000..b75e033f56 --- /dev/null +++ b/types/ol/format/filter/GreaterThanOrEqualTo.d.ts @@ -0,0 +1,4 @@ +import ComparisonBinary from 'ol/format/filter/ComparisonBinary'; +export default class GreaterThanOrEqualTo extends ComparisonBinary { + constructor(propertyName: string, expression: number); +} diff --git a/types/ol/format/filter/Intersects.d.ts b/types/ol/format/filter/Intersects.d.ts new file mode 100644 index 0000000000..fced056225 --- /dev/null +++ b/types/ol/format/filter/Intersects.d.ts @@ -0,0 +1,5 @@ +import Spatial from 'ol/format/filter/Spatial'; +import Geometry from 'ol/geom/Geometry'; +export default class Intersects extends Spatial { + constructor(geometryName: string, geometry: Geometry, opt_srsName?: string); +} diff --git a/types/ol/format/filter/IsBetween.d.ts b/types/ol/format/filter/IsBetween.d.ts new file mode 100644 index 0000000000..daec6910dd --- /dev/null +++ b/types/ol/format/filter/IsBetween.d.ts @@ -0,0 +1,4 @@ +import Comparison from 'ol/format/filter/Comparison'; +export default class IsBetween extends Comparison { + constructor(propertyName: string, lowerBoundary: number, upperBoundary: number); +} diff --git a/types/ol/format/filter/IsLike.d.ts b/types/ol/format/filter/IsLike.d.ts new file mode 100644 index 0000000000..77d1a6d551 --- /dev/null +++ b/types/ol/format/filter/IsLike.d.ts @@ -0,0 +1,4 @@ +import Comparison from 'ol/format/filter/Comparison'; +export default class IsLike extends Comparison { + constructor(propertyName: string, pattern: string, opt_wildCard?: string, opt_singleChar?: string, opt_escapeChar?: string, opt_matchCase?: boolean); +} diff --git a/types/ol/format/filter/IsNull.d.ts b/types/ol/format/filter/IsNull.d.ts new file mode 100644 index 0000000000..4fb2f22d8e --- /dev/null +++ b/types/ol/format/filter/IsNull.d.ts @@ -0,0 +1,4 @@ +import Comparison from 'ol/format/filter/Comparison'; +export default class IsNull extends Comparison { + constructor(propertyName: string); +} diff --git a/types/ol/format/filter/LessThan.d.ts b/types/ol/format/filter/LessThan.d.ts new file mode 100644 index 0000000000..dec0c662ff --- /dev/null +++ b/types/ol/format/filter/LessThan.d.ts @@ -0,0 +1,4 @@ +import ComparisonBinary from 'ol/format/filter/ComparisonBinary'; +export default class LessThan extends ComparisonBinary { + constructor(propertyName: string, expression: number); +} diff --git a/types/ol/format/filter/LessThanOrEqualTo.d.ts b/types/ol/format/filter/LessThanOrEqualTo.d.ts new file mode 100644 index 0000000000..c35311a4ee --- /dev/null +++ b/types/ol/format/filter/LessThanOrEqualTo.d.ts @@ -0,0 +1,4 @@ +import ComparisonBinary from 'ol/format/filter/ComparisonBinary'; +export default class LessThanOrEqualTo extends ComparisonBinary { + constructor(propertyName: string, expression: number); +} diff --git a/types/ol/format/filter/LogicalNary.d.ts b/types/ol/format/filter/LogicalNary.d.ts new file mode 100644 index 0000000000..ff1aaa1430 --- /dev/null +++ b/types/ol/format/filter/LogicalNary.d.ts @@ -0,0 +1,4 @@ +import Filter from 'ol/format/filter/Filter'; +export default class LogicalNary extends Filter { + constructor(tagName: string, conditions: Filter[]); +} diff --git a/types/ol/format/filter/Not.d.ts b/types/ol/format/filter/Not.d.ts new file mode 100644 index 0000000000..61ecad249f --- /dev/null +++ b/types/ol/format/filter/Not.d.ts @@ -0,0 +1,4 @@ +import Filter from 'ol/format/filter/Filter'; +export default class Not extends Filter { + constructor(condition: Filter); +} diff --git a/types/ol/format/filter/NotEqualTo.d.ts b/types/ol/format/filter/NotEqualTo.d.ts new file mode 100644 index 0000000000..35116c0232 --- /dev/null +++ b/types/ol/format/filter/NotEqualTo.d.ts @@ -0,0 +1,4 @@ +import ComparisonBinary from 'ol/format/filter/ComparisonBinary'; +export default class NotEqualTo extends ComparisonBinary { + constructor(propertyName: string, expression: string | number, opt_matchCase?: boolean); +} diff --git a/types/ol/format/filter/Or.d.ts b/types/ol/format/filter/Or.d.ts new file mode 100644 index 0000000000..9f177b5828 --- /dev/null +++ b/types/ol/format/filter/Or.d.ts @@ -0,0 +1,5 @@ +import Filter from 'ol/format/filter/Filter'; +import LogicalNary from 'ol/format/filter/LogicalNary'; +export default class Or extends LogicalNary { + constructor(...conditions: Filter[]); +} diff --git a/types/ol/format/filter/Spatial.d.ts b/types/ol/format/filter/Spatial.d.ts new file mode 100644 index 0000000000..4b56079b6e --- /dev/null +++ b/types/ol/format/filter/Spatial.d.ts @@ -0,0 +1,5 @@ +import Filter from 'ol/format/filter/Filter'; +import Geometry from 'ol/geom/Geometry'; +export default class Spatial extends Filter { + constructor(tagName: string, geometryName: string, geometry: Geometry, opt_srsName?: string); +} diff --git a/types/ol/format/filter/Within.d.ts b/types/ol/format/filter/Within.d.ts new file mode 100644 index 0000000000..9d593e531c --- /dev/null +++ b/types/ol/format/filter/Within.d.ts @@ -0,0 +1,5 @@ +import Spatial from 'ol/format/filter/Spatial'; +import Geometry from 'ol/geom/Geometry'; +export default class Within extends Spatial { + constructor(geometryName: string, geometry: Geometry, opt_srsName?: string); +} diff --git a/types/ol/format/filter/index.d.ts b/types/ol/format/filter/index.d.ts new file mode 100644 index 0000000000..aff4359e48 --- /dev/null +++ b/types/ol/format/filter/index.d.ts @@ -0,0 +1,37 @@ +import { Extent } from 'ol/extent'; +import And from 'ol/format/filter/And'; +import Bbox from 'ol/format/filter/Bbox'; +import Contains from 'ol/format/filter/Contains'; +import During from 'ol/format/filter/During'; +import EqualTo from 'ol/format/filter/EqualTo'; +import Filter from 'ol/format/filter/Filter'; +import GreaterThan from 'ol/format/filter/GreaterThan'; +import GreaterThanOrEqualTo from 'ol/format/filter/GreaterThanOrEqualTo'; +import Intersects from 'ol/format/filter/Intersects'; +import IsBetween from 'ol/format/filter/IsBetween'; +import IsLike from 'ol/format/filter/IsLike'; +import IsNull from 'ol/format/filter/IsNull'; +import LessThan from 'ol/format/filter/LessThan'; +import LessThanOrEqualTo from 'ol/format/filter/LessThanOrEqualTo'; +import Not from 'ol/format/filter/Not'; +import NotEqualTo from 'ol/format/filter/NotEqualTo'; +import Or from 'ol/format/filter/Or'; +import Within from 'ol/format/filter/Within'; +import Geometry from 'ol/geom/Geometry'; +export function and(...conditions: Filter[]): And; +export function bbox(geometryName: string, extent: Extent, opt_srsName?: string): Bbox; +export function between(propertyName: string, lowerBoundary: number, upperBoundary: number): IsBetween; +export function contains(geometryName: string, geometry: Geometry, opt_srsName?: string): Contains; +export function during(propertyName: string, begin: string, end: string): During; +export function equalTo(propertyName: string, expression: string | number, opt_matchCase?: boolean): EqualTo; +export function greaterThan(propertyName: string, expression: number): GreaterThan; +export function greaterThanOrEqualTo(propertyName: string, expression: number): GreaterThanOrEqualTo; +export function intersects(geometryName: string, geometry: Geometry, opt_srsName?: string): Intersects; +export function isNull(propertyName: string): IsNull; +export function lessThan(propertyName: string, expression: number): LessThan; +export function lessThanOrEqualTo(propertyName: string, expression: number): LessThanOrEqualTo; +export function like(propertyName: string, pattern: string, opt_wildCard?: string, opt_singleChar?: string, opt_escapeChar?: string, opt_matchCase?: boolean): IsLike; +export function not(condition: Filter): Not; +export function notEqualTo(propertyName: string, expression: string | number, opt_matchCase?: boolean): NotEqualTo; +export function or(...conditions: Filter[]): Or; +export function within(geometryName: string, geometry: Geometry, opt_srsName?: string): Within; diff --git a/types/ol/format/index.d.ts b/types/ol/format/index.d.ts new file mode 100644 index 0000000000..9a23306c8f --- /dev/null +++ b/types/ol/format/index.d.ts @@ -0,0 +1,15 @@ +export { default as EsriJSON } from 'ol/format/EsriJSON'; +export { default as GeoJSON } from 'ol/format/GeoJSON'; +export { default as GML } from 'ol/format/GML'; +export { default as GPX } from 'ol/format/GPX'; +export { default as IGC } from 'ol/format/IGC'; +export { default as KML } from 'ol/format/KML'; +export { default as MVT } from 'ol/format/MVT'; +export { default as OWS } from 'ol/format/OWS'; +export { default as Polyline } from 'ol/format/Polyline'; +export { default as TopoJSON } from 'ol/format/TopoJSON'; +export { default as WFS } from 'ol/format/WFS'; +export { default as WKT } from 'ol/format/WKT'; +export { default as WMSCapabilities } from 'ol/format/WMSCapabilities'; +export { default as WMSGetFeatureInfo } from 'ol/format/WMSGetFeatureInfo'; +export { default as WMTSCapabilities } from 'ol/format/WMTSCapabilities'; diff --git a/types/ol/format/xsd.d.ts b/types/ol/format/xsd.d.ts new file mode 100644 index 0000000000..fac46f5052 --- /dev/null +++ b/types/ol/format/xsd.d.ts @@ -0,0 +1,14 @@ +export function readBoolean(node: Node): boolean; +export function readBooleanString(string: string): boolean; +export function readDateTime(node: Node): number; +export function readDecimal(node: Node): number; +export function readDecimalString(string: string): number; +export function readNonNegativeInteger(node: Node): number; +export function readNonNegativeIntegerString(string: string): number; +export function readString(node: Node): string; +export function writeBooleanTextNode(node: Node, bool: boolean): void; +export function writeCDATASection(node: Node, string: string): void; +export function writeDateTimeTextNode(node: Node, dateTime: number): void; +export function writeDecimalTextNode(node: Node, decimal: number): void; +export function writeNonNegativeIntegerTextNode(node: Node, nonNegativeInteger: number): void; +export function writeStringTextNode(node: Node, string: string): void; diff --git a/types/ol/functions.d.ts b/types/ol/functions.d.ts new file mode 100644 index 0000000000..e409a55fb3 --- /dev/null +++ b/types/ol/functions.d.ts @@ -0,0 +1,3 @@ +export function FALSE(): boolean; +export function TRUE(): boolean; +export function VOID(): void; diff --git a/types/ol/geom/Circle.d.ts b/types/ol/geom/Circle.d.ts index 48abeeed8e..e31780db2a 100644 --- a/types/ol/geom/Circle.d.ts +++ b/types/ol/geom/Circle.d.ts @@ -1,3 +1,27 @@ -import * as ol from 'openlayers'; - -export default ol.geom.Circle; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Geometry from 'ol/geom/Geometry'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +export default class Circle extends SimpleGeometry { + constructor(center: Coordinate, opt_radius?: number, opt_layout?: GeometryLayout); + getCenter(): Coordinate; + getRadius(): number; + setCenter(center: Coordinate): void; + setCenterAndRadius(center: Coordinate, radius: number, opt_layout?: GeometryLayout): void; + setRadius(radius: number): void; + transform(source: ProjectionLike, destination: ProjectionLike): Circle; + transform(source: ProjectionLike, destination: ProjectionLike): Geometry; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/Geometry.d.ts b/types/ol/geom/Geometry.d.ts index 59f0ba50d9..553cb2be1e 100644 --- a/types/ol/geom/Geometry.d.ts +++ b/types/ol/geom/Geometry.d.ts @@ -1,3 +1,38 @@ -import * as ol from 'openlayers'; - -export default ol.geom.Geometry; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import GeometryType from 'ol/geom/GeometryType'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import { TransformFunction, ProjectionLike } from 'ol/proj'; +export default class Geometry extends BaseObject { + constructor(); + protected simplifiedGeometryCache: { [key: string]: Geometry }; + protected simplifiedGeometryMaxMinSquaredTolerance: number; + protected simplifiedGeometryRevision: number; + protected computeExtent(extent: Extent): Extent; + intersectsCoordinate(coordinate: Coordinate): boolean; + getClosestPoint(point: Coordinate, opt_closestPoint?: Coordinate): Coordinate; + getExtent(opt_extent?: Extent): Extent; + getSimplifiedGeometry(squaredTolerance: number): Geometry; + getType(): GeometryType; + clone(): Geometry; + intersectsExtent(extent: Extent): boolean; + rotate(angle: number, anchor: Coordinate): void; + scale(sx: number, opt_sy?: number, opt_anchor?: Coordinate): void; + closestPointXY(x: number, y: number, closestPoint: Coordinate, minSquaredDistance: number): number; + applyTransform(transformFn: TransformFunction): void; + containsXY(x: number, y: number): boolean; + simplify(tolerance: number): Geometry; + transform(source: ProjectionLike, destination: ProjectionLike): Geometry; + translate(deltaX: number, deltaY: number): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/GeometryCollection.d.ts b/types/ol/geom/GeometryCollection.d.ts index d8aaddefbf..cb227c977e 100644 --- a/types/ol/geom/GeometryCollection.d.ts +++ b/types/ol/geom/GeometryCollection.d.ts @@ -1,3 +1,21 @@ -import * as ol from 'openlayers'; - -export default ol.geom.GeometryCollection; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Geometry from 'ol/geom/Geometry'; +import { ObjectEvent } from 'ol/Object'; +export default class GeometryCollection extends Geometry { + constructor(opt_geometries?: Geometry[]); + getGeometries(): Geometry[]; + getGeometriesArray(): Geometry[]; + isEmpty(): boolean; + setGeometries(geometries: Geometry[]): void; + setGeometriesArray(geometries: Geometry[]): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/GeometryLayout.d.ts b/types/ol/geom/GeometryLayout.d.ts new file mode 100644 index 0000000000..80ed5bf2a5 --- /dev/null +++ b/types/ol/geom/GeometryLayout.d.ts @@ -0,0 +1,8 @@ +declare enum GeometryLayout { + XY = 'XY', + XYZ = 'XYZ', + XYM = 'XYM', + XYZM = 'XYZM', +} + +export default GeometryLayout; diff --git a/types/ol/geom/GeometryType.d.ts b/types/ol/geom/GeometryType.d.ts new file mode 100644 index 0000000000..e2599a3a83 --- /dev/null +++ b/types/ol/geom/GeometryType.d.ts @@ -0,0 +1,13 @@ +declare enum GeometryType { + POINT = 'Point', + LINE_STRING = 'LineString', + LINEAR_RING = 'LinearRing', + POLYGON = 'Polygon', + MULTI_POINT = 'MultiPoint', + MULTI_LINE_STRING = 'MultiLineString', + MULTI_POLYGON = 'MultiPolygon', + GEOMETRY_COLLECTION = 'GeometryCollection', + CIRCLE = 'Circle', +} + +export default GeometryType; diff --git a/types/ol/geom/LineString.d.ts b/types/ol/geom/LineString.d.ts index 8f58f85ff4..b2ae10b019 100644 --- a/types/ol/geom/LineString.d.ts +++ b/types/ol/geom/LineString.d.ts @@ -1,3 +1,24 @@ -import * as ol from 'openlayers'; - -export default ol.geom.LineString; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { ObjectEvent } from 'ol/Object'; +export default class LineString extends SimpleGeometry { + constructor(coordinates: Coordinate[] | number[], opt_layout?: GeometryLayout); + appendCoordinate(coordinate: Coordinate): void; + forEachSegment(callback: ((this: S, param1: Coordinate, param2: Coordinate) => T)): T | boolean; + getCoordinateAt(fraction: number, opt_dest?: Coordinate): Coordinate; + getCoordinateAtM(m: number, opt_extrapolate?: boolean): Coordinate; + getFlatMidpoint(): number[]; + getLength(): number; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/LinearRing.d.ts b/types/ol/geom/LinearRing.d.ts index 4341aa8780..7479e063eb 100644 --- a/types/ol/geom/LinearRing.d.ts +++ b/types/ol/geom/LinearRing.d.ts @@ -1,3 +1,19 @@ -import * as ol from 'openlayers'; - -export default ol.geom.LinearRing; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { ObjectEvent } from 'ol/Object'; +export default class LinearRing extends SimpleGeometry { + constructor(coordinates: Coordinate[] | number[], opt_layout?: GeometryLayout); + getArea(): number; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/MultiLineString.d.ts b/types/ol/geom/MultiLineString.d.ts new file mode 100644 index 0000000000..539fd7d000 --- /dev/null +++ b/types/ol/geom/MultiLineString.d.ts @@ -0,0 +1,25 @@ +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import LineString from 'ol/geom/LineString'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { ObjectEvent } from 'ol/Object'; +export default class MultiLineString extends SimpleGeometry { + constructor(coordinates: any[] | number[], opt_layout?: GeometryLayout, opt_ends?: number[]); + appendLineString(lineString: LineString): void; + getCoordinateAtM(m: number, opt_extrapolate?: boolean, opt_interpolate?: boolean): Coordinate; + getEnds(): number[]; + getFlatMidpoints(): number[]; + getLineString(index: number): LineString; + getLineStrings(): LineString[]; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/MultiPoint.d.ts b/types/ol/geom/MultiPoint.d.ts index 1846edddb5..40971d0468 100644 --- a/types/ol/geom/MultiPoint.d.ts +++ b/types/ol/geom/MultiPoint.d.ts @@ -1,3 +1,22 @@ -import * as ol from 'openlayers'; - -export default ol.geom.MultiPoint; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import Point from 'ol/geom/Point'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { ObjectEvent } from 'ol/Object'; +export default class MultiPoint extends SimpleGeometry { + constructor(coordinates: Coordinate[] | number[], opt_layout?: GeometryLayout); + appendPoint(point: Point): void; + getPoint(index: number): Point; + getPoints(): Point[]; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/MultiPolygon.d.ts b/types/ol/geom/MultiPolygon.d.ts index 9a058fac0f..426578c566 100644 --- a/types/ol/geom/MultiPolygon.d.ts +++ b/types/ol/geom/MultiPolygon.d.ts @@ -1,3 +1,27 @@ -import * as ol from 'openlayers'; - -export default ol.geom.MultiPolygon; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import MultiPoint from 'ol/geom/MultiPoint'; +import Polygon from 'ol/geom/Polygon'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { ObjectEvent } from 'ol/Object'; +export default class MultiPolygon extends SimpleGeometry { + constructor(coordinates: any[] | number[], opt_layout?: GeometryLayout, opt_endss?: number[][]); + appendPolygon(polygon: Polygon): void; + getArea(): number; + getEndss(): number[][]; + getFlatInteriorPoints(): number[]; + getInteriorPoints(): MultiPoint; + getOrientedFlatCoordinates(): number[]; + getPolygon(index: number): Polygon; + getPolygons(): Polygon[]; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/MultilineString.d.ts b/types/ol/geom/MultilineString.d.ts deleted file mode 100644 index b9c3de266e..0000000000 --- a/types/ol/geom/MultilineString.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.geom.MultiLineString; diff --git a/types/ol/geom/Point.d.ts b/types/ol/geom/Point.d.ts index 0c8bf8e7d8..9481434270 100644 --- a/types/ol/geom/Point.d.ts +++ b/types/ol/geom/Point.d.ts @@ -1,3 +1,18 @@ -import * as ol from 'openlayers'; - -export default ol.geom.Point; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { ObjectEvent } from 'ol/Object'; +export default class Point extends SimpleGeometry { + constructor(coordinates: Coordinate, opt_layout?: GeometryLayout); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/Polygon.d.ts b/types/ol/geom/Polygon.d.ts index 67351267ed..7f573fedd5 100644 --- a/types/ol/geom/Polygon.d.ts +++ b/types/ol/geom/Polygon.d.ts @@ -1,3 +1,35 @@ -import * as ol from 'openlayers'; - -export default ol.geom.Polygon; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Circle from 'ol/geom/Circle'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import LinearRing from 'ol/geom/LinearRing'; +import Point from 'ol/geom/Point'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { ObjectEvent } from 'ol/Object'; +export function circular(center: Coordinate, radius: number, opt_n?: number, opt_sphereRadius?: number): Polygon; +export function fromCircle(circle: Circle, opt_sides?: number, opt_angle?: number): Polygon; +export function fromExtent(extent: Extent): Polygon; +export function makeRegular(polygon: Polygon, center: Coordinate, radius: number, opt_angle?: number): void; +export default class Polygon extends SimpleGeometry { + constructor(coordinates: Coordinate[][] | number[], opt_layout?: GeometryLayout, opt_ends?: number[]); + appendLinearRing(linearRing: LinearRing): void; + getArea(): number; + getEnds(): number[]; + getFlatInteriorPoint(): number[]; + getInteriorPoint(): Point; + getLinearRing(index: number): LinearRing; + getLinearRingCount(): number; + getLinearRings(): LinearRing[]; + getOrientedFlatCoordinates(): number[]; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/SimpleGeometry.d.ts b/types/ol/geom/SimpleGeometry.d.ts index 20695d2bb1..d1c1395e61 100644 --- a/types/ol/geom/SimpleGeometry.d.ts +++ b/types/ol/geom/SimpleGeometry.d.ts @@ -1,3 +1,34 @@ -import * as ol from 'openlayers'; - -export default ol.geom.SimpleGeometry; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Geometry from 'ol/geom/Geometry'; +import GeometryLayout from 'ol/geom/GeometryLayout'; +import { ObjectEvent } from 'ol/Object'; +import { Transform } from 'ol/transform'; +export function getStrideForLayout(layout: GeometryLayout): number; +export function transformGeom2D(simpleGeometry: SimpleGeometry, transform: Transform, opt_dest?: number[]): number[]; +export default class SimpleGeometry extends Geometry { + constructor(); + protected flatCoordinates: number[]; + protected stride: number; + protected layout: GeometryLayout; + protected setLayout(layout: GeometryLayout, coordinates: any[], nesting: number): void; + protected getSimplifiedGeometryInternal(squaredTolerance: number): SimpleGeometry; + getFlatCoordinates(): number[]; + getLastCoordinate(): Coordinate; + getLayout(): GeometryLayout; + getCoordinates(): any[]; + getStride(): number; + getFirstCoordinate(): Coordinate; + setCoordinates(coordinates: any[], opt_layout?: GeometryLayout): void; + setFlatCoordinates(layout: GeometryLayout, flatCoordinates: number[]): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/geom/flat/area.d.ts b/types/ol/geom/flat/area.d.ts new file mode 100644 index 0000000000..dac45e9c5b --- /dev/null +++ b/types/ol/geom/flat/area.d.ts @@ -0,0 +1,3 @@ +export function linearRing(flatCoordinates: number[], offset: number, end: number, stride: number): number; +export function linearRings(flatCoordinates: number[], offset: number, ends: number[], stride: number): number; +export function linearRingss(flatCoordinates: number[], offset: number, endss: number[][], stride: number): number; diff --git a/types/ol/geom/flat/center.d.ts b/types/ol/geom/flat/center.d.ts new file mode 100644 index 0000000000..b1dc731029 --- /dev/null +++ b/types/ol/geom/flat/center.d.ts @@ -0,0 +1 @@ +export function linearRingss(flatCoordinates: number[], offset: number, endss: number[][], stride: number): number[]; diff --git a/types/ol/geom/flat/closest.d.ts b/types/ol/geom/flat/closest.d.ts new file mode 100644 index 0000000000..e4d021e5a6 --- /dev/null +++ b/types/ol/geom/flat/closest.d.ts @@ -0,0 +1,6 @@ +export function arrayMaxSquaredDelta(flatCoordinates: number[], offset: number, ends: number[], stride: number, max: number): number; +export function assignClosestArrayPoint(flatCoordinates: number[], offset: number, ends: number[], stride: number, maxDelta: number, isRing: boolean, x: number, y: number, closestPoint: number[], minSquaredDistance: number, opt_tmpPoint?: number[]): number; +export function assignClosestMultiArrayPoint(flatCoordinates: number[], offset: number, endss: number[][], stride: number, maxDelta: number, isRing: boolean, x: number, y: number, closestPoint: number[], minSquaredDistance: number, opt_tmpPoint?: number[]): number; +export function assignClosestPoint(flatCoordinates: number[], offset: number, end: number, stride: number, maxDelta: number, isRing: boolean, x: number, y: number, closestPoint: number[], minSquaredDistance: number, opt_tmpPoint?: number[]): number; +export function maxSquaredDelta(flatCoordinates: number[], offset: number, end: number, stride: number, max: number): number; +export function multiArrayMaxSquaredDelta(flatCoordinates: number[], offset: number, endss: number[][], stride: number, max: number): number; diff --git a/types/ol/geom/flat/contains.d.ts b/types/ol/geom/flat/contains.d.ts new file mode 100644 index 0000000000..64cdec8867 --- /dev/null +++ b/types/ol/geom/flat/contains.d.ts @@ -0,0 +1,5 @@ +import { Extent } from 'ol/extent'; +export function linearRingContainsExtent(flatCoordinates: number[], offset: number, end: number, stride: number, extent: Extent): boolean; +export function linearRingContainsXY(flatCoordinates: number[], offset: number, end: number, stride: number, x: number, y: number): boolean; +export function linearRingsContainsXY(flatCoordinates: number[], offset: number, ends: number[], stride: number, x: number, y: number): boolean; +export function linearRingssContainsXY(flatCoordinates: number[], offset: number, endss: number[][], stride: number, x: number, y: number): boolean; diff --git a/types/ol/geom/flat/deflate.d.ts b/types/ol/geom/flat/deflate.d.ts new file mode 100644 index 0000000000..6630816e83 --- /dev/null +++ b/types/ol/geom/flat/deflate.d.ts @@ -0,0 +1,5 @@ +import { Coordinate } from 'ol/coordinate'; +export function deflateCoordinate(flatCoordinates: number[], offset: number, coordinate: Coordinate, stride: number): number; +export function deflateCoordinates(flatCoordinates: number[], offset: number, coordinates: Coordinate[], stride: number): number; +export function deflateCoordinatesArray(flatCoordinates: number[], offset: number, coordinatess: Coordinate[][], stride: number, opt_ends?: number[]): number[]; +export function deflateMultiCoordinatesArray(flatCoordinates: number[], offset: number, coordinatesss: Coordinate[][][], stride: number, opt_endss?: number[][]): number[][]; diff --git a/types/ol/geom/flat/flip.d.ts b/types/ol/geom/flat/flip.d.ts new file mode 100644 index 0000000000..20291a9082 --- /dev/null +++ b/types/ol/geom/flat/flip.d.ts @@ -0,0 +1 @@ +export function flipXY(flatCoordinates: number[], offset: number, end: number, stride: number, opt_dest?: number[], opt_destOffset?: number): number[]; diff --git a/types/ol/geom/flat/geodesic.d.ts b/types/ol/geom/flat/geodesic.d.ts new file mode 100644 index 0000000000..fe56d95f58 --- /dev/null +++ b/types/ol/geom/flat/geodesic.d.ts @@ -0,0 +1,6 @@ +import { Coordinate } from 'ol/coordinate'; +import { TransformFunction } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +export function greatCircleArc(lon1: number, lat1: number, lon2: number, lat2: number, projection: Projection, squaredTolerance: number): number[]; +export function meridian(lon: number, lat1: number, lat2: number, projection: Projection, squaredTolerance: number): number[]; +export function parallel(lat: number, lon1: number, lon2: number, projection: Projection, squaredTolerance: number): number[]; diff --git a/types/ol/geom/flat/inflate.d.ts b/types/ol/geom/flat/inflate.d.ts new file mode 100644 index 0000000000..872eb42860 --- /dev/null +++ b/types/ol/geom/flat/inflate.d.ts @@ -0,0 +1,4 @@ +import { Coordinate } from 'ol/coordinate'; +export function inflateCoordinates(flatCoordinates: number[], offset: number, end: number, stride: number, opt_coordinates?: Coordinate[]): Coordinate[]; +export function inflateCoordinatesArray(flatCoordinates: number[], offset: number, ends: number[], stride: number, opt_coordinatess?: Coordinate[][]): Coordinate[][]; +export function inflateMultiCoordinatesArray(flatCoordinates: number[], offset: number, endss: number[][], stride: number, opt_coordinatesss?: Coordinate[][][]): Coordinate[][][]; diff --git a/types/ol/geom/flat/interiorpoint.d.ts b/types/ol/geom/flat/interiorpoint.d.ts new file mode 100644 index 0000000000..df48c64b46 --- /dev/null +++ b/types/ol/geom/flat/interiorpoint.d.ts @@ -0,0 +1,2 @@ +export function getInteriorPointOfArray(flatCoordinates: number[], offset: number, ends: number[], stride: number, flatCenters: number[], flatCentersOffset: number, opt_dest?: number[]): number[]; +export function getInteriorPointsOfMultiArray(flatCoordinates: number[], offset: number, endss: number[][], stride: number, flatCenters: number[]): number[]; diff --git a/types/ol/geom/flat/interpolate.d.ts b/types/ol/geom/flat/interpolate.d.ts new file mode 100644 index 0000000000..9e5d5996cf --- /dev/null +++ b/types/ol/geom/flat/interpolate.d.ts @@ -0,0 +1,4 @@ +import { Coordinate } from 'ol/coordinate'; +export function interpolatePoint(flatCoordinates: number[], offset: number, end: number, stride: number, fraction: number, opt_dest?: number[]): number[]; +export function lineStringCoordinateAtM(flatCoordinates: number[], offset: number, end: number, stride: number, m: number, extrapolate: boolean): Coordinate; +export function lineStringsCoordinateAtM(flatCoordinates: number[], offset: number, ends: number[], stride: number, m: number, extrapolate: boolean, interpolate: boolean): Coordinate; diff --git a/types/ol/geom/flat/intersectsextent.d.ts b/types/ol/geom/flat/intersectsextent.d.ts new file mode 100644 index 0000000000..5f4fe4d983 --- /dev/null +++ b/types/ol/geom/flat/intersectsextent.d.ts @@ -0,0 +1,6 @@ +import { Extent } from 'ol/extent'; +export function intersectsLinearRing(flatCoordinates: number[], offset: number, end: number, stride: number, extent: Extent): boolean; +export function intersectsLinearRingArray(flatCoordinates: number[], offset: number, ends: number[], stride: number, extent: Extent): boolean; +export function intersectsLinearRingMultiArray(flatCoordinates: number[], offset: number, endss: number[][], stride: number, extent: Extent): boolean; +export function intersectsLineString(flatCoordinates: number[], offset: number, end: number, stride: number, extent: Extent): boolean; +export function intersectsLineStringArray(flatCoordinates: number[], offset: number, ends: number[], stride: number, extent: Extent): boolean; diff --git a/types/ol/geom/flat/length.d.ts b/types/ol/geom/flat/length.d.ts new file mode 100644 index 0000000000..59ea637da1 --- /dev/null +++ b/types/ol/geom/flat/length.d.ts @@ -0,0 +1,2 @@ +export function linearRingLength(flatCoordinates: number[], offset: number, end: number, stride: number): number; +export function lineStringLength(flatCoordinates: number[], offset: number, end: number, stride: number): number; diff --git a/types/ol/geom/flat/orient.d.ts b/types/ol/geom/flat/orient.d.ts new file mode 100644 index 0000000000..507f979469 --- /dev/null +++ b/types/ol/geom/flat/orient.d.ts @@ -0,0 +1,5 @@ +export function linearRingIsClockwise(flatCoordinates: number[], offset: number, end: number, stride: number): boolean; +export function linearRingIsOriented(flatCoordinates: number[], offset: number, ends: number[], stride: number, opt_right?: boolean): boolean; +export function linearRingsAreOriented(flatCoordinates: number[], offset: number, endss: number[][], stride: number, opt_right?: boolean): boolean; +export function orientLinearRings(flatCoordinates: number[], offset: number, ends: number[], stride: number, opt_right?: boolean): number; +export function orientLinearRingsArray(flatCoordinates: number[], offset: number, endss: number[][], stride: number, opt_right?: boolean): number; diff --git a/types/ol/geom/flat/reverse.d.ts b/types/ol/geom/flat/reverse.d.ts new file mode 100644 index 0000000000..a4a3d7f0e3 --- /dev/null +++ b/types/ol/geom/flat/reverse.d.ts @@ -0,0 +1 @@ +export function coordinates(flatCoordinates: number[], offset: number, end: number, stride: number): void; diff --git a/types/ol/geom/flat/segments.d.ts b/types/ol/geom/flat/segments.d.ts new file mode 100644 index 0000000000..d12d3a5c61 --- /dev/null +++ b/types/ol/geom/flat/segments.d.ts @@ -0,0 +1,2 @@ +import { Coordinate } from 'ol/coordinate'; +export function forEach(flatCoordinates: number[], offset: number, end: number, stride: number, callback: ((this: S, param1: Coordinate, param2: Coordinate) => T), opt_this?: S): T | boolean; diff --git a/types/ol/geom/flat/simplify.d.ts b/types/ol/geom/flat/simplify.d.ts new file mode 100644 index 0000000000..88ed94d79e --- /dev/null +++ b/types/ol/geom/flat/simplify.d.ts @@ -0,0 +1,9 @@ +export function douglasPeucker(flatCoordinates: number[], offset: number, end: number, stride: number, squaredTolerance: number, simplifiedFlatCoordinates: number[], simplifiedOffset: number): number; +export function douglasPeuckerArray(flatCoordinates: number[], offset: number, ends: number[], stride: number, squaredTolerance: number, simplifiedFlatCoordinates: number[], simplifiedOffset: number, simplifiedEnds: number[]): number; +export function douglasPeuckerMultiArray(flatCoordinates: number[], offset: number, endss: number[][], stride: number, squaredTolerance: number, simplifiedFlatCoordinates: number[], simplifiedOffset: number, simplifiedEndss: number[][]): number; +export function quantize(flatCoordinates: number[], offset: number, end: number, stride: number, tolerance: number, simplifiedFlatCoordinates: number[], simplifiedOffset: number): number; +export function quantizeArray(flatCoordinates: number[], offset: number, ends: number[], stride: number, tolerance: number, simplifiedFlatCoordinates: number[], simplifiedOffset: number, simplifiedEnds: number[]): number; +export function quantizeMultiArray(flatCoordinates: number[], offset: number, endss: number[][], stride: number, tolerance: number, simplifiedFlatCoordinates: number[], simplifiedOffset: number, simplifiedEndss: number[][]): number; +export function radialDistance(flatCoordinates: number[], offset: number, end: number, stride: number, squaredTolerance: number, simplifiedFlatCoordinates: number[], simplifiedOffset: number): number; +export function simplifyLineString(flatCoordinates: number[], offset: number, end: number, stride: number, squaredTolerance: number, highQuality: boolean, opt_simplifiedFlatCoordinates?: number[]): number[]; +export function snap(value: number, tolerance: number): number; diff --git a/types/ol/geom/flat/straightchunk.d.ts b/types/ol/geom/flat/straightchunk.d.ts new file mode 100644 index 0000000000..839000347c --- /dev/null +++ b/types/ol/geom/flat/straightchunk.d.ts @@ -0,0 +1 @@ +export function matchingChunk(maxAngle: number, flatCoordinates: number[], offset: number, end: number, stride: number): number[]; diff --git a/types/ol/geom/flat/textpath.d.ts b/types/ol/geom/flat/textpath.d.ts new file mode 100644 index 0000000000..b975981d46 --- /dev/null +++ b/types/ol/geom/flat/textpath.d.ts @@ -0,0 +1 @@ +export function drawTextOnPath(flatCoordinates: number[], offset: number, end: number, stride: number, text: string, measure: ((param0: string) => number), startM: number, maxAngle: number): any[][]; diff --git a/types/ol/geom/flat/topology.d.ts b/types/ol/geom/flat/topology.d.ts new file mode 100644 index 0000000000..f73f23d557 --- /dev/null +++ b/types/ol/geom/flat/topology.d.ts @@ -0,0 +1 @@ +export function lineStringIsClosed(flatCoordinates: number[], offset: number, end: number, stride: number): boolean; diff --git a/types/ol/geom/flat/transform.d.ts b/types/ol/geom/flat/transform.d.ts new file mode 100644 index 0000000000..745a031731 --- /dev/null +++ b/types/ol/geom/flat/transform.d.ts @@ -0,0 +1,5 @@ +import { Transform } from 'ol/transform'; +export function rotate(flatCoordinates: number[], offset: number, end: number, stride: number, angle: number, anchor: number[], opt_dest?: number[]): number[]; +export function scale(flatCoordinates: number[], offset: number, end: number, stride: number, sx: number, sy: number, anchor: number[], opt_dest?: number[]): number[]; +export function transform2D(flatCoordinates: number[], offset: number, end: number, stride: number, transform: Transform, opt_dest?: number[]): number[]; +export function translate(flatCoordinates: number[], offset: number, end: number, stride: number, deltaX: number, deltaY: number, opt_dest?: number[]): number[]; diff --git a/types/ol/geom/index.d.ts b/types/ol/geom/index.d.ts new file mode 100644 index 0000000000..05d84ec579 --- /dev/null +++ b/types/ol/geom/index.d.ts @@ -0,0 +1,8 @@ +export { default as Circle } from 'ol/geom/Circle'; +export { default as Geometry } from 'ol/geom/Geometry'; +export { default as LineString } from 'ol/geom/LineString'; +export { default as MultiLineString } from 'ol/geom/MultiLineString'; +export { default as MultiPoint } from 'ol/geom/MultiPoint'; +export { default as MultiPolygon } from 'ol/geom/MultiPolygon'; +export { default as Point } from 'ol/geom/Point'; +export { default as Polygon } from 'ol/geom/Polygon'; diff --git a/types/ol/has.d.ts b/types/ol/has.d.ts new file mode 100644 index 0000000000..da480b861a --- /dev/null +++ b/types/ol/has.d.ts @@ -0,0 +1,4 @@ +export { HAS as WEBGL } from 'ol/webgl'; +export const DEVICE_PIXEL_RATIO: number; +export const GEOLOCATION: boolean; +export const TOUCH: boolean; diff --git a/types/ol/index.d.ts b/types/ol/index.d.ts index dfdf2aa3e3..6a9ab03e6a 100644 --- a/types/ol/index.d.ts +++ b/types/ol/index.d.ts @@ -1,7 +1,37 @@ -// Type definitions for ol 4.6 -// Project: https://github.com/openlayers/openlayers/tree/master/package#readme, https://openlayers.org -// Definitions by: Yair Tawil +// Type definitions for ol 5.3 +// Project: https://github.com/openlayers/openlayers, https://openlayers.org +// Definitions by: Rifa'i M. Hanif // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped -import * as ol from 'openlayers'; +// TypeScript Version: 2.4 -export default ol; +export { default as AssertionError } from 'ol/AssertionError'; +export { default as Collection } from 'ol/Collection'; +export { default as Disposable } from 'ol/Disposable'; +export { default as Feature } from 'ol/Feature'; +export { default as Geolocation } from 'ol/Geolocation'; +export { default as Graticule } from 'ol/Graticule'; +export { default as Image } from 'ol/Image'; +export { default as ImageBase } from 'ol/ImageBase'; +export { default as ImageCanvas } from 'ol/ImageCanvas'; +export { default as ImageTile } from 'ol/ImageTile'; +export { default as Kinetic } from 'ol/Kinetic'; +export { default as Map } from 'ol/Map'; +export { default as MapBrowserEvent } from 'ol/MapBrowserEvent'; +export { default as MapBrowserEventHandler } from 'ol/MapBrowserEventHandler'; +export { default as MapBrowserPointerEvent } from 'ol/MapBrowserPointerEvent'; +export { default as MapEvent } from 'ol/MapEvent'; +export { default as Object } from 'ol/Object'; +export { default as Observable } from 'ol/Observable'; +export { default as Overlay } from 'ol/Overlay'; +export { default as PluggableMap } from 'ol/PluggableMap'; +export { default as Tile } from 'ol/Tile'; +export { default as TileCache } from 'ol/TileCache'; +export { default as TileQueue } from 'ol/TileQueue'; +export { default as TileRange } from 'ol/TileRange'; +export { default as VectorImageTile } from 'ol/VectorImageTile'; +export { default as VectorTile } from 'ol/VectorTile'; +export { default as View } from 'ol/View'; +export { default as WebGLMap } from 'ol/WebGLMap'; +export { VERSION } from 'ol/util'; +export function getUid(obj: { [key: string]: any }): string; +export function inherits(childCtor: (() => void), parentCtor: (() => void)): void; diff --git a/types/ol/interaction/DoubleClickZoom.d.ts b/types/ol/interaction/DoubleClickZoom.d.ts index 3982ba3b7f..882c537519 100644 --- a/types/ol/interaction/DoubleClickZoom.d.ts +++ b/types/ol/interaction/DoubleClickZoom.d.ts @@ -1,3 +1,24 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.DoubleClickZoom; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Interaction from 'ol/interaction/Interaction'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import { ObjectEvent } from 'ol/Object'; +export default class DoubleClickZoom extends Interaction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + duration?: number; + delta?: number; +} diff --git a/types/ol/interaction/DragAndDrop.d.ts b/types/ol/interaction/DragAndDrop.d.ts index bbfbbeb727..a51a788538 100644 --- a/types/ol/interaction/DragAndDrop.d.ts +++ b/types/ol/interaction/DragAndDrop.d.ts @@ -1,3 +1,42 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.DragAndDrop; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Feature, { FeatureLike } from 'ol/Feature'; +import FeatureFormat from 'ol/format/Feature'; +import Interaction from 'ol/interaction/Interaction'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import VectorSource from 'ol/source/Vector'; +export default class DragAndDrop extends Interaction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'addfeatures', listener: (evt: DragAndDropEvent) => void): EventsKey; + once(type: 'addfeatures', listener: (evt: DragAndDropEvent) => void): EventsKey; + un(type: 'addfeatures', listener: (evt: DragAndDropEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export class DragAndDropEvent extends Event { + constructor(type: DragAndDropEventType, file: File, opt_features?: Feature[], opt_projection?: Projection); + features: FeatureLike[]; + file: File; + projection: Projection; +} +export enum DragAndDropEventType { + ADD_FEATURES = 'addfeatures', +} +export interface Options { + formatConstructors?: FeatureFormat[]; + source?: VectorSource; + projection?: ProjectionLike; + target?: HTMLElement; +} diff --git a/types/ol/interaction/DragBox.d.ts b/types/ol/interaction/DragBox.d.ts index dbb06b7a18..aadef1ba44 100644 --- a/types/ol/interaction/DragBox.d.ts +++ b/types/ol/interaction/DragBox.d.ts @@ -1,3 +1,53 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.DragBox; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import Polygon from 'ol/geom/Polygon'; +import PointerInteraction from 'ol/interaction/Pointer'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import { ObjectEvent } from 'ol/Object'; +import { Pixel } from 'ol/pixel'; +export default class DragBox extends PointerInteraction { + constructor(opt_options?: Options); + defaultBoxEndCondition(mapBrowserEvent: MapBrowserEvent, startPixel: Pixel, endPixel: Pixel): boolean; + getGeometry(): Polygon; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'boxdrag', listener: (evt: DragBoxEvent) => void): EventsKey; + once(type: 'boxdrag', listener: (evt: DragBoxEvent) => void): EventsKey; + un(type: 'boxdrag', listener: (evt: DragBoxEvent) => void): void; + on(type: 'boxend', listener: (evt: DragBoxEvent) => void): EventsKey; + once(type: 'boxend', listener: (evt: DragBoxEvent) => void): EventsKey; + un(type: 'boxend', listener: (evt: DragBoxEvent) => void): void; + on(type: 'boxstart', listener: (evt: DragBoxEvent) => void): EventsKey; + once(type: 'boxstart', listener: (evt: DragBoxEvent) => void): EventsKey; + un(type: 'boxstart', listener: (evt: DragBoxEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export class DragBoxEvent extends Event { + constructor(type: string, coordinate: Coordinate, mapBrowserEvent: MapBrowserEvent); + coordinate: Coordinate; + mapBrowserEvent: MapBrowserEvent; +} +export enum DragBoxEventType { + BOXSTART = 'boxstart', + BOXDRAG = 'boxdrag', + BOXEND = 'boxend', +} +export type EndCondition = ((this: any, param1: MapBrowserEvent, param2: Pixel, param3: Pixel) => boolean); +export interface Options { + className?: string; + condition?: Condition; + minArea?: number; + boxEndCondition?: EndCondition; + onBoxEnd: ((this: DragBox, param1: MapBrowserEvent) => void); +} diff --git a/types/ol/interaction/DragPan.d.ts b/types/ol/interaction/DragPan.d.ts index e9c14d7b5d..91a51151c1 100644 --- a/types/ol/interaction/DragPan.d.ts +++ b/types/ol/interaction/DragPan.d.ts @@ -1,3 +1,25 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.DragPan; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import PointerInteraction from 'ol/interaction/Pointer'; +import Kinetic from 'ol/Kinetic'; +import { ObjectEvent } from 'ol/Object'; +export default class DragPan extends PointerInteraction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + condition?: Condition; + kinetic?: Kinetic; +} diff --git a/types/ol/interaction/DragRotate.d.ts b/types/ol/interaction/DragRotate.d.ts index 31ebec3772..59ad39e599 100644 --- a/types/ol/interaction/DragRotate.d.ts +++ b/types/ol/interaction/DragRotate.d.ts @@ -1,3 +1,24 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.DragRotate; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import PointerInteraction from 'ol/interaction/Pointer'; +import { ObjectEvent } from 'ol/Object'; +export default class DragRotate extends PointerInteraction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + condition?: Condition; + duration?: number; +} diff --git a/types/ol/interaction/DragRotateAndZoom.d.ts b/types/ol/interaction/DragRotateAndZoom.d.ts index 6b8a2979e1..cbcf4a2cdb 100644 --- a/types/ol/interaction/DragRotateAndZoom.d.ts +++ b/types/ol/interaction/DragRotateAndZoom.d.ts @@ -1,3 +1,24 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.DragRotateAndZoom; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import PointerInteraction from 'ol/interaction/Pointer'; +import { ObjectEvent } from 'ol/Object'; +export default class DragRotateAndZoom extends PointerInteraction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + condition?: Condition; + duration?: number; +} diff --git a/types/ol/interaction/DragZoom.d.ts b/types/ol/interaction/DragZoom.d.ts index c0e0413b21..f3ff658ca1 100644 --- a/types/ol/interaction/DragZoom.d.ts +++ b/types/ol/interaction/DragZoom.d.ts @@ -1,3 +1,35 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.DragZoom; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import DragBox, { DragBoxEvent } from 'ol/interaction/DragBox'; +import { ObjectEvent } from 'ol/Object'; +export default class DragZoom extends DragBox { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'boxdrag', listener: (evt: DragBoxEvent) => void): EventsKey; + once(type: 'boxdrag', listener: (evt: DragBoxEvent) => void): EventsKey; + un(type: 'boxdrag', listener: (evt: DragBoxEvent) => void): void; + on(type: 'boxend', listener: (evt: DragBoxEvent) => void): EventsKey; + once(type: 'boxend', listener: (evt: DragBoxEvent) => void): EventsKey; + un(type: 'boxend', listener: (evt: DragBoxEvent) => void): void; + on(type: 'boxstart', listener: (evt: DragBoxEvent) => void): EventsKey; + once(type: 'boxstart', listener: (evt: DragBoxEvent) => void): EventsKey; + un(type: 'boxstart', listener: (evt: DragBoxEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + className?: string; + condition?: Condition; + duration?: number; + out?: boolean; +} diff --git a/types/ol/interaction/Draw.d.ts b/types/ol/interaction/Draw.d.ts index d7e1318f69..e5b4338793 100644 --- a/types/ol/interaction/Draw.d.ts +++ b/types/ol/interaction/Draw.d.ts @@ -1,3 +1,72 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.Draw; +import Collection from 'ol/Collection'; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import Feature from 'ol/Feature'; +import GeometryType from 'ol/geom/GeometryType'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import PointerInteraction from 'ol/interaction/Pointer'; +import VectorLayer from 'ol/layer/Vector'; +import { ObjectEvent } from 'ol/Object'; +import VectorSource from 'ol/source/Vector'; +import { StyleFunction, StyleLike } from 'ol/style/Style'; +export function createBox(): GeometryFunction; +export function createRegularPolygon(opt_sides?: number, opt_angle?: number): GeometryFunction; +export default class Draw extends PointerInteraction { + constructor(options: Options); + extend(feature: Feature): void; + finishDrawing(): void; + getOverlay(): VectorLayer; + removeLastPoint(): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'drawend', listener: (evt: DrawEvent) => void): EventsKey; + once(type: 'drawend', listener: (evt: DrawEvent) => void): EventsKey; + un(type: 'drawend', listener: (evt: DrawEvent) => void): void; + on(type: 'drawstart', listener: (evt: DrawEvent) => void): EventsKey; + once(type: 'drawstart', listener: (evt: DrawEvent) => void): EventsKey; + un(type: 'drawstart', listener: (evt: DrawEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export class DrawEvent extends Event { + constructor(type: DrawEventType, feature: Feature); + feature: Feature; +} +export enum DrawEventType { + DRAWSTART = 'drawstart', + DRAWEND = 'drawend', +} +export type GeometryFunction = ((param0: SketchCoordType, param1: SimpleGeometry) => SimpleGeometry); +export type LineCoordType = Coordinate[]; +export interface Options { + type: GeometryType; + clickTolerance?: number; + features?: Collection; + source?: VectorSource; + dragVertexDelay?: number; + snapTolerance?: number; + stopClick?: boolean; + maxPoints?: number; + minPoints?: number; + finishCondition?: Condition; + style?: StyleLike; + geometryFunction?: GeometryFunction; + geometryName?: string; + condition?: Condition; + freehand?: boolean; + freehandCondition?: Condition; + wrapX?: boolean; +} +export type PointCoordType = Coordinate; +export type PolyCoordType = Coordinate[][]; +export type SketchCoordType = PointCoordType | LineCoordType | PolyCoordType; diff --git a/types/ol/interaction/Extent.d.ts b/types/ol/interaction/Extent.d.ts index 43c69756e3..9435cd59f1 100644 --- a/types/ol/interaction/Extent.d.ts +++ b/types/ol/interaction/Extent.d.ts @@ -1,3 +1,31 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.Extent; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import PointerInteraction from 'ol/interaction/Pointer'; +import { ObjectEvent } from 'ol/Object'; +import { StyleFunction, StyleLike } from 'ol/style/Style'; +export default class ExtentInteraction extends PointerInteraction { + constructor(opt_options?: Options); + getExtent(): Extent; + setExtent(extent: Extent): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + extent?: Extent; + boxStyle?: StyleLike; + pixelTolerance?: number; + pointerStyle?: StyleLike; + wrapX?: boolean; +} diff --git a/types/ol/interaction/Interaction.d.ts b/types/ol/interaction/Interaction.d.ts index 9eb1c46525..e30710dbf7 100644 --- a/types/ol/interaction/Interaction.d.ts +++ b/types/ol/interaction/Interaction.d.ts @@ -1,3 +1,36 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.Interaction; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import PluggableMap from 'ol/PluggableMap'; +import View from 'ol/View'; +export function pan(view: View, delta: Coordinate, opt_duration?: number): void; +export function rotate(view: View, rotation: number, opt_anchor?: Coordinate, opt_duration?: number): void; +export function rotateWithoutConstraints(view: View, rotation: number, opt_anchor?: Coordinate, opt_duration?: number): void; +export function zoom(view: View, resolution: number, opt_anchor?: Coordinate, opt_duration?: number, opt_direction?: number): void; +export function zoomByDelta(view: View, delta: number, opt_anchor?: Coordinate, opt_duration?: number): void; +export function zoomWithoutConstraints(view: View, resolution: number, opt_anchor?: Coordinate, opt_duration?: number): void; +export default class Interaction extends BaseObject { + constructor(options: InteractionOptions); + getActive(): boolean; + getMap(): PluggableMap; + handleEvent(mapBrowserEvent: MapBrowserEvent): boolean; + setActive(active: boolean): void; + setMap(map: PluggableMap): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface InteractionOptions { + handleEvent: ((param0: MapBrowserEvent) => boolean); +} diff --git a/types/ol/interaction/KeyboardPan.d.ts b/types/ol/interaction/KeyboardPan.d.ts index 5c32c8dfa3..04730a8b19 100644 --- a/types/ol/interaction/KeyboardPan.d.ts +++ b/types/ol/interaction/KeyboardPan.d.ts @@ -1,3 +1,26 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.KeyboardPan; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import Interaction from 'ol/interaction/Interaction'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import { ObjectEvent } from 'ol/Object'; +export default class KeyboardPan extends Interaction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + condition?: Condition; + duration?: number; + pixelDelta?: number; +} diff --git a/types/ol/interaction/KeyboardZoom.d.ts b/types/ol/interaction/KeyboardZoom.d.ts index e52bf705eb..bb4a40bb3c 100644 --- a/types/ol/interaction/KeyboardZoom.d.ts +++ b/types/ol/interaction/KeyboardZoom.d.ts @@ -1,3 +1,26 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.KeyboardZoom; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import Interaction from 'ol/interaction/Interaction'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import { ObjectEvent } from 'ol/Object'; +export default class KeyboardZoom extends Interaction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + duration?: number; + condition?: Condition; + delta?: number; +} diff --git a/types/ol/interaction/Modify.d.ts b/types/ol/interaction/Modify.d.ts index 8079ab0ba5..d9067ce2c9 100644 --- a/types/ol/interaction/Modify.d.ts +++ b/types/ol/interaction/Modify.d.ts @@ -1,3 +1,60 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.Modify; +import Collection from 'ol/Collection'; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import PointerInteraction from 'ol/interaction/Pointer'; +import VectorLayer from 'ol/layer/Vector'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import { ObjectEvent } from 'ol/Object'; +import VectorSource from 'ol/source/Vector'; +import { StyleFunction, StyleLike } from 'ol/style/Style'; +export class ModifyEvent extends Event { + constructor(); + features: Collection; + mapBrowserEvent: MapBrowserEvent; +} +export default class Modify extends PointerInteraction { + constructor(options: Options); + getOverlay(): VectorLayer; + removePoint(): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'modifyend', listener: (evt: ModifyEvent) => void): EventsKey; + once(type: 'modifyend', listener: (evt: ModifyEvent) => void): EventsKey; + un(type: 'modifyend', listener: (evt: ModifyEvent) => void): void; + on(type: 'modifystart', listener: (evt: ModifyEvent) => void): EventsKey; + once(type: 'modifystart', listener: (evt: ModifyEvent) => void): EventsKey; + un(type: 'modifystart', listener: (evt: ModifyEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + condition?: Condition; + deleteCondition?: Condition; + insertVertexCondition?: Condition; + pixelTolerance?: number; + style?: StyleLike; + source?: VectorSource; + features?: Collection; + wrapX?: boolean; +} +export interface SegmentData { + depth?: number[]; + feature: Feature; + geometry: SimpleGeometry; + index?: number; + segment: Extent[]; + featureSegments?: SegmentData[]; +} diff --git a/types/ol/interaction/MouseWheelZoom.d.ts b/types/ol/interaction/MouseWheelZoom.d.ts index d8a5223153..8e60079c55 100644 --- a/types/ol/interaction/MouseWheelZoom.d.ts +++ b/types/ol/interaction/MouseWheelZoom.d.ts @@ -1,3 +1,32 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.MouseWheelZoom; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import Interaction from 'ol/interaction/Interaction'; +import { ObjectEvent } from 'ol/Object'; +export enum Mode { + TRACKPAD = 'trackpad', + WHEEL = 'wheel', +} +export default class MouseWheelZoom extends Interaction { + constructor(opt_options?: Options); + setMouseAnchor(useAnchor: boolean): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + condition?: Condition; + duration?: number; + timeout?: number; + constrainResolution?: boolean; + useAnchor?: boolean; +} diff --git a/types/ol/interaction/PinchRotate.d.ts b/types/ol/interaction/PinchRotate.d.ts index b10400ce30..ecfc4f35a7 100644 --- a/types/ol/interaction/PinchRotate.d.ts +++ b/types/ol/interaction/PinchRotate.d.ts @@ -1,3 +1,23 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.PinchRotate; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import PointerInteraction from 'ol/interaction/Pointer'; +import { ObjectEvent } from 'ol/Object'; +export interface Options { + duration?: number; + threshold?: number; +} +export default class PinchRotate extends PointerInteraction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/interaction/PinchZoom.d.ts b/types/ol/interaction/PinchZoom.d.ts index 0d666096c2..c8c92b11ff 100644 --- a/types/ol/interaction/PinchZoom.d.ts +++ b/types/ol/interaction/PinchZoom.d.ts @@ -1,3 +1,23 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.PinchZoom; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import PointerInteraction from 'ol/interaction/Pointer'; +import { ObjectEvent } from 'ol/Object'; +export interface Options { + duration?: number; + constrainResolution?: boolean; +} +export default class PinchZoom extends PointerInteraction { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/interaction/Pointer.d.ts b/types/ol/interaction/Pointer.d.ts index 22936f602a..67febbd833 100644 --- a/types/ol/interaction/Pointer.d.ts +++ b/types/ol/interaction/Pointer.d.ts @@ -1,3 +1,39 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.Pointer; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Interaction from 'ol/interaction/Interaction'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import MapBrowserPointerEvent from 'ol/MapBrowserPointerEvent'; +import { ObjectEvent } from 'ol/Object'; +import { Pixel } from 'ol/pixel'; +import PointerEvent from 'ol/pointer/PointerEvent'; +export function centroid(pointerEvents: PointerEvent[]): Pixel; +export interface Options { + handleDownEvent?: ((param0: MapBrowserPointerEvent) => boolean); + handleDragEvent?: ((param0: MapBrowserPointerEvent) => void); + handleEvent?: ((param0: MapBrowserEvent) => boolean); + handleMoveEvent?: ((param0: MapBrowserPointerEvent) => void); + handleUpEvent?: ((param0: MapBrowserPointerEvent) => boolean); + stopDown?: ((param0: boolean) => boolean); +} +export default class PointerInteraction extends Interaction { + constructor(opt_options?: Options); + protected handlingDownUpSequence: boolean; + protected targetPointers: PointerEvent[]; + protected handleDownEvent(mapBrowserEvent: MapBrowserPointerEvent): boolean; + protected handleDragEvent(mapBrowserEvent: MapBrowserPointerEvent): void; + protected handleMoveEvent(mapBrowserEvent: MapBrowserPointerEvent): void; + protected handleUpEvent(mapBrowserEvent: MapBrowserPointerEvent): boolean; + stopDown(handled: boolean): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/interaction/Property.d.ts b/types/ol/interaction/Property.d.ts new file mode 100644 index 0000000000..9f5a0bc031 --- /dev/null +++ b/types/ol/interaction/Property.d.ts @@ -0,0 +1,5 @@ +declare enum Property { + ACTIVE = 'active', +} + +export default Property; diff --git a/types/ol/interaction/Select.d.ts b/types/ol/interaction/Select.d.ts index fe8c16b4b9..d051bf0a33 100644 --- a/types/ol/interaction/Select.d.ts +++ b/types/ol/interaction/Select.d.ts @@ -1,3 +1,57 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.Select; +import Collection from 'ol/Collection'; +import { EventsKey } from 'ol/events'; +import { Condition } from 'ol/events/condition'; +import Event from 'ol/events/Event'; +import Feature, { FeatureLike } from 'ol/Feature'; +import Interaction from 'ol/interaction/Interaction'; +import Layer from 'ol/layer/Layer'; +import VectorLayer from 'ol/layer/Vector'; +import MapBrowserEvent from 'ol/MapBrowserEvent'; +import { ObjectEvent } from 'ol/Object'; +import { StyleFunction, StyleLike } from 'ol/style/Style'; +export type FilterFunction = ((param0: FeatureLike, param1: Layer) => boolean); +export interface Options { + addCondition?: Condition; + condition?: Condition; + layers?: Layer[] | ((param0: Layer) => boolean); + style?: StyleLike; + removeCondition?: Condition; + toggleCondition?: Condition; + multi?: boolean; + features?: Collection; + filter?: FilterFunction; + wrapX?: boolean; + hitTolerance?: number; +} +export default class Select extends Interaction { + constructor(opt_options?: Options); + getFeatures(): Collection; + getHitTolerance(): number; + getLayer(feature: FeatureLike): VectorLayer; + getOverlay(): VectorLayer; + setHitTolerance(hitTolerance: number): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'select', listener: (evt: SelectEvent) => void): EventsKey; + once(type: 'select', listener: (evt: SelectEvent) => void): EventsKey; + un(type: 'select', listener: (evt: SelectEvent) => void): void; +} +export class SelectEvent extends Event { + constructor(type: SelectEventType, selected: Feature[], deselected: Feature[], mapBrowserEvent: MapBrowserEvent); + deselected: Feature[]; + mapBrowserEvent: MapBrowserEvent; + selected: Feature[]; +} +export enum SelectEventType { + SELECT = 'select', +} diff --git a/types/ol/interaction/Snap.d.ts b/types/ol/interaction/Snap.d.ts index 90a7fee1bb..4950233bc7 100644 --- a/types/ol/interaction/Snap.d.ts +++ b/types/ol/interaction/Snap.d.ts @@ -1,3 +1,44 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.Snap; +import Collection, { CollectionEvent } from 'ol/Collection'; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Feature from 'ol/Feature'; +import PointerInteraction from 'ol/interaction/Pointer'; +import { ObjectEvent } from 'ol/Object'; +import { Pixel } from 'ol/pixel'; +import PluggableMap from 'ol/PluggableMap'; +import VectorSource, { VectorSourceEvent } from 'ol/source/Vector'; +export interface Options { + features?: Collection; + edge?: boolean; + vertex?: boolean; + pixelTolerance?: number; + source?: VectorSource; +} +export interface Result { + snapped: boolean; + vertex: Coordinate; + vertexPixel: Pixel; +} +export interface SegmentData { + feature: Feature; + segment: Coordinate[]; +} +export default class Snap extends PointerInteraction { + constructor(opt_options?: Options); + addFeature(feature: Feature, opt_listen?: boolean): void; + removeFeature(feature: Feature, opt_unlisten?: boolean): void; + snapTo(pixel: Pixel, pixelCoordinate: Coordinate, map: PluggableMap): Result; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/interaction/Translate.d.ts b/types/ol/interaction/Translate.d.ts index b035bae021..cfdf426d74 100644 --- a/types/ol/interaction/Translate.d.ts +++ b/types/ol/interaction/Translate.d.ts @@ -1,3 +1,44 @@ -import * as ol from 'openlayers'; - -export default ol.interaction.Translate; +import Collection from 'ol/Collection'; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Feature from 'ol/Feature'; +import PointerInteraction from 'ol/interaction/Pointer'; +import Layer from 'ol/layer/Layer'; +import { ObjectEvent } from 'ol/Object'; +export class TranslateEvent extends Event { + constructor(); + features: Collection; + coordinate: Coordinate; +} +export interface Options { + features?: Collection; + layers?: Layer[] | ((param0: Layer) => boolean); + hitTolerance?: number; +} +export default class Translate extends PointerInteraction { + constructor(opt_options?: Options); + getHitTolerance(): number; + setHitTolerance(hitTolerance: number): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:active', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:active', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'translateend', listener: (evt: TranslateEvent) => void): EventsKey; + once(type: 'translateend', listener: (evt: TranslateEvent) => void): EventsKey; + un(type: 'translateend', listener: (evt: TranslateEvent) => void): void; + on(type: 'translatestart', listener: (evt: TranslateEvent) => void): EventsKey; + once(type: 'translatestart', listener: (evt: TranslateEvent) => void): EventsKey; + un(type: 'translatestart', listener: (evt: TranslateEvent) => void): void; + on(type: 'translating', listener: (evt: TranslateEvent) => void): EventsKey; + once(type: 'translating', listener: (evt: TranslateEvent) => void): EventsKey; + un(type: 'translating', listener: (evt: TranslateEvent) => void): void; +} diff --git a/types/ol/interaction/index.d.ts b/types/ol/interaction/index.d.ts index 6ef5898695..cca93d5948 100644 --- a/types/ol/interaction/index.d.ts +++ b/types/ol/interaction/index.d.ts @@ -1,3 +1,37 @@ -import * as ol from 'openlayers'; - -export default ol.interaction; +import Collection from 'ol/Collection'; +import Interaction from 'ol/interaction/Interaction'; +export { default as DoubleClickZoom } from 'ol/interaction/DoubleClickZoom'; +export { default as DragAndDrop } from 'ol/interaction/DragAndDrop'; +export { default as DragBox } from 'ol/interaction/DragBox'; +export { default as DragPan } from 'ol/interaction/DragPan'; +export { default as DragRotate } from 'ol/interaction/DragRotate'; +export { default as DragRotateAndZoom } from 'ol/interaction/DragRotateAndZoom'; +export { default as DragZoom } from 'ol/interaction/DragZoom'; +export { default as Draw } from 'ol/interaction/Draw'; +export { default as Extent } from 'ol/interaction/Extent'; +export { default as Interaction } from 'ol/interaction/Interaction'; +export { default as KeyboardPan } from 'ol/interaction/KeyboardPan'; +export { default as KeyboardZoom } from 'ol/interaction/KeyboardZoom'; +export { default as Modify } from 'ol/interaction/Modify'; +export { default as MouseWheelZoom } from 'ol/interaction/MouseWheelZoom'; +export { default as PinchRotate } from 'ol/interaction/PinchRotate'; +export { default as PinchZoom } from 'ol/interaction/PinchZoom'; +export { default as Pointer } from 'ol/interaction/Pointer'; +export { default as Select } from 'ol/interaction/Select'; +export { default as Snap } from 'ol/interaction/Snap'; +export { default as Translate } from 'ol/interaction/Translate'; +export function defaults(opt_options?: DefaultsOptions): Collection; +export interface DefaultsOptions { + altShiftDragRotate?: boolean; + onFocusOnly?: boolean; + constrainResolution?: boolean; + doubleClickZoom?: boolean; + keyboard?: boolean; + mouseWheelZoom?: boolean; + shiftDragZoom?: boolean; + dragPan?: boolean; + pinchRotate?: boolean; + pinchZoom?: boolean; + zoomDelta?: number; + zoomDuration?: number; +} diff --git a/types/ol/layer/Base.d.ts b/types/ol/layer/Base.d.ts index 25c11c8edd..5ceb7ed73e 100644 --- a/types/ol/layer/Base.d.ts +++ b/types/ol/layer/Base.d.ts @@ -1,3 +1,62 @@ -import * as ol from 'openlayers'; - -export default ol.layer.Base; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Layer, { State } from 'ol/layer/Layer'; +import LayerType from 'ol/LayerType'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import State_1 from 'ol/source/State'; +export default class BaseLayer extends BaseObject { + constructor(options: Options); + getType(): LayerType; + getExtent(): Extent; + getLayerState(): State; + getLayerStatesArray(opt_states?: State[]): State[]; + getMaxResolution(): number; + getMinResolution(): number; + getOpacity(): number; + getSourceState(): State_1; + getLayersArray(opt_array?: Layer[]): Layer[]; + getVisible(): boolean; + getZIndex(): number; + setExtent(extent: Extent): void; + setMaxResolution(maxResolution: number): void; + setMinResolution(minResolution: number): void; + setOpacity(opacity: number): void; + setVisible(visible: boolean): void; + setZIndex(zindex: number): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:extent', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:opacity', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:visible', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + opacity?: number; + visible?: boolean; + extent?: Extent; + zIndex?: number; + minResolution?: number; + maxResolution?: number; +} diff --git a/types/ol/layer/Group.d.ts b/types/ol/layer/Group.d.ts index b3669bc387..40f4fddd88 100644 --- a/types/ol/layer/Group.d.ts +++ b/types/ol/layer/Group.d.ts @@ -1,3 +1,50 @@ -import * as ol from 'openlayers'; - -export default ol.layer.Group; +import Collection from 'ol/Collection'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import BaseLayer from 'ol/layer/Base'; +import { ObjectEvent } from 'ol/Object'; +export default class LayerGroup extends BaseLayer { + constructor(opt_options?: Options); + getLayers(): Collection; + setLayers(layers: Collection): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:extent', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:layers', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:layers', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:layers', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:opacity', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:visible', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + opacity?: number; + visible?: boolean; + extent?: Extent; + zIndex?: number; + minResolution?: number; + maxResolution?: number; + layers?: BaseLayer[] | Collection; +} diff --git a/types/ol/layer/Heatmap.d.ts b/types/ol/layer/Heatmap.d.ts index 4b4f112642..d3001fa627 100644 --- a/types/ol/layer/Heatmap.d.ts +++ b/types/ol/layer/Heatmap.d.ts @@ -1,3 +1,84 @@ -import * as ol from 'openlayers'; - -export default ol.layer.Heatmap; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import VectorLayer from 'ol/layer/Vector'; +import VectorRenderType from 'ol/layer/VectorRenderType'; +import { ObjectEvent } from 'ol/Object'; +import RenderEvent from 'ol/render/Event'; +import VectorSource from 'ol/source/Vector'; +export default class Heatmap extends VectorLayer { + constructor(opt_options?: Options); + getBlur(): number; + getGradient(): string[]; + getRadius(): number; + setBlur(blur: number): void; + setGradient(colors: string[]): void; + setRadius(radius: number): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:blur', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:blur', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:blur', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:extent', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:gradient', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:gradient', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:gradient', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:opacity', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:radius', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:radius', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:radius', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:source', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:visible', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'render', listener: (evt: RenderEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; +} +export interface Options { + opacity?: number; + visible?: boolean; + extent?: Extent; + zIndex?: number; + minResolution?: number; + maxResolution?: number; + gradient?: string[]; + radius?: number; + blur?: number; + shadow?: number; + weight?: string | ((param0: Feature) => number); + renderMode?: VectorRenderType | string; + source?: VectorSource; +} diff --git a/types/ol/layer/Image.d.ts b/types/ol/layer/Image.d.ts index 34a862498e..c6e6cc4491 100644 --- a/types/ol/layer/Image.d.ts +++ b/types/ol/layer/Image.d.ts @@ -1,3 +1,68 @@ -import * as ol from 'openlayers'; - -export default ol.layer.Image; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Layer from 'ol/layer/Layer'; +import LayerType from 'ol/LayerType'; +import { ObjectEvent } from 'ol/Object'; +import PluggableMap from 'ol/PluggableMap'; +import RenderEvent from 'ol/render/Event'; +import ImageSource from 'ol/source/Image'; +import Source from 'ol/source/Source'; +export default class ImageLayer extends Layer { + constructor(opt_options?: Options); + protected type: LayerType; + getSource(): ImageSource; + getSource(): Source; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:extent', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:opacity', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:source', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:visible', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'render', listener: (evt: RenderEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; +} +export interface Options { + opacity?: number; + visible?: boolean; + extent?: Extent; + zIndex?: number; + minResolution?: number; + maxResolution?: number; + map?: PluggableMap; + source?: ImageSource; +} diff --git a/types/ol/layer/Layer.d.ts b/types/ol/layer/Layer.d.ts index 38c31c927f..f8167e379d 100644 --- a/types/ol/layer/Layer.d.ts +++ b/types/ol/layer/Layer.d.ts @@ -1,3 +1,79 @@ -import * as ol from 'openlayers'; - -export default ol.layer.Layer; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import BaseLayer from 'ol/layer/Base'; +import { ObjectEvent } from 'ol/Object'; +import PluggableMap from 'ol/PluggableMap'; +import RenderEvent from 'ol/render/Event'; +import Source from 'ol/source/Source'; +import State_1 from 'ol/source/State'; +export function visibleAtResolution(layerState: State, resolution: number): boolean; +export default class Layer extends BaseLayer { + constructor(options: Options); + getSource(): Source; + setMap(map: PluggableMap): void; + setSource(source: Source): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'render', listener: (evt: RenderEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; + on(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:source', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:extent', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:opacity', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:visible', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} +export interface Options { + opacity?: number; + visible?: boolean; + extent?: Extent; + zIndex?: number; + minResolution?: number; + maxResolution?: number; + source?: Source; + map?: PluggableMap; +} +export interface State { + layer: BaseLayer; + opacity: number; + sourceState: State_1; + visible: boolean; + managed: boolean; + extent?: Extent; + zIndex: number; + maxResolution: number; + minResolution: number; +} diff --git a/types/ol/layer/Property.d.ts b/types/ol/layer/Property.d.ts new file mode 100644 index 0000000000..6dbd620ad0 --- /dev/null +++ b/types/ol/layer/Property.d.ts @@ -0,0 +1,11 @@ +declare enum Property { + OPACITY = 'opacity', + VISIBLE = 'visible', + EXTENT = 'extent', + Z_INDEX = 'zIndex', + MAX_RESOLUTION = 'maxResolution', + MIN_RESOLUTION = 'minResolution', + SOURCE = 'source', +} + +export default Property; diff --git a/types/ol/layer/Tile.d.ts b/types/ol/layer/Tile.d.ts index bbd95be84d..d2212f4cd2 100644 --- a/types/ol/layer/Tile.d.ts +++ b/types/ol/layer/Tile.d.ts @@ -1,3 +1,80 @@ -import * as ol from 'openlayers'; - -export default ol.layer.Tile; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Layer from 'ol/layer/Layer'; +import LayerType from 'ol/LayerType'; +import { ObjectEvent } from 'ol/Object'; +import PluggableMap from 'ol/PluggableMap'; +import RenderEvent from 'ol/render/Event'; +import Source from 'ol/source/Source'; +import TileSource from 'ol/source/Tile'; +export interface Options { + opacity?: number; + visible?: boolean; + extent?: Extent; + zIndex?: number; + minResolution?: number; + maxResolution?: number; + preload?: number; + source?: TileSource; + map?: PluggableMap; + useInterimTilesOnError?: boolean; +} +export default class TileLayer extends Layer { + constructor(opt_options?: Options); + protected type: LayerType; + getPreload(): number; + getSource(): TileSource; + getSource(): Source; + getUseInterimTilesOnError(): boolean; + setPreload(preload: number): void; + setUseInterimTilesOnError(useInterimTilesOnError: boolean): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:extent', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:opacity', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:preload', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:preload', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:preload', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:source', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:useInterimTilesOnError', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:useInterimTilesOnError', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:useInterimTilesOnError', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:visible', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'render', listener: (evt: RenderEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; +} diff --git a/types/ol/layer/TileProperty.d.ts b/types/ol/layer/TileProperty.d.ts new file mode 100644 index 0000000000..2d70c15cc7 --- /dev/null +++ b/types/ol/layer/TileProperty.d.ts @@ -0,0 +1,6 @@ +declare enum TileProperty { + PRELOAD = 'preload', + USE_INTERIM_TILES_ON_ERROR = 'useInterimTilesOnError', +} + +export default TileProperty; diff --git a/types/ol/layer/Vector.d.ts b/types/ol/layer/Vector.d.ts index f26e2a3bf5..44a16d3f68 100644 --- a/types/ol/layer/Vector.d.ts +++ b/types/ol/layer/Vector.d.ts @@ -1,3 +1,90 @@ -import * as ol from 'openlayers'; - -export default ol.layer.Vector; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import Layer from 'ol/layer/Layer'; +import VectorRenderType from 'ol/layer/VectorRenderType'; +import LayerType from 'ol/LayerType'; +import { ObjectEvent } from 'ol/Object'; +import PluggableMap from 'ol/PluggableMap'; +import { OrderFunction } from 'ol/render'; +import RenderEvent from 'ol/render/Event'; +import Source from 'ol/source/Source'; +import VectorSource from 'ol/source/Vector'; +import Style, { StyleLike, StyleFunction } from 'ol/style/Style'; +export interface Options { + opacity?: number; + visible?: boolean; + extent?: Extent; + zIndex?: number; + minResolution?: number; + maxResolution?: number; + renderOrder?: OrderFunction; + renderBuffer?: number; + renderMode?: VectorRenderType | string; + source?: VectorSource; + map?: PluggableMap; + declutter?: boolean; + style?: StyleLike; + updateWhileAnimating?: boolean; + updateWhileInteracting?: boolean; +} +export default class VectorLayer extends Layer { + constructor(opt_options?: Options); + protected type: LayerType; + getDeclutter(): boolean; + getRenderMode(): VectorRenderType | string; + getRenderOrder(): ((param0: Feature, param1: Feature) => number); + getSource(): VectorSource; + getSource(): Source; + getStyle(): StyleLike; + getRenderBuffer(): number; + getUpdateWhileAnimating(): boolean; + getUpdateWhileInteracting(): boolean; + setDeclutter(declutter: boolean): void; + setRenderOrder(renderOrder: OrderFunction): void; + setStyle(style: Style | Style[] | StyleFunction): void; + getStyleFunction(): StyleFunction; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:extent', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:opacity', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:source', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:visible', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'render', listener: (evt: RenderEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; +} diff --git a/types/ol/layer/VectorRenderType.d.ts b/types/ol/layer/VectorRenderType.d.ts new file mode 100644 index 0000000000..0bc8c15325 --- /dev/null +++ b/types/ol/layer/VectorRenderType.d.ts @@ -0,0 +1,6 @@ +declare enum VectorRenderType { + IMAGE = 'image', + VECTOR = 'vector', +} + +export default VectorRenderType; diff --git a/types/ol/layer/VectorTile.d.ts b/types/ol/layer/VectorTile.d.ts index 27ac70d8c3..655895cd54 100644 --- a/types/ol/layer/VectorTile.d.ts +++ b/types/ol/layer/VectorTile.d.ts @@ -1,3 +1,90 @@ -import * as ol from 'openlayers'; - -export default ol.layer.VectorTile; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import VectorLayer from 'ol/layer/Vector'; +import VectorTileRenderType from 'ol/layer/VectorTileRenderType'; +import LayerType from 'ol/LayerType'; +import { ObjectEvent } from 'ol/Object'; +import PluggableMap from 'ol/PluggableMap'; +import { OrderFunction } from 'ol/render'; +import RenderEvent from 'ol/render/Event'; +import VectorSource from 'ol/source/Vector'; +import VectorTile from 'ol/source/VectorTile'; +import { StyleLike } from 'ol/style/Style'; +export interface Options { + opacity?: number; + visible?: boolean; + extent?: Extent; + zIndex?: number; + minResolution?: number; + maxResolution?: number; + renderOrder?: OrderFunction; + renderBuffer?: number; + renderMode?: VectorTileRenderType | string; + source?: VectorTile; + map?: PluggableMap; + declutter?: boolean; + style?: StyleLike; + updateWhileAnimating?: boolean; + updateWhileInteracting?: boolean; + preload?: number; + useInterimTilesOnError?: boolean; +} +export default class VectorTileLayer extends VectorLayer { + constructor(opt_options?: Options); + protected type: LayerType; + getPreload(): number; + getSource(): VectorTile; + getSource(): VectorSource; + getUseInterimTilesOnError(): boolean; + setPreload(preload: number): void; + setUseInterimTilesOnError(useInterimTilesOnError: boolean): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:extent', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:opacity', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:preload', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:preload', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:preload', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:source', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:useInterimTilesOnError', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:useInterimTilesOnError', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:useInterimTilesOnError', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:visible', listener: (evt: ObjectEvent) => void): void; + on(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void; + on(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'postcompose', listener: (evt: RenderEvent) => void): void; + on(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'precompose', listener: (evt: RenderEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'render', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'render', listener: (evt: RenderEvent) => void): void; + on(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + once(type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey; + un(type: 'rendercomplete', listener: (evt: RenderEvent) => void): void; +} diff --git a/types/ol/layer/VectorTileRenderType.d.ts b/types/ol/layer/VectorTileRenderType.d.ts new file mode 100644 index 0000000000..2e9dc72b57 --- /dev/null +++ b/types/ol/layer/VectorTileRenderType.d.ts @@ -0,0 +1,7 @@ +declare enum VectorTileRenderType { + IMAGE = 'image', + HYBRID = 'hybrid', + VECTOR = 'vector', +} + +export default VectorTileRenderType; diff --git a/types/ol/layer/index.d.ts b/types/ol/layer/index.d.ts new file mode 100644 index 0000000000..7d1a01a35c --- /dev/null +++ b/types/ol/layer/index.d.ts @@ -0,0 +1,7 @@ +export { default as Group } from 'ol/layer/Group'; +export { default as Heatmap } from 'ol/layer/Heatmap'; +export { default as Image } from 'ol/layer/Image'; +export { default as Layer } from 'ol/layer/Layer'; +export { default as Tile } from 'ol/layer/Tile'; +export { default as Vector } from 'ol/layer/Vector'; +export { default as VectorTile } from 'ol/layer/VectorTile'; diff --git a/types/ol/loadingstrategy.d.ts b/types/ol/loadingstrategy.d.ts new file mode 100644 index 0000000000..f5b01c51e2 --- /dev/null +++ b/types/ol/loadingstrategy.d.ts @@ -0,0 +1,5 @@ +import { Extent } from 'ol/extent'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export function all(extent: Extent, resolution: number): Extent[]; +export function bbox(extent: Extent, resolution: number): Extent[]; +export function tile(tileGrid: TileGrid): ((param0: Extent, param1: number) => Extent[]); diff --git a/types/ol/loadingstrategy/index.d.ts b/types/ol/loadingstrategy/index.d.ts deleted file mode 100644 index 9b3d8bff3b..0000000000 --- a/types/ol/loadingstrategy/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.loadingstrategy; diff --git a/types/ol/math.d.ts b/types/ol/math.d.ts new file mode 100644 index 0000000000..271444d506 --- /dev/null +++ b/types/ol/math.d.ts @@ -0,0 +1,9 @@ +export function clamp(value: number, min: number, max: number): number; +export function lerp(a: number, b: number, x: number): number; +export function modulo(a: number, b: number): number; +export function roundUpToPowerOfTwo(x: number): number; +export function solveLinearSystem(mat: number[][]): number[]; +export function squaredDistance(x1: number, y1: number, x2: number, y2: number): number; +export function squaredSegmentDistance(x: number, y: number, x1: number, y1: number, x2: number, y2: number): number; +export function toDegrees(angleInRadians: number): number; +export function toRadians(angleInDegrees: number): number; diff --git a/types/ol/net.d.ts b/types/ol/net.d.ts new file mode 100644 index 0000000000..120df63d68 --- /dev/null +++ b/types/ol/net.d.ts @@ -0,0 +1 @@ +export function jsonp(url: string, callback: (() => void), opt_errback?: (() => void), opt_callbackParam?: string): void; diff --git a/types/ol/obj.d.ts b/types/ol/obj.d.ts new file mode 100644 index 0000000000..2dc251997f --- /dev/null +++ b/types/ol/obj.d.ts @@ -0,0 +1,4 @@ +export function clear(object: { [key: string]: any }): void; +export function getValues(obj: { [key: string]: V }): V[]; +export function getValues(obj: { [key: number]: V }): V[]; +export function isEmpty(object: { [key: string]: any }): boolean; diff --git a/types/ol/ol-tests.ts b/types/ol/ol-tests.ts deleted file mode 100644 index f8117f43ac..0000000000 --- a/types/ol/ol-tests.ts +++ /dev/null @@ -1,171 +0,0 @@ -import AssertionError from 'ol/AssertionError'; -import AtlasManager from 'ol/style/AtlasManager'; -// import Attribution from 'ol/Attribution'; -import Attribution from 'ol/control/Attribution'; -import Base from 'ol/layer/Base'; -import BingMaps from 'ol/source/BingMaps'; -import canvas from 'ol/render/canvas'; -import CartoDB from 'ol/source/CartoDB'; -import Circle from 'ol/geom/Circle'; -// import Circle from 'ol/style/Circle'; -import Cluster from 'ol/source/Cluster'; -import Collection from 'ol/Collection'; -import color from 'ol/color'; -import colorlike from 'ol/colorlike'; -import condition from 'ol/events/condition'; -import control from 'ol/control'; -import Control from 'ol/control/Control'; -// import coordinate from 'ol/coordinate'; -import DeviceOrientation from 'ol/deviceorientation'; -import Disposable from 'ol/Disposable'; -import DoubleClickZoom from 'ol/interaction/DoubleClickZoom'; -import DragAndDrop from 'ol/interaction/DragAndDrop'; -import DragBox from 'ol/interaction/DragBox'; -import DragPan from 'ol/interaction/DragPan'; -import DragRotateAndZoom from 'ol/interaction/DragRotateAndZoom'; -import DragRotate from 'ol/interaction/DragRotate'; -import DragZoom from 'ol/interaction/DragZoom'; -import Draw from 'ol/interaction/Draw'; -import easing from 'ol/easing'; -import EsriJSON from 'ol/format/EsriJSON'; -// import Event from 'ol/events/Event'; -import Event from 'ol/render/Event'; -import events from 'ol/events'; -import EventTarget from 'ol/events/EventTarget'; -import extent from 'ol/extent'; -import Extent from 'ol/interaction/Extent'; -// import Feature from 'ol/Feature'; -import Feature from 'ol/format/Feature'; -// import Feature from 'ol/render/Feature'; -import featureloader from 'ol/featureloader'; -import Fill from 'ol/style/Fill'; -import filter from 'ol/format/filter'; -import FullScreen from 'ol/control/Fullscreen'; -import GeoJSON from 'ol/format/GeoJSON'; -import Geolocation from 'ol/Geolocation'; -import GeometryCollection from 'ol/geom/GeometryCollection'; -import Geometry from 'ol/geom/Geometry'; -import GML2 from 'ol/format/GML2'; -import GML3 from 'ol/format/GML3'; -import GMLBase from 'ol/format/GMLBase'; -import GPX from 'ol/format/GPX'; -import Graticule from 'ol/Graticule'; -import Group from 'ol/layer/Group'; -import Heatmap from 'ol/layer/Heatmap'; -import Icon from 'ol/style/Icon'; -import IGC from 'ol/format/IGC'; -import ImageArcGISRest from 'ol/source/ImageArcGISRest'; -import ImageBase from 'ol/ImageBase'; -import ImageCanvas from 'ol/source/ImageCanvas'; -// import Image from 'ol/Image'; -import Image from 'ol/layer/Image'; -// import Image from 'ol/source/Image'; -// import Image from 'ol/style/Image'; -import ImageMapGuide from 'ol/source/ImageMapGuide'; -import ImageStatic from 'ol/source/ImageStatic'; -import ImageTile from 'ol/ImageTile'; -import ImageVector from 'ol/source/ImageVector'; -import ImageWMS from 'ol/source/ImageWMS'; -import interaction from 'ol/interaction'; -import Interaction from 'ol/interaction/Interaction'; -import JSONFeature from 'ol/format/JSONFeature'; -import KeyboardPan from 'ol/interaction/KeyboardPan'; -import KeyboardZoom from 'ol/interaction/KeyboardZoom'; -import Kinetic from 'ol/Kinetic'; -import KML from 'ol/format/KML'; -import Layer from 'ol/layer/Layer'; -import LinearRing from 'ol/geom/LinearRing'; -import LineString from 'ol/geom/LineString'; -import loadingstrategy from 'ol/loadingstrategy'; -import MapBrowserEvent from 'ol/MapBrowserEvent'; -import MapBrowserPointerEvent from 'ol/MapBrowserPointerEvent'; -import MapEvent from 'ol/MapEvent'; -import Map from 'ol/Map'; -import Modify from 'ol/interaction/Modify'; -import MousePosition from 'ol/control/MousePosition'; -import MouseWheelZoom from 'ol/interaction/MouseWheelZoom'; -import MultiLineString from 'ol/geom/MultilineString'; -import MultiPoint from 'ol/geom/MultiPoint'; -import MultiPolygon from 'ol/geom/MultiPolygon'; -import MVT from 'ol/format/MVT'; -import Object from 'ol/Object'; -import Observable from 'ol/Observable'; -import ol from 'ol'; -import OSM from 'ol/source/OSM'; -import OSMXML from 'ol/format/OSMXML'; -import Overlay from 'ol/Overlay'; -import OverviewMap from 'ol/control/OverviewMap'; -import PinchRotate from 'ol/interaction/PinchRotate'; -import PinchZoom from 'ol/interaction/PinchZoom'; -import PointerEvent from 'ol/pointer/PointerEvent'; -import Pointer from 'ol/interaction/Pointer'; -import Point from 'ol/geom/Point'; -import Polygon from 'ol/geom/Polygon'; -import Polyline from 'ol/format/Polyline'; -import Projection from 'ol/proj/Projection'; -import proj from 'ol/proj'; -import Raster from 'ol/source/Raster'; -import RegularShape from 'ol/style/RegularShape'; -import Rotate from 'ol/control/Rotate'; -import ScaleLine from 'ol/control/ScaleLine'; -import Select from 'ol/interaction/Select'; -import SimpleGeometry from 'ol/geom/SimpleGeometry'; -import Snap from 'ol/interaction/Snap'; -import Source from 'ol/source/Source'; -import Sphere from 'ol/sphere'; -import Stamen from 'ol/source/Stamen'; -import Stroke from 'ol/style/Stroke'; -import Style from 'ol/style/Style'; -import TextFeature from 'ol/format/TextFeature'; -import Text from 'ol/style/Text'; -import TileArcGISRest from 'ol/source/TileArcGISRest'; -import TileDebug from 'ol/source/TileDebug'; -import Tile from 'ol/layer/Tile'; -// import Tile from 'ol/source/Tile'; -// import Tile from 'ol/Tile'; -import tilegrid from 'ol/tilegrid'; -import TileGrid from 'ol/tilegrid/TileGrid'; -import TileImage from 'ol/source/TileImage'; -import TileJSON from 'ol/source/TileJSON'; -import TileUTFGrid from 'ol/source/TileUTFGrid'; -import TileWMS from 'ol/source/TileWMS'; -import TopoJSON from 'ol/format/TopoJSON'; -import Translate from 'ol/interaction/Translate'; -import UrlTile from 'ol/source/UrlTile'; -import VectorContext from 'ol/render/VectorContext'; -import Vector from 'ol/layer/Vector'; -// import Vector from 'ol/source/Vector'; -// import VectorTile from 'ol/layer/VectorTile'; -// import VectorTile from 'ol/source/VectorTile'; -import VectorTile from 'ol/VectorTile'; -import View from 'ol/View'; -import WFS from 'ol/format/WFS'; -import WKT from 'ol/format/WKT'; -import WMSCapabilities from 'ol/format/WMSCapabilities'; -import WMSGetFeatureInfo from 'ol/format/WMSGetFeatureInfo'; -import WMTSCapabilities from 'ol/format/WMTSCapabilities'; -import WMTS from 'ol/source/WMTS'; -// import WMTS from 'ol/tilegrid/WMTS'; -import XMLFeature from 'ol/format/XMLFeature'; -import XML from 'ol/format/XML'; -import XYZ from 'ol/source/XYZ'; -import Zoom from 'ol/control/Zoom'; -import Zoomify from 'ol/source/Zoomify'; -import ZoomSlider from 'ol/control/ZoomSlider'; -import ZoomToExtent from 'ol/control/ZoomToExtent'; - -// Map -const map: ol.Map = new Map({} as any); -declare const mapView: View; -map.setView(mapView); - -// View -let view: View; -declare const coordinate: ol.Coordinate; -declare const size: ol.Size; -declare const position: ol.Pixel; -view = map.getView(); -view.getProjection(); -view.animate({} as any); -view.calculateExtent('size' as any); -view.centerOn(coordinate, size, position); diff --git a/types/ol/pixel.d.ts b/types/ol/pixel.d.ts new file mode 100644 index 0000000000..59149580fc --- /dev/null +++ b/types/ol/pixel.d.ts @@ -0,0 +1 @@ +export type Pixel = number[]; diff --git a/types/ol/pointer/EventSource.d.ts b/types/ol/pointer/EventSource.d.ts new file mode 100644 index 0000000000..90aed3761f --- /dev/null +++ b/types/ol/pointer/EventSource.d.ts @@ -0,0 +1,6 @@ +import PointerEventHandler from 'ol/pointer/PointerEventHandler'; +export default class EventSource { + constructor(dispatcher: PointerEventHandler, mapping: { [key: string]: any }); + getEvents(): string[]; + getHandlerForEvent(eventType: string): ((param0: Event) => void); +} diff --git a/types/ol/pointer/EventType.d.ts b/types/ol/pointer/EventType.d.ts new file mode 100644 index 0000000000..222e70d80c --- /dev/null +++ b/types/ol/pointer/EventType.d.ts @@ -0,0 +1,12 @@ +declare enum EventType { + POINTERMOVE = 'pointermove', + POINTERDOWN = 'pointerdown', + POINTERUP = 'pointerup', + POINTEROVER = 'pointerover', + POINTEROUT = 'pointerout', + POINTERENTER = 'pointerenter', + POINTERLEAVE = 'pointerleave', + POINTERCANCEL = 'pointercancel', +} + +export default EventType; diff --git a/types/ol/pointer/MouseSource.d.ts b/types/ol/pointer/MouseSource.d.ts new file mode 100644 index 0000000000..633d84d63d --- /dev/null +++ b/types/ol/pointer/MouseSource.d.ts @@ -0,0 +1,8 @@ +import EventSource from 'ol/pointer/EventSource'; +import PointerEventHandler from 'ol/pointer/PointerEventHandler'; +export function prepareEvent(inEvent: Event, dispatcher: PointerEventHandler): { [key: string]: any }; +export default class MouseSource extends EventSource { + constructor(dispatcher: PointerEventHandler); + cancel(inEvent: Event): void; + cleanupMouse(): void; +} diff --git a/types/ol/pointer/MsSource.d.ts b/types/ol/pointer/MsSource.d.ts new file mode 100644 index 0000000000..915b871c17 --- /dev/null +++ b/types/ol/pointer/MsSource.d.ts @@ -0,0 +1,6 @@ +import EventSource from 'ol/pointer/EventSource'; +import PointerEventHandler from 'ol/pointer/PointerEventHandler'; +export default class MsSource extends EventSource { + constructor(dispatcher: PointerEventHandler); + cleanup(pointerId: number): void; +} diff --git a/types/ol/pointer/NativeSource.d.ts b/types/ol/pointer/NativeSource.d.ts new file mode 100644 index 0000000000..fc2aa4ba5f --- /dev/null +++ b/types/ol/pointer/NativeSource.d.ts @@ -0,0 +1,5 @@ +import EventSource from 'ol/pointer/EventSource'; +import PointerEventHandler from 'ol/pointer/PointerEventHandler'; +export default class NativeSource extends EventSource { + constructor(dispatcher: PointerEventHandler); +} diff --git a/types/ol/pointer/PointerEvent.d.ts b/types/ol/pointer/PointerEvent.d.ts index 62e84e6207..b5891677c0 100644 --- a/types/ol/pointer/PointerEvent.d.ts +++ b/types/ol/pointer/PointerEvent.d.ts @@ -1,3 +1,4 @@ -import * as ol from 'openlayers'; - -export default ol.pointer.PointerEvent; +import Event from 'ol/events/Event'; +export default class PointerEvent extends Event { + constructor(type: string, originalEvent: Event, opt_eventDict?: { [key: string]: any }); +} diff --git a/types/ol/pointer/PointerEventHandler.d.ts b/types/ol/pointer/PointerEventHandler.d.ts new file mode 100644 index 0000000000..be6b019b06 --- /dev/null +++ b/types/ol/pointer/PointerEventHandler.d.ts @@ -0,0 +1,23 @@ +import Target from 'ol/events/Target'; +import EventSource from 'ol/pointer/EventSource'; +import PointerEvent from 'ol/pointer/PointerEvent'; +export default class PointerEventHandler extends Target { + constructor(element: Element | HTMLDocument); + leaveOut(data: { [key: string]: any }, event: Event): void; + cancel(data: { [key: string]: any }, event: Event): void; + down(data: { [key: string]: any }, event: Event): void; + enter(data: { [key: string]: any }, event: Event): void; + enterOver(data: { [key: string]: any }, event: Event): void; + fireEvent(inType: string, data: { [key: string]: any }, event: Event): void; + fireNativeEvent(event: Event): void; + leave(data: { [key: string]: any }, event: Event): void; + cloneEvent(event: Event, inEvent: Event | Touch): { [key: string]: any }; + makeEvent(inType: string, data: { [key: string]: any }, event: Event): PointerEvent; + move(data: { [key: string]: any }, event: Event): void; + out(data: { [key: string]: any }, event: Event): void; + over(data: { [key: string]: any }, event: Event): void; + registerSource(name: string, source: EventSource): void; + registerSources(): void; + up(data: { [key: string]: any }, event: Event): void; + wrapMouseEvent(eventType: string, event: Event): PointerEvent; +} diff --git a/types/ol/pointer/TouchSource.d.ts b/types/ol/pointer/TouchSource.d.ts new file mode 100644 index 0000000000..19a1681998 --- /dev/null +++ b/types/ol/pointer/TouchSource.d.ts @@ -0,0 +1,6 @@ +import EventSource from 'ol/pointer/EventSource'; +import MouseSource from 'ol/pointer/MouseSource'; +import PointerEventHandler from 'ol/pointer/PointerEventHandler'; +export default class TouchSource extends EventSource { + constructor(dispatcher: PointerEventHandler, mouseSource: MouseSource); +} diff --git a/types/ol/proj/Projection.d.ts b/types/ol/proj/Projection.d.ts index 26050bb377..248842f757 100644 --- a/types/ol/proj/Projection.d.ts +++ b/types/ol/proj/Projection.d.ts @@ -1,3 +1,32 @@ -import * as ol from 'openlayers'; - -export default ol.proj.Projection; +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import Units from 'ol/proj/Units'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export interface Options { + code: string; + units?: Units | string; + extent?: Extent; + axisOrientation?: string; + global?: boolean; + metersPerUnit?: number; + worldExtent?: Extent; + getPointResolution?: ((param0: number, param1: Coordinate) => number); +} +export default class Projection { + constructor(options: Options); + getUnits(): Units; + canWrapX(): boolean; + getCode(): string; + getDefaultTileGrid(): TileGrid; + getExtent(): Extent; + getMetersPerUnit(): number; + getPointResolutionFunc(): ((param0: number, param1: Coordinate) => number); + getAxisOrientation(): string; + getWorldExtent(): Extent; + isGlobal(): boolean; + setDefaultTileGrid(tileGrid: TileGrid): void; + setExtent(extent: Extent): void; + setGetPointResolution(func: ((param0: number, param1: Coordinate) => number)): void; + setGlobal(global: boolean): void; + setWorldExtent(worldExtent: Extent): void; +} diff --git a/types/ol/proj/Units.d.ts b/types/ol/proj/Units.d.ts new file mode 100644 index 0000000000..604219e7f5 --- /dev/null +++ b/types/ol/proj/Units.d.ts @@ -0,0 +1,11 @@ +export const METERS_PER_UNIT: { [key in Units]: number }; +declare enum Units { + DEGREES = 'degrees', + FEET = 'ft', + METERS = 'm', + PIXELS = 'pixels', + TILE_PIXELS = 'tile-pixels', + USFEET = 'us-ft', +} + +export default Units; diff --git a/types/ol/proj/epsg3857.d.ts b/types/ol/proj/epsg3857.d.ts new file mode 100644 index 0000000000..fcc852d4a2 --- /dev/null +++ b/types/ol/proj/epsg3857.d.ts @@ -0,0 +1,3 @@ +import Projection from 'ol/proj/Projection'; +export function fromEPSG4326(input: number[], opt_output?: number[], opt_dimension?: number): number[]; +export function toEPSG4326(input: number[], opt_output?: number[], opt_dimension?: number): number[]; diff --git a/types/ol/proj/epsg4326.d.ts b/types/ol/proj/epsg4326.d.ts new file mode 100644 index 0000000000..ca9a838168 --- /dev/null +++ b/types/ol/proj/epsg4326.d.ts @@ -0,0 +1 @@ +import Projection from 'ol/proj/Projection'; diff --git a/types/ol/proj/index.d.ts b/types/ol/proj/index.d.ts index dc8d1a7f95..c323fb8c45 100644 --- a/types/ol/proj/index.d.ts +++ b/types/ol/proj/index.d.ts @@ -1,3 +1,27 @@ -import * as ol from 'openlayers'; - -export default ol.proj; +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import Projection from 'ol/proj/Projection'; +import Units from 'ol/proj/Units'; +export function addCommon(): void; +export function addCoordinateTransforms(source: ProjectionLike, destination: ProjectionLike, forward: ((param0: Coordinate) => Coordinate), inverse: ((param0: Coordinate) => Coordinate)): void; +export function addEquivalentProjections(projections: Projection[]): void; +export function addEquivalentTransforms(projections1: Projection[], projections2: Projection[], forwardTransform: TransformFunction, inverseTransform: TransformFunction): void; +export function addProjection(projection: Projection): void; +export function addProjections(projections: Projection[]): void; +export function clearAllProjections(): void; +export function cloneTransform(input: number[], opt_output?: number[], opt_dimension?: number): number[]; +export function createProjection(projection: Projection | string, defaultCode: string): Projection; +export function createTransformFromCoordinateTransform(coordTransform: ((param0: Coordinate) => Coordinate)): TransformFunction; +export function equivalent(projection1: Projection, projection2: Projection): boolean; +export function fromLonLat(coordinate: Coordinate, opt_projection?: ProjectionLike): Coordinate; +export function get(projectionLike: ProjectionLike): Projection; +export function getPointResolution(projection: ProjectionLike, resolution: number, point: Coordinate, opt_units?: Units): number; +export function getTransform(source: ProjectionLike, destination: ProjectionLike): TransformFunction; +export function getTransformFromProjections(sourceProjection: Projection, destinationProjection: Projection): TransformFunction; +export function identityTransform(input: number[], opt_output?: number[], opt_dimension?: number): number[]; +export function toLonLat(coordinate: Coordinate, opt_projection?: ProjectionLike): Coordinate; +export function transform(coordinate: Coordinate, source: ProjectionLike, destination: ProjectionLike): Coordinate; +export function transformExtent(extent: Extent, source: ProjectionLike, destination: ProjectionLike): Extent; +export function transformWithProjections(point: Coordinate, sourceProjection: Projection, destinationProjection: Projection): Coordinate; +export type ProjectionLike = Projection | string; +export type TransformFunction = ((param0: number[], param1: number[], param2: number) => number[]); diff --git a/types/ol/proj/proj4.d.ts b/types/ol/proj/proj4.d.ts new file mode 100644 index 0000000000..f6ec098c04 --- /dev/null +++ b/types/ol/proj/proj4.d.ts @@ -0,0 +1 @@ +export function register(proj4: any): void; diff --git a/types/ol/proj/projections.d.ts b/types/ol/proj/projections.d.ts new file mode 100644 index 0000000000..5c51885456 --- /dev/null +++ b/types/ol/proj/projections.d.ts @@ -0,0 +1,4 @@ +import Projection from 'ol/proj/Projection'; +export function add(code: string, projection: Projection): void; +export function clear(): void; +export function get(code: string): Projection; diff --git a/types/ol/proj/transforms.d.ts b/types/ol/proj/transforms.d.ts new file mode 100644 index 0000000000..bbc7aa528a --- /dev/null +++ b/types/ol/proj/transforms.d.ts @@ -0,0 +1,6 @@ +import { TransformFunction } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +export function add(source: Projection, destination: Projection, transformFn: TransformFunction): void; +export function clear(): void; +export function get(sourceCode: string, destinationCode: string): TransformFunction; +export function remove(source: Projection, destination: Projection): TransformFunction; diff --git a/types/ol/render/Box.d.ts b/types/ol/render/Box.d.ts new file mode 100644 index 0000000000..f14e2d572b --- /dev/null +++ b/types/ol/render/Box.d.ts @@ -0,0 +1,11 @@ +import Disposable from 'ol/Disposable'; +import Polygon from 'ol/geom/Polygon'; +import { Pixel } from 'ol/pixel'; +import PluggableMap from 'ol/PluggableMap'; +export default class RenderBox extends Disposable { + constructor(className: string); + createOrUpdateGeometry(): void; + getGeometry(): Polygon; + setMap(map: PluggableMap): void; + setPixels(startPixel: Pixel, endPixel: Pixel): void; +} diff --git a/types/ol/render/Event.d.ts b/types/ol/render/Event.d.ts index 981b821b5e..bc0e4788b2 100644 --- a/types/ol/render/Event.d.ts +++ b/types/ol/render/Event.d.ts @@ -1,3 +1,12 @@ -import * as ol from 'openlayers'; - -export default ol.render.Event; +import Event from 'ol/events/Event'; +import { FrameState } from 'ol/PluggableMap'; +import EventType from 'ol/render/EventType'; +import VectorContext from 'ol/render/VectorContext'; +import WebGLContext from 'ol/webgl/Context'; +export default class RenderEvent extends Event { + constructor(type: EventType, opt_vectorContext?: VectorContext, opt_frameState?: FrameState, opt_context?: CanvasRenderingContext2D, opt_glContext?: WebGLContext); + context: CanvasRenderingContext2D; + frameState: FrameState; + glContext: WebGLContext; + vectorContext: VectorContext; +} diff --git a/types/ol/render/EventType.d.ts b/types/ol/render/EventType.d.ts new file mode 100644 index 0000000000..32543549f5 --- /dev/null +++ b/types/ol/render/EventType.d.ts @@ -0,0 +1,8 @@ +declare enum EventType { + POSTCOMPOSE = 'postcompose', + PRECOMPOSE = 'precompose', + RENDER = 'render', + RENDERCOMPLETE = 'rendercomplete', +} + +export default EventType; diff --git a/types/ol/render/Feature.d.ts b/types/ol/render/Feature.d.ts index 95e4831fba..db215a30c1 100644 --- a/types/ol/render/Feature.d.ts +++ b/types/ol/render/Feature.d.ts @@ -1,3 +1,21 @@ -import * as ol from 'openlayers'; - -export default ol.render.Feature; +import { Extent } from 'ol/extent'; +import GeometryType from 'ol/geom/GeometryType'; +import { ProjectionLike } from 'ol/proj'; +export default class RenderFeature { + constructor(type: GeometryType, flatCoordinates: number[], ends: number[] | number[][], properties: { [key: string]: any }, id: number | string); + getId(): number | string; + get(key: string): any; + getFlatInteriorPoint(): number[]; + getFlatInteriorPoints(): number[]; + getFlatMidpoint(): number[]; + getFlatMidpoints(): number[]; + getGeometry(): RenderFeature; + getExtent(): Extent; + getOrientedFlatCoordinates(): number[]; + getProperties(): { [key: string]: any }; + getSimplifiedGeometry(squaredTolerance: number): RenderFeature; + getStride(): number; + getStyleFunction(): any; + getType(): GeometryType; + transform(source: ProjectionLike, destination: ProjectionLike): void; +} diff --git a/types/ol/render/ReplayGroup.d.ts b/types/ol/render/ReplayGroup.d.ts new file mode 100644 index 0000000000..bed550a772 --- /dev/null +++ b/types/ol/render/ReplayGroup.d.ts @@ -0,0 +1,8 @@ +import ReplayType from 'ol/render/ReplayType'; +import VectorContext from 'ol/render/VectorContext'; +export default class ReplayGroup { + constructor(); + addDeclutter(group: boolean): any[]; + getReplay(zIndex: number, replayType: ReplayType): VectorContext; + isEmpty(): boolean; +} diff --git a/types/ol/render/ReplayType.d.ts b/types/ol/render/ReplayType.d.ts new file mode 100644 index 0000000000..bca0d01919 --- /dev/null +++ b/types/ol/render/ReplayType.d.ts @@ -0,0 +1,10 @@ +declare enum ReplayType { + CIRCLE = 'Circle', + DEFAULT = 'Default', + IMAGE = 'Image', + LINE_STRING = 'LineString', + POLYGON = 'Polygon', + TEXT = 'Text', +} + +export default ReplayType; diff --git a/types/ol/render/VectorContext.d.ts b/types/ol/render/VectorContext.d.ts index b3e287c91b..82205c42aa 100644 --- a/types/ol/render/VectorContext.d.ts +++ b/types/ol/render/VectorContext.d.ts @@ -1,3 +1,37 @@ -import * as ol from 'openlayers'; - -export default ol.render.VectorContext; +import Feature from 'ol/Feature'; +import Circle from 'ol/geom/Circle'; +import Geometry from 'ol/geom/Geometry'; +import GeometryCollection from 'ol/geom/GeometryCollection'; +import LineString from 'ol/geom/LineString'; +import MultiLineString from 'ol/geom/MultiLineString'; +import MultiPoint from 'ol/geom/MultiPoint'; +import MultiPolygon from 'ol/geom/MultiPolygon'; +import Point from 'ol/geom/Point'; +import Polygon from 'ol/geom/Polygon'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { DeclutterGroup } from 'ol/render/canvas'; +import RenderFeature from 'ol/render/Feature'; +import Fill from 'ol/style/Fill'; +import ImageStyle from 'ol/style/Image'; +import Stroke from 'ol/style/Stroke'; +import Style from 'ol/style/Style'; +import Text from 'ol/style/Text'; +export default class VectorContext { + constructor(); + drawMultiPolygon(multiPolygonGeometry: MultiPolygon, feature: Feature | RenderFeature): void; + drawCircle(circleGeometry: Circle, feature: Feature): void; + drawFeature(feature: Feature, style: Style): void; + drawGeometry(geometry: Geometry): void; + drawGeometryCollection(geometryCollectionGeometry: GeometryCollection, feature: Feature): void; + drawLineString(lineStringGeometry: LineString | RenderFeature, feature: Feature | RenderFeature): void; + drawMultiLineString(multiLineStringGeometry: MultiLineString | RenderFeature, feature: Feature | RenderFeature): void; + drawMultiPoint(multiPointGeometry: MultiPoint | RenderFeature, feature: Feature | RenderFeature): void; + drawCustom(geometry: SimpleGeometry, feature: Feature | RenderFeature, renderer: (() => void)): void; + drawPoint(pointGeometry: Point | RenderFeature, feature: Feature | RenderFeature): void; + drawPolygon(polygonGeometry: Polygon | RenderFeature, feature: Feature | RenderFeature): void; + drawText(geometry: Geometry | RenderFeature, feature: Feature | RenderFeature): void; + setFillStrokeStyle(fillStyle: Fill, strokeStyle: Stroke): void; + setImageStyle(imageStyle: ImageStyle, opt_declutterGroup?: DeclutterGroup): void; + setStyle(style: Style): void; + setTextStyle(textStyle: Text, opt_declutterGroup?: DeclutterGroup): void; +} diff --git a/types/ol/render/canvas.d.ts b/types/ol/render/canvas.d.ts deleted file mode 100644 index 9e6d06eca6..0000000000 --- a/types/ol/render/canvas.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.render.canvas; diff --git a/types/ol/render/canvas/ImageReplay.d.ts b/types/ol/render/canvas/ImageReplay.d.ts new file mode 100644 index 0000000000..45fbf8ccb0 --- /dev/null +++ b/types/ol/render/canvas/ImageReplay.d.ts @@ -0,0 +1,5 @@ +import { Extent } from 'ol/extent'; +import CanvasReplay from 'ol/render/canvas/Replay'; +export default class CanvasImageReplay extends CanvasReplay { + constructor(tolerance: number, maxExtent: Extent, resolution: number, pixelRatio: number, overlaps: boolean, declutterTree: any); +} diff --git a/types/ol/render/canvas/Immediate.d.ts b/types/ol/render/canvas/Immediate.d.ts new file mode 100644 index 0000000000..0b19c9deee --- /dev/null +++ b/types/ol/render/canvas/Immediate.d.ts @@ -0,0 +1,6 @@ +import { Extent } from 'ol/extent'; +import VectorContext from 'ol/render/VectorContext'; +import { Transform } from 'ol/transform'; +export default class CanvasImmediateRenderer extends VectorContext { + constructor(context: CanvasRenderingContext2D, pixelRatio: number, extent: Extent, transform: Transform, viewRotation: number); +} diff --git a/types/ol/render/canvas/Instruction.d.ts b/types/ol/render/canvas/Instruction.d.ts new file mode 100644 index 0000000000..36b24bd48f --- /dev/null +++ b/types/ol/render/canvas/Instruction.d.ts @@ -0,0 +1,17 @@ +declare enum Instruction { + BEGIN_GEOMETRY = 0, + BEGIN_PATH = 1, + CIRCLE = 2, + CLOSE_PATH = 3, + CUSTOM = 4, + DRAW_CHARS = 5, + DRAW_IMAGE = 6, + END_GEOMETRY = 7, + FILL = 8, + MOVE_TO_LINE_TO = 9, + SET_FILL_STYLE = 10, + SET_STROKE_STYLE = 11, + STROKE = 12, +} + +export default Instruction; diff --git a/types/ol/render/canvas/LineStringReplay.d.ts b/types/ol/render/canvas/LineStringReplay.d.ts new file mode 100644 index 0000000000..e400f57932 --- /dev/null +++ b/types/ol/render/canvas/LineStringReplay.d.ts @@ -0,0 +1,8 @@ +import { Extent } from 'ol/extent'; +import { FillStrokeState } from 'ol/render/canvas'; +import CanvasReplay from 'ol/render/canvas/Replay'; +export default class CanvasLineStringReplay extends CanvasReplay { + constructor(tolerance: number, maxExtent: Extent, resolution: number, pixelRatio: number, overlaps: boolean, declutterTree: any); + applyStroke(): void; + applyStroke(state: FillStrokeState): void; +} diff --git a/types/ol/render/canvas/PolygonReplay.d.ts b/types/ol/render/canvas/PolygonReplay.d.ts new file mode 100644 index 0000000000..c042126938 --- /dev/null +++ b/types/ol/render/canvas/PolygonReplay.d.ts @@ -0,0 +1,5 @@ +import { Extent } from 'ol/extent'; +import CanvasReplay from 'ol/render/canvas/Replay'; +export default class CanvasPolygonReplay extends CanvasReplay { + constructor(tolerance: number, maxExtent: Extent, resolution: number, pixelRatio: number, overlaps: boolean, declutterTree: any); +} diff --git a/types/ol/render/canvas/Replay.d.ts b/types/ol/render/canvas/Replay.d.ts new file mode 100644 index 0000000000..e855b720ca --- /dev/null +++ b/types/ol/render/canvas/Replay.d.ts @@ -0,0 +1,42 @@ +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import Geometry from 'ol/geom/Geometry'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import { FillStrokeState, DeclutterGroup } from 'ol/render/canvas'; +import RenderFeature from 'ol/render/Feature'; +import VectorContext from 'ol/render/VectorContext'; +import { Transform } from 'ol/transform'; +export default class CanvasReplay extends VectorContext { + constructor(tolerance: number, maxExtent: Extent, resolution: number, pixelRatio: number, overlaps: boolean, declutterTree: any); + protected overlaps: boolean; + protected instructions: any[]; + protected hitDetectionInstructions: any[]; + protected coordinates: number[]; + protected state: FillStrokeState; + protected pixelRatio: number; + protected tolerance: number; + protected maxLineWidth: number; + protected applyPixelRatio(dashArray: number[]): number[]; + protected getBufferedMaxExtent(): Extent; + protected beginGeometry(geometry: Geometry | RenderFeature, feature: Feature | RenderFeature): void; + protected appendFlatCoordinates(flatCoordinates: number[], offset: number, end: number, stride: number, closed: boolean, skipFirst: boolean): number; + protected resolution: number; + protected maxExtent: Extent; + replayImage_(context: CanvasRenderingContext2D, x: number, y: number, image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, anchorX: number, anchorY: number, declutterGroup: DeclutterGroup, height: number, opacity: number, originX: number, originY: number, rotation: number, scale: number, snapToPixel: boolean, width: number, padding: number[], fillInstruction: any[], strokeInstruction: any[]): void; + finish(): void; + drawCustomCoordinates_(flatCoordinates: number[], offset: number, ends: number[], stride: number, replayEnds: number[]): number; + drawCustom(): void; + drawCustom(geometry: SimpleGeometry, feature: Feature | RenderFeature, renderer: (() => void)): void; + renderDeclutter_(declutterGroup: DeclutterGroup, feature: Feature | RenderFeature): void; + replay(context: CanvasRenderingContext2D, transform: Transform, viewRotation: number, skippedFeaturesHash: { [key: string]: boolean }, snapToPixel: boolean): void; + replayHitDetection(context: CanvasRenderingContext2D, transform: Transform, viewRotation: number, skippedFeaturesHash: { [key: string]: boolean }, opt_featureCallback?: (() => void), opt_hitExtent?: Extent): T; + endGeometry(geometry: Geometry | RenderFeature, feature: Feature | RenderFeature): void; + replayTextBackground_(context: CanvasRenderingContext2D, p1: Coordinate, p2: Coordinate, p3: Coordinate, p4: Coordinate, fillInstruction: any[], strokeInstruction: any[]): void; + createStroke(state: FillStrokeState): any[]; + reverseHitDetectionInstructions(): void; + createFill(state: FillStrokeState, geometry: Geometry | RenderFeature): any[]; + applyStroke(state: FillStrokeState): void; + updateFillStyle(state: FillStrokeState, createFill: ((this: CanvasReplay, param1: FillStrokeState, param2: Geometry | RenderFeature) => any[]), geometry: Geometry | RenderFeature): void; + updateStrokeStyle(state: FillStrokeState, applyStroke: ((this: CanvasReplay, param1: FillStrokeState) => void)): void; +} diff --git a/types/ol/render/canvas/ReplayGroup.d.ts b/types/ol/render/canvas/ReplayGroup.d.ts new file mode 100644 index 0000000000..0f71372ee0 --- /dev/null +++ b/types/ol/render/canvas/ReplayGroup.d.ts @@ -0,0 +1,21 @@ +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import { DeclutterGroup } from 'ol/render/canvas'; +import CanvasReplay from 'ol/render/canvas/Replay'; +import RenderFeature from 'ol/render/Feature'; +import ReplayGroup from 'ol/render/ReplayGroup'; +import ReplayType from 'ol/render/ReplayType'; +import { Transform } from 'ol/transform'; +export function getCircleArray(radius: number): any[][]; +export function replayDeclutter(declutterReplays: { [key: string]: any[] }, context: CanvasRenderingContext2D, rotation: number, snapToPixel: boolean): void; +export default class CanvasReplayGroup extends ReplayGroup { + constructor(tolerance: number, maxExtent: Extent, resolution: number, pixelRatio: number, overlaps: boolean, declutterTree: any, opt_renderBuffer?: number); + clip(context: CanvasRenderingContext2D, transform: Transform): void; + finish(): void; + forEachFeatureAtCoordinate(coordinate: Coordinate, resolution: number, rotation: number, hitTolerance: number, skippedFeaturesHash: { [key: string]: boolean }, callback: ((param0: Feature | RenderFeature) => T), declutterReplays: { [key: string]: DeclutterGroup }): T; + getClipCoords(transform: Transform): number[]; + getReplays(): { [key: string]: { [key in ReplayType]: CanvasReplay } }; + hasReplays(replays: ReplayType[]): boolean; + replay(context: CanvasRenderingContext2D, transform: Transform, viewRotation: number, skippedFeaturesHash: { [key: string]: boolean }, snapToPixel: boolean, opt_replayTypes?: ReplayType[], opt_declutterReplays?: { [key: string]: DeclutterGroup }): void; +} diff --git a/types/ol/render/canvas/TextReplay.d.ts b/types/ol/render/canvas/TextReplay.d.ts new file mode 100644 index 0000000000..92bdbd66bf --- /dev/null +++ b/types/ol/render/canvas/TextReplay.d.ts @@ -0,0 +1,7 @@ +import { Extent } from 'ol/extent'; +import CanvasReplay from 'ol/render/canvas/Replay'; +export function measureTextWidths(font: string, lines: string[], widths: number[]): number; +export default class CanvasTextReplay extends CanvasReplay { + constructor(tolerance: number, maxExtent: Extent, resolution: number, pixelRatio: number, overlaps: boolean, declutterTree: any); + getImage(text: string, textKey: string, fillKey: string, strokeKey: string): HTMLCanvasElement; +} diff --git a/types/ol/render/canvas/index.d.ts b/types/ol/render/canvas/index.d.ts new file mode 100644 index 0000000000..09c7e23235 --- /dev/null +++ b/types/ol/render/canvas/index.d.ts @@ -0,0 +1,53 @@ +import { ColorLike } from 'ol/colorlike'; +import LRUCache from 'ol/structs/LRUCache'; +import Fill from 'ol/style/Fill'; +import Stroke from 'ol/style/Stroke'; +import { Transform } from 'ol/transform'; +export function drawImage(context: CanvasRenderingContext2D, transform: Transform, opacity: number, image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, originX: number, originY: number, w: number, h: number, x: number, y: number, scale: number): void; +export function measureTextWidth(font: string, text: string): number; +export function rotateAtOffset(context: CanvasRenderingContext2D, rotation: number, offsetX: number, offsetY: number): void; +export type DeclutterGroup = any[]; +export interface FillState { + fillStyle: ColorLike; +} +export interface FillStrokeState { + currentFillStyle?: ColorLike; + currentStrokeStyle?: ColorLike; + currentLineCap?: string; + currentLineDash: number[]; + currentLineDashOffset?: number; + currentLineJoin?: string; + currentLineWidth?: number; + currentMiterLimit?: number; + lastStroke?: number; + fillStyle?: ColorLike; + strokeStyle?: ColorLike; + lineCap?: string; + lineDash: number[]; + lineDashOffset?: number; + lineJoin?: string; + lineWidth?: number; + miterLimit?: number; +} +export const labelCache: LRUCache; +export interface StrokeState { + lineCap: string; + lineDash: number[]; + lineDashOffset: number; + lineJoin: string; + lineWidth: number; + miterLimit: number; + strokeStyle: ColorLike; +} +export interface TextState { + font: string; + textAlign?: string; + textBaseline: string; + placement?: string; + maxAngle?: number; + overflow?: boolean; + backgroundFill?: Fill; + backgroundStroke?: Stroke; + scale?: number; + padding?: number[]; +} diff --git a/types/ol/render/index.d.ts b/types/ol/render/index.d.ts new file mode 100644 index 0000000000..ed7f2a3142 --- /dev/null +++ b/types/ol/render/index.d.ts @@ -0,0 +1,18 @@ +import { FeatureLike } from 'ol/Feature'; +import SimpleGeometry from 'ol/geom/SimpleGeometry'; +import CanvasImmediateRenderer from 'ol/render/canvas/Immediate'; +import { Size } from 'ol/size'; +export function toContext(context: CanvasRenderingContext2D, opt_options?: ToContextOptions): CanvasImmediateRenderer; +export type OrderFunction = ((param0: FeatureLike, param1: FeatureLike) => number); +export interface State { + context: CanvasRenderingContext2D; + feature: FeatureLike; + geometry: SimpleGeometry; + pixelRatio: number; + resolution: number; + rotation: number; +} +export interface ToContextOptions { + size?: Size; + pixelRatio?: number; +} diff --git a/types/ol/render/replay.d.ts b/types/ol/render/replay.d.ts new file mode 100644 index 0000000000..779e76d27c --- /dev/null +++ b/types/ol/render/replay.d.ts @@ -0,0 +1,15 @@ +import ReplayType from 'ol/render/ReplayType'; +export const ORDER: ReplayType[]; +export enum TEXT_ALIGN { + left = 0, + end = 0, + center = 0.5, + right = 1, + start = 1, + top = 0, + middle = 0.5, + hanging = 0.2, + alphabetic = 0.8, + ideographic = 0.8, + bottom = 1, +} diff --git a/types/ol/render/webgl/CircleReplay.d.ts b/types/ol/render/webgl/CircleReplay.d.ts new file mode 100644 index 0000000000..0b200a0e3d --- /dev/null +++ b/types/ol/render/webgl/CircleReplay.d.ts @@ -0,0 +1,5 @@ +import { Extent } from 'ol/extent'; +import WebGLReplay from 'ol/render/webgl/Replay'; +export default class WebGLCircleReplay extends WebGLReplay { + constructor(tolerance: number, maxExtent: Extent); +} diff --git a/types/ol/render/webgl/ImageReplay.d.ts b/types/ol/render/webgl/ImageReplay.d.ts new file mode 100644 index 0000000000..47c9510ad0 --- /dev/null +++ b/types/ol/render/webgl/ImageReplay.d.ts @@ -0,0 +1,7 @@ +import { Extent } from 'ol/extent'; +import WebGLTextureReplay from 'ol/render/webgl/TextureReplay'; +export default class WebGLImageReplay extends WebGLTextureReplay { + constructor(tolerance: number, maxExtent: Extent); + protected hitDetectionImages_: any[]; + protected images_: any[]; +} diff --git a/types/ol/render/webgl/Immediate.d.ts b/types/ol/render/webgl/Immediate.d.ts new file mode 100644 index 0000000000..bac48c2245 --- /dev/null +++ b/types/ol/render/webgl/Immediate.d.ts @@ -0,0 +1,8 @@ +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import VectorContext from 'ol/render/VectorContext'; +import { Size } from 'ol/size'; +import WebGLContext from 'ol/webgl/Context'; +export default class WebGLImmediateRenderer extends VectorContext { + constructor(context: WebGLContext, center: Coordinate, resolution: number, rotation: number, size: Size, extent: Extent, pixelRatio: number); +} diff --git a/types/ol/render/webgl/LineStringReplay.d.ts b/types/ol/render/webgl/LineStringReplay.d.ts new file mode 100644 index 0000000000..183f70ba4a --- /dev/null +++ b/types/ol/render/webgl/LineStringReplay.d.ts @@ -0,0 +1,10 @@ +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import RenderFeature from 'ol/render/Feature'; +import WebGLReplay from 'ol/render/webgl/Replay'; +export default class WebGLLineStringReplay extends WebGLReplay { + constructor(tolerance: number, maxExtent: Extent); + drawPolygonCoordinates(flatCoordinates: number[], holeFlatCoordinates: number[][], stride: number): void; + getCurrentIndex(): number; + setPolygonStyle(feature: Feature | RenderFeature, opt_index?: number): void; +} diff --git a/types/ol/render/webgl/PolygonReplay.d.ts b/types/ol/render/webgl/PolygonReplay.d.ts new file mode 100644 index 0000000000..88addfdb7c --- /dev/null +++ b/types/ol/render/webgl/PolygonReplay.d.ts @@ -0,0 +1,15 @@ +import { Extent } from 'ol/extent'; +import WebGLReplay from 'ol/render/webgl/Replay'; +export interface PolygonSegment { + p0: PolygonVertex; + p1: PolygonVertex; +} +export interface PolygonVertex { + x: number; + y: number; + i: number; + reflex?: boolean; +} +export default class WebGLPolygonReplay extends WebGLReplay { + constructor(tolerance: number, maxExtent: Extent); +} diff --git a/types/ol/render/webgl/Replay.d.ts b/types/ol/render/webgl/Replay.d.ts new file mode 100644 index 0000000000..336b801a75 --- /dev/null +++ b/types/ol/render/webgl/Replay.d.ts @@ -0,0 +1,36 @@ +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import RenderFeature from 'ol/render/Feature'; +import VectorContext from 'ol/render/VectorContext'; +import Locations from 'ol/render/webgl/circlereplay/defaultshader/Locations'; +import WebGLLineStringReplay from 'ol/render/webgl/LineStringReplay'; +import Locations_1 from 'ol/render/webgl/linestringreplay/defaultshader/Locations'; +import Locations_2 from 'ol/render/webgl/polygonreplay/defaultshader/Locations'; +import Locations_3 from 'ol/render/webgl/texturereplay/defaultshader/Locations'; +import { Size } from 'ol/size'; +import WebGLBuffer from 'ol/webgl/Buffer'; +import WebGLContext from 'ol/webgl/Context'; +export default class WebGLReplay extends VectorContext { + constructor(tolerance: number, maxExtent: Extent); + protected verticesBuffer: WebGLBuffer; + protected vertices: number[]; + protected tolerance: number; + protected indices: number[]; + protected indicesBuffer: WebGLBuffer; + protected lineStringReplay: WebGLLineStringReplay; + protected origin: Coordinate; + protected startIndicesFeature: any[]; + protected startIndices: number[]; + protected drawElements(gl: WebGLRenderingContext, context: WebGLContext, start: number, end: number): void; + protected drawHitDetectionReplay(gl: WebGLRenderingContext, context: WebGLContext, skippedFeaturesHash: { [key: string]: boolean }, featureCallback: ((param0: Feature | RenderFeature) => T), oneByOne: boolean, opt_hitExtent?: Extent): T; + protected drawHitDetectionReplayAll(gl: WebGLRenderingContext, context: WebGLContext, skippedFeaturesHash: { [key: string]: boolean }, featureCallback: ((param0: Feature | RenderFeature) => T)): T; + protected drawHitDetectionReplayOneByOne(gl: WebGLRenderingContext, context: WebGLContext, skippedFeaturesHash: { [key: string]: boolean }, featureCallback: ((param0: Feature | RenderFeature) => T), opt_hitExtent?: Extent): T; + protected setUpProgram(gl: WebGLRenderingContext, context: WebGLContext, size: Size, pixelRatio: number): Locations | Locations_1 | Locations_2 | Locations_3; + protected shutDownProgram(gl: WebGLRenderingContext, locations: Locations | Locations_1 | Locations_2 | Locations_3): void; + protected drawReplay(gl: WebGLRenderingContext, context: WebGLContext, skippedFeaturesHash: { [key: string]: boolean }, hitDetection: boolean): void; + protected maxExtent: Extent; + replay(context: WebGLContext, center: Coordinate, resolution: number, rotation: number, size: Size, pixelRatio: number, opacity: number, skippedFeaturesHash: { [key: string]: boolean }, featureCallback: ((param0: Feature | RenderFeature) => T), oneByOne: boolean, opt_hitExtent?: Extent): T; + getDeleteResourcesFunction(context: WebGLContext): (() => void); + finish(context: WebGLContext): void; +} diff --git a/types/ol/render/webgl/ReplayGroup.d.ts b/types/ol/render/webgl/ReplayGroup.d.ts new file mode 100644 index 0000000000..41fac38240 --- /dev/null +++ b/types/ol/render/webgl/ReplayGroup.d.ts @@ -0,0 +1,15 @@ +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import RenderFeature from 'ol/render/Feature'; +import ReplayGroup from 'ol/render/ReplayGroup'; +import { Size } from 'ol/size'; +import WebGLContext from 'ol/webgl/Context'; +export default class WebGLReplayGroup extends ReplayGroup { + constructor(tolerance: number, maxExtent: Extent, opt_renderBuffer?: number); + finish(context: WebGLContext): void; + forEachFeatureAtCoordinate(coordinate: Coordinate, context: WebGLContext, center: Coordinate, resolution: number, rotation: number, size: Size, pixelRatio: number, opacity: number, skippedFeaturesHash: { [key: string]: boolean }, callback: ((param0: Feature | RenderFeature) => T)): T; + getDeleteResourcesFunction(context: WebGLContext): (() => void); + hasFeatureAtCoordinate(coordinate: Coordinate, context: WebGLContext, center: Coordinate, resolution: number, rotation: number, size: Size, pixelRatio: number, opacity: number, skippedFeaturesHash: { [key: string]: boolean }): boolean; + replay(context: WebGLContext, center: Coordinate, resolution: number, rotation: number, size: Size, pixelRatio: number, opacity: number, skippedFeaturesHash: { [key: string]: boolean }): void; +} diff --git a/types/ol/render/webgl/TextReplay.d.ts b/types/ol/render/webgl/TextReplay.d.ts new file mode 100644 index 0000000000..1efc822360 --- /dev/null +++ b/types/ol/render/webgl/TextReplay.d.ts @@ -0,0 +1,11 @@ +import { Extent } from 'ol/extent'; +import WebGLTextureReplay from 'ol/render/webgl/TextureReplay'; +import AtlasManager from 'ol/style/AtlasManager'; +export interface GlyphAtlas { + atlas: AtlasManager; + width: { [key: string]: number }; + height: number; +} +export default class WebGLTextReplay extends WebGLTextureReplay { + constructor(tolerance: number, maxExtent: Extent); +} diff --git a/types/ol/render/webgl/TextureReplay.d.ts b/types/ol/render/webgl/TextureReplay.d.ts new file mode 100644 index 0000000000..c892d1c134 --- /dev/null +++ b/types/ol/render/webgl/TextureReplay.d.ts @@ -0,0 +1,27 @@ +import { Extent } from 'ol/extent'; +import WebGLReplay from 'ol/render/webgl/Replay'; +import Locations from 'ol/render/webgl/texturereplay/defaultshader/Locations'; +import WebGLContext from 'ol/webgl/Context'; +export default class WebGLTextureReplay extends WebGLReplay { + constructor(tolerance: number, maxExtent: Extent); + protected hitDetectionGroupIndices: number[]; + protected anchorX: number; + protected scale: number; + protected defaultLocations: Locations; + protected rotation: number; + protected rotateWithView: boolean; + protected originY: number; + protected originX: number; + protected groupIndices: number[]; + protected height: number; + protected anchorY: number; + protected imageHeight: number; + protected imageWidth: number; + protected opacity: number; + protected width: number; + protected getTextures(opt_all?: boolean): WebGLTexture[]; + protected getHitDetectionTextures(): WebGLTexture[]; + protected drawReplaySkipping(gl: WebGLRenderingContext, context: WebGLContext, skippedFeaturesHash: { [key: string]: boolean }, textures: WebGLTexture[], groupIndices: number[]): void; + protected drawCoordinates(flatCoordinates: number[], offset: number, end: number, stride: number): number; + protected createTextures(textures: WebGLTexture[], images: any[], texturePerImage: { [key: string]: WebGLTexture }, gl: WebGLRenderingContext): void; +} diff --git a/types/ol/render/webgl/circlereplay/defaultshader/Locations.d.ts b/types/ol/render/webgl/circlereplay/defaultshader/Locations.d.ts new file mode 100644 index 0000000000..35d5cd5f85 --- /dev/null +++ b/types/ol/render/webgl/circlereplay/defaultshader/Locations.d.ts @@ -0,0 +1,3 @@ +export default class Locations { + constructor(gl: WebGLRenderingContext, program: WebGLProgram); +} diff --git a/types/ol/render/webgl/circlereplay/defaultshader/index.d.ts b/types/ol/render/webgl/circlereplay/defaultshader/index.d.ts new file mode 100644 index 0000000000..98fac274bf --- /dev/null +++ b/types/ol/render/webgl/circlereplay/defaultshader/index.d.ts @@ -0,0 +1,4 @@ +import WebGLFragment from 'ol/webgl/Fragment'; +import WebGLVertex from 'ol/webgl/Vertex'; +export const fragment: WebGLFragment; +export const vertex: WebGLVertex; diff --git a/types/ol/render/webgl/index.d.ts b/types/ol/render/webgl/index.d.ts new file mode 100644 index 0000000000..19186b1b8e --- /dev/null +++ b/types/ol/render/webgl/index.d.ts @@ -0,0 +1 @@ +export function triangleIsCounterClockwise(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): boolean; diff --git a/types/ol/render/webgl/linestringreplay/defaultshader/Locations.d.ts b/types/ol/render/webgl/linestringreplay/defaultshader/Locations.d.ts new file mode 100644 index 0000000000..35d5cd5f85 --- /dev/null +++ b/types/ol/render/webgl/linestringreplay/defaultshader/Locations.d.ts @@ -0,0 +1,3 @@ +export default class Locations { + constructor(gl: WebGLRenderingContext, program: WebGLProgram); +} diff --git a/types/ol/render/webgl/linestringreplay/defaultshader/index.d.ts b/types/ol/render/webgl/linestringreplay/defaultshader/index.d.ts new file mode 100644 index 0000000000..98fac274bf --- /dev/null +++ b/types/ol/render/webgl/linestringreplay/defaultshader/index.d.ts @@ -0,0 +1,4 @@ +import WebGLFragment from 'ol/webgl/Fragment'; +import WebGLVertex from 'ol/webgl/Vertex'; +export const fragment: WebGLFragment; +export const vertex: WebGLVertex; diff --git a/types/ol/render/webgl/polygonreplay/defaultshader/Locations.d.ts b/types/ol/render/webgl/polygonreplay/defaultshader/Locations.d.ts new file mode 100644 index 0000000000..35d5cd5f85 --- /dev/null +++ b/types/ol/render/webgl/polygonreplay/defaultshader/Locations.d.ts @@ -0,0 +1,3 @@ +export default class Locations { + constructor(gl: WebGLRenderingContext, program: WebGLProgram); +} diff --git a/types/ol/render/webgl/polygonreplay/defaultshader/index.d.ts b/types/ol/render/webgl/polygonreplay/defaultshader/index.d.ts new file mode 100644 index 0000000000..98fac274bf --- /dev/null +++ b/types/ol/render/webgl/polygonreplay/defaultshader/index.d.ts @@ -0,0 +1,4 @@ +import WebGLFragment from 'ol/webgl/Fragment'; +import WebGLVertex from 'ol/webgl/Vertex'; +export const fragment: WebGLFragment; +export const vertex: WebGLVertex; diff --git a/types/ol/render/webgl/texturereplay/defaultshader/Locations.d.ts b/types/ol/render/webgl/texturereplay/defaultshader/Locations.d.ts new file mode 100644 index 0000000000..35d5cd5f85 --- /dev/null +++ b/types/ol/render/webgl/texturereplay/defaultshader/Locations.d.ts @@ -0,0 +1,3 @@ +export default class Locations { + constructor(gl: WebGLRenderingContext, program: WebGLProgram); +} diff --git a/types/ol/render/webgl/texturereplay/defaultshader/index.d.ts b/types/ol/render/webgl/texturereplay/defaultshader/index.d.ts new file mode 100644 index 0000000000..98fac274bf --- /dev/null +++ b/types/ol/render/webgl/texturereplay/defaultshader/index.d.ts @@ -0,0 +1,4 @@ +import WebGLFragment from 'ol/webgl/Fragment'; +import WebGLVertex from 'ol/webgl/Vertex'; +export const fragment: WebGLFragment; +export const vertex: WebGLVertex; diff --git a/types/ol/renderer/Layer.d.ts b/types/ol/renderer/Layer.d.ts new file mode 100644 index 0000000000..98386b2610 --- /dev/null +++ b/types/ol/renderer/Layer.d.ts @@ -0,0 +1,32 @@ +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import { FeatureLike } from 'ol/Feature'; +import ImageBase from 'ol/ImageBase'; +import Layer from 'ol/layer/Layer'; +import Observable from 'ol/Observable'; +import { FrameState } from 'ol/PluggableMap'; +import Projection from 'ol/proj/Projection'; +import TileSource from 'ol/source/Tile'; +import Tile from 'ol/Tile'; +import TileGrid from 'ol/tilegrid/TileGrid'; +import TileRange from 'ol/TileRange'; +export default class LayerRenderer extends Observable { + constructor(layer: Layer); + protected createLoadedTileFinder(source: TileSource, projection: Projection, tiles: { [key: number]: { [key: string]: Tile } }): ((param0: number, param1: TileRange) => boolean); + protected loadImage(image: ImageBase): boolean; + protected manageTilePyramid(frameState: FrameState, tileSource: TileSource, tileGrid: TileGrid, pixelRatio: number, projection: Projection, extent: Extent, currentZ: number, preload: number, opt_tileCallback?: (() => void), opt_this?: T): void; + protected renderIfReadyAndVisible(): void; + protected scheduleExpireCache(frameState: FrameState, tileSource: TileSource): void; + protected updateUsedTiles(usedTiles: { [key: string]: { [key: string]: TileRange } }, tileSource: TileSource, z: number, tileRange: TileRange): void; + forEachFeatureAtCoordinate(coordinate: Coordinate, frameState: FrameState, hitTolerance: number, callback: ((param0: FeatureLike, param1: Layer) => T)): T | void; + getLayer(): Layer; + hasFeatureAtCoordinate(coordinate: Coordinate, frameState: FrameState): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/Map.d.ts b/types/ol/renderer/Map.d.ts new file mode 100644 index 0000000000..dd592f2d23 --- /dev/null +++ b/types/ol/renderer/Map.d.ts @@ -0,0 +1,27 @@ +import { Coordinate } from 'ol/coordinate'; +import Disposable from 'ol/Disposable'; +import { FeatureLike } from 'ol/Feature'; +import BaseLayer from 'ol/layer/Base'; +import Layer, { State } from 'ol/layer/Layer'; +import { Pixel } from 'ol/pixel'; +import PluggableMap, { FrameState } from 'ol/PluggableMap'; +import EventType from 'ol/render/EventType'; +import LayerRenderer from 'ol/renderer/Layer'; +export function sortByZIndex(state1: State, state2: State): number; +export default class MapRenderer extends Disposable { + constructor(map: PluggableMap); + protected calculateMatrices2D(frameState: FrameState): void; + protected scheduleRemoveUnusedLayerRenderers(frameState: FrameState): void; + protected scheduleExpireIconCache(frameState: FrameState): void; + protected getLayerRenderers(): { [key: string]: LayerRenderer }; + protected getLayerRenderer(layer: BaseLayer): LayerRenderer; + protected getLayerRendererByKey(layerKey: string): LayerRenderer; + forEachLayerAtPixel(pixel: Pixel, frameState: FrameState, hitTolerance: number, callback: ((this: S, param1: Layer, param2: Uint8ClampedArray | Uint8Array) => T), thisArg: S, layerFilter: ((this: U, param1: Layer) => boolean), thisArg2: U): T; + dispatchRenderEvent(type: EventType, frameState: FrameState): void; + hasFeatureAtCoordinate(coordinate: Coordinate, frameState: FrameState, hitTolerance: number, layerFilter: ((this: U, param1: Layer) => boolean), thisArg: U): boolean; + registerLayerRenderers(constructors: LayerRenderer[]): void; + removeLayerRenderers(): void; + renderFrame(frameState: FrameState): void; + forEachFeatureAtCoordinate(coordinate: Coordinate, frameState: FrameState, hitTolerance: number, callback: ((this: S, param1: FeatureLike, param2: Layer) => T), thisArg: S, layerFilter: ((this: U, param1: Layer) => boolean), thisArg2: U): T; + getMap(): PluggableMap; +} diff --git a/types/ol/renderer/canvas/ImageLayer.d.ts b/types/ol/renderer/canvas/ImageLayer.d.ts new file mode 100644 index 0000000000..448257d6f2 --- /dev/null +++ b/types/ol/renderer/canvas/ImageLayer.d.ts @@ -0,0 +1,18 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import ImageLayer from 'ol/layer/Image'; +import Layer from 'ol/layer/Layer'; +import VectorLayer from 'ol/layer/Vector'; +import IntermediateCanvasRenderer from 'ol/renderer/canvas/IntermediateCanvas'; +import MapRenderer from 'ol/renderer/Map'; +export default class CanvasImageLayerRenderer extends IntermediateCanvasRenderer { + constructor(imageLayer: ImageLayer | VectorLayer); + create(mapRenderer: MapRenderer, layer: Layer): CanvasImageLayerRenderer; + handles(layer: Layer): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/canvas/IntermediateCanvas.d.ts b/types/ol/renderer/canvas/IntermediateCanvas.d.ts new file mode 100644 index 0000000000..0340e544ae --- /dev/null +++ b/types/ol/renderer/canvas/IntermediateCanvas.d.ts @@ -0,0 +1,17 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Layer from 'ol/layer/Layer'; +import CanvasLayerRenderer from 'ol/renderer/canvas/Layer'; +import { Transform } from 'ol/transform'; +export default class IntermediateCanvasRenderer extends CanvasLayerRenderer { + constructor(layer: Layer); + protected coordinateToCanvasPixelTransform: Transform; + getImage(): HTMLCanvasElement | HTMLVideoElement | HTMLImageElement; + getImageTransform(): Transform; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/canvas/Layer.d.ts b/types/ol/renderer/canvas/Layer.d.ts new file mode 100644 index 0000000000..ba66e21c8c --- /dev/null +++ b/types/ol/renderer/canvas/Layer.d.ts @@ -0,0 +1,26 @@ +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Layer, { State } from 'ol/layer/Layer'; +import { FrameState } from 'ol/PluggableMap'; +import LayerRenderer from 'ol/renderer/Layer'; +import { Transform } from 'ol/transform'; +export default class CanvasLayerRenderer extends LayerRenderer { + constructor(layer: Layer); + protected renderedResolution: number; + protected clip(context: CanvasRenderingContext2D, frameState: FrameState, extent: Extent): void; + protected dispatchRenderEvent(context: CanvasRenderingContext2D, frameState: FrameState, opt_transform?: Transform): void; + protected getTransform(frameState: FrameState, offsetX: number): Transform; + protected postCompose(context: CanvasRenderingContext2D, frameState: FrameState, layerState: State, opt_transform?: Transform): void; + protected preCompose(context: CanvasRenderingContext2D, frameState: FrameState, opt_transform?: Transform): void; + composeFrame(frameState: FrameState, layerState: State, context: CanvasRenderingContext2D): void; + forEachLayerAtCoordinate(coordinate: Coordinate, frameState: FrameState, hitTolerance: number, callback: ((this: S, param1: Layer, param2: Uint8ClampedArray | Uint8Array) => T), thisArg: S): T; + prepareFrame(frameState: FrameState, layerState: State): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/canvas/Map.d.ts b/types/ol/renderer/canvas/Map.d.ts new file mode 100644 index 0000000000..0d9dc0cdcf --- /dev/null +++ b/types/ol/renderer/canvas/Map.d.ts @@ -0,0 +1,9 @@ +import PluggableMap, { FrameState } from 'ol/PluggableMap'; +import EventType from 'ol/render/EventType'; +import MapRenderer from 'ol/renderer/Map'; +import { Transform } from 'ol/transform'; +export default class CanvasMapRenderer extends MapRenderer { + constructor(map: PluggableMap); + protected getTransform(frameState: FrameState): Transform; + dispatchRenderEvent(type: EventType, frameState: FrameState): void; +} diff --git a/types/ol/renderer/canvas/TileLayer.d.ts b/types/ol/renderer/canvas/TileLayer.d.ts new file mode 100644 index 0000000000..03970624bc --- /dev/null +++ b/types/ol/renderer/canvas/TileLayer.d.ts @@ -0,0 +1,32 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Layer, { State } from 'ol/layer/Layer'; +import TileLayer from 'ol/layer/Tile'; +import VectorTileLayer from 'ol/layer/VectorTile'; +import { FrameState } from 'ol/PluggableMap'; +import Projection from 'ol/proj/Projection'; +import IntermediateCanvasRenderer from 'ol/renderer/canvas/IntermediateCanvas'; +import MapRenderer from 'ol/renderer/Map'; +import Tile from 'ol/Tile'; +export default class CanvasTileLayerRenderer extends IntermediateCanvasRenderer { + constructor(tileLayer: TileLayer | VectorTileLayer, opt_noContext?: boolean); + protected zDirection: number; + protected context: CanvasRenderingContext2D; + protected renderedRevision: number; + protected renderedTiles: Tile[]; + protected tmpExtent: Extent; + protected getTileImage(tile: Tile): HTMLCanvasElement | HTMLImageElement | HTMLVideoElement; + create(mapRenderer: MapRenderer, layer: Layer): CanvasTileLayerRenderer; + drawTileImage(tile: Tile, frameState: FrameState, layerState: State, x: number, y: number, w: number, h: number, gutter: number, transition: boolean): void; + getLayer(): TileLayer | VectorTileLayer; + getLayer(): Layer; + handles(layer: Layer): boolean; + getTile(z: number, x: number, y: number, pixelRatio: number, projection: Projection): Tile; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/canvas/VectorLayer.d.ts b/types/ol/renderer/canvas/VectorLayer.d.ts new file mode 100644 index 0000000000..47ecf5c27c --- /dev/null +++ b/types/ol/renderer/canvas/VectorLayer.d.ts @@ -0,0 +1,24 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Feature from 'ol/Feature'; +import Layer, { State } from 'ol/layer/Layer'; +import VectorLayer from 'ol/layer/Vector'; +import { FrameState } from 'ol/PluggableMap'; +import CanvasReplayGroup from 'ol/render/canvas/ReplayGroup'; +import CanvasLayerRenderer from 'ol/renderer/canvas/Layer'; +import MapRenderer from 'ol/renderer/Map'; +import Style from 'ol/style/Style'; +export default class CanvasVectorLayerRenderer extends CanvasLayerRenderer { + constructor(vectorLayer: VectorLayer); + create(mapRenderer: MapRenderer, layer: Layer): CanvasVectorLayerRenderer; + handles(layer: Layer): boolean; + compose(context: CanvasRenderingContext2D, frameState: FrameState, layerState: State): void; + handleFontsChanged_(event: Event): void; + renderFeature(feature: Feature, resolution: number, pixelRatio: number, styles: Style | Style[], replayGroup: CanvasReplayGroup): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/canvas/VectorTileLayer.d.ts b/types/ol/renderer/canvas/VectorTileLayer.d.ts new file mode 100644 index 0000000000..c06fbf5c1b --- /dev/null +++ b/types/ol/renderer/canvas/VectorTileLayer.d.ts @@ -0,0 +1,22 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { FeatureLike } from 'ol/Feature'; +import Layer from 'ol/layer/Layer'; +import VectorTileLayer from 'ol/layer/VectorTile'; +import CanvasReplayGroup from 'ol/render/canvas/ReplayGroup'; +import CanvasTileLayerRenderer from 'ol/renderer/canvas/TileLayer'; +import MapRenderer from 'ol/renderer/Map'; +import Style from 'ol/style/Style'; +export default class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer { + constructor(layer: VectorTileLayer); + create(mapRenderer: MapRenderer, layer: Layer): CanvasVectorTileLayerRenderer; + handles(layer: Layer): boolean; + handleFontsChanged_(event: Event): void; + renderFeature(feature: FeatureLike, squaredTolerance: number, styles: Style | Style[], replayGroup: CanvasReplayGroup): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/vector.d.ts b/types/ol/renderer/vector.d.ts new file mode 100644 index 0000000000..80cf748d43 --- /dev/null +++ b/types/ol/renderer/vector.d.ts @@ -0,0 +1,18 @@ +import Event from 'ol/events/Event'; +import Feature, { FeatureLike } from 'ol/Feature'; +import Circle from 'ol/geom/Circle'; +import Geometry from 'ol/geom/Geometry'; +import GeometryCollection from 'ol/geom/GeometryCollection'; +import LineString from 'ol/geom/LineString'; +import MultiLineString from 'ol/geom/MultiLineString'; +import MultiPoint from 'ol/geom/MultiPoint'; +import MultiPolygon from 'ol/geom/MultiPolygon'; +import Point from 'ol/geom/Point'; +import Polygon from 'ol/geom/Polygon'; +import RenderFeature from 'ol/render/Feature'; +import ReplayGroup from 'ol/render/ReplayGroup'; +import Style from 'ol/style/Style'; +export function defaultOrder(feature1: FeatureLike, feature2: FeatureLike): number; +export function getSquaredTolerance(resolution: number, pixelRatio: number): number; +export function getTolerance(resolution: number, pixelRatio: number): number; +export function renderFeature(replayGroup: ReplayGroup, feature: FeatureLike, style: Style, squaredTolerance: number, listener: ((this: T, param1: Event) => void), thisArg: T): boolean; diff --git a/types/ol/renderer/webgl/ImageLayer.d.ts b/types/ol/renderer/webgl/ImageLayer.d.ts new file mode 100644 index 0000000000..789674bd8a --- /dev/null +++ b/types/ol/renderer/webgl/ImageLayer.d.ts @@ -0,0 +1,18 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import ImageLayer from 'ol/layer/Image'; +import Layer from 'ol/layer/Layer'; +import MapRenderer from 'ol/renderer/Map'; +import WebGLLayerRenderer from 'ol/renderer/webgl/Layer'; +import WebGLMapRenderer from 'ol/renderer/webgl/Map'; +export default class WebGLImageLayerRenderer extends WebGLLayerRenderer { + constructor(mapRenderer: WebGLMapRenderer, imageLayer: ImageLayer); + create(mapRenderer: MapRenderer, layer: Layer): WebGLImageLayerRenderer; + handles(layer: Layer): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/webgl/Layer.d.ts b/types/ol/renderer/webgl/Layer.d.ts new file mode 100644 index 0000000000..ddcb6e67ef --- /dev/null +++ b/types/ol/renderer/webgl/Layer.d.ts @@ -0,0 +1,32 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Layer, { State } from 'ol/layer/Layer'; +import { Pixel } from 'ol/pixel'; +import { FrameState } from 'ol/PluggableMap'; +import LayerRenderer from 'ol/renderer/Layer'; +import WebGLMapRenderer from 'ol/renderer/webgl/Map'; +import { Transform } from 'ol/transform'; +import WebGLContext from 'ol/webgl/Context'; +export default class WebGLLayerRenderer extends LayerRenderer { + constructor(mapRenderer: WebGLMapRenderer, layer: Layer); + protected texture: WebGLTexture; + protected texCoordMatrix: Transform; + protected framebuffer: WebGLFramebuffer; + protected framebufferDimension: number; + protected projectionMatrix: Transform; + protected mapRenderer: WebGLMapRenderer; + protected bindFramebuffer(frameState: FrameState, framebufferDimension: number): void; + composeFrame(frameState: FrameState, layerState: State, context: WebGLContext): void; + handleWebGLContextLost(): void; + getTexCoordMatrix(): Transform; + prepareFrame(frameState: FrameState, layerState: State, context: WebGLContext): boolean; + getProjectionMatrix(): Transform; + forEachLayerAtPixel(pixel: Pixel, frameState: FrameState, callback: ((this: S, param1: Layer, param2: Uint8ClampedArray | Uint8Array) => T), thisArg: S): T; + getTexture(): WebGLTexture; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/webgl/Map.d.ts b/types/ol/renderer/webgl/Map.d.ts new file mode 100644 index 0000000000..c0b6ddab98 --- /dev/null +++ b/types/ol/renderer/webgl/Map.d.ts @@ -0,0 +1,24 @@ +import Event from 'ol/events/Event'; +import PluggableMap, { FrameState } from 'ol/PluggableMap'; +import EventType from 'ol/render/EventType'; +import MapRenderer from 'ol/renderer/Map'; +import { Size } from 'ol/size'; +import PriorityQueue from 'ol/structs/PriorityQueue'; +import Tile from 'ol/Tile'; +import WebGLContext from 'ol/webgl/Context'; +export interface TextureCacheEntry { + magFilter: number; + minFilter: number; + texture: WebGLTexture; +} +export default class WebGLMapRenderer extends MapRenderer { + constructor(map: PluggableMap); + protected handleWebGLContextLost(event: Event): void; + protected handleWebGLContextRestored(): void; + bindTileTexture(tile: Tile, tileSize: Size, tileGutter: number, magFilter: number, minFilter: number): void; + dispatchRenderEvent(type: EventType, frameState: FrameState): void; + getContext(): WebGLContext; + getGL(): WebGLRenderingContext; + getTileTextureQueue(): PriorityQueue; + isTileTextureLoaded(tile: Tile): boolean; +} diff --git a/types/ol/renderer/webgl/TileLayer.d.ts b/types/ol/renderer/webgl/TileLayer.d.ts new file mode 100644 index 0000000000..cc5991c8c2 --- /dev/null +++ b/types/ol/renderer/webgl/TileLayer.d.ts @@ -0,0 +1,18 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Layer from 'ol/layer/Layer'; +import TileLayer from 'ol/layer/Tile'; +import MapRenderer from 'ol/renderer/Map'; +import WebGLLayerRenderer from 'ol/renderer/webgl/Layer'; +import WebGLMapRenderer from 'ol/renderer/webgl/Map'; +export default class WebGLTileLayerRenderer extends WebGLLayerRenderer { + constructor(mapRenderer: WebGLMapRenderer, tileLayer: TileLayer); + create(mapRenderer: MapRenderer, layer: Layer): WebGLTileLayerRenderer; + handles(layer: Layer): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/webgl/VectorLayer.d.ts b/types/ol/renderer/webgl/VectorLayer.d.ts new file mode 100644 index 0000000000..8225e9ea9d --- /dev/null +++ b/types/ol/renderer/webgl/VectorLayer.d.ts @@ -0,0 +1,22 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Feature from 'ol/Feature'; +import Layer from 'ol/layer/Layer'; +import VectorLayer from 'ol/layer/Vector'; +import WebGLReplayGroup from 'ol/render/webgl/ReplayGroup'; +import MapRenderer from 'ol/renderer/Map'; +import WebGLLayerRenderer from 'ol/renderer/webgl/Layer'; +import WebGLMapRenderer from 'ol/renderer/webgl/Map'; +import Style from 'ol/style/Style'; +export default class WebGLVectorLayerRenderer extends WebGLLayerRenderer { + constructor(mapRenderer: WebGLMapRenderer, vectorLayer: VectorLayer); + create(mapRenderer: MapRenderer, layer: Layer): WebGLVectorLayerRenderer; + handles(layer: Layer): boolean; + renderFeature(feature: Feature, resolution: number, pixelRatio: number, styles: Style | Style[], replayGroup: WebGLReplayGroup): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/renderer/webgl/defaultmapshader/Locations.d.ts b/types/ol/renderer/webgl/defaultmapshader/Locations.d.ts new file mode 100644 index 0000000000..35d5cd5f85 --- /dev/null +++ b/types/ol/renderer/webgl/defaultmapshader/Locations.d.ts @@ -0,0 +1,3 @@ +export default class Locations { + constructor(gl: WebGLRenderingContext, program: WebGLProgram); +} diff --git a/types/ol/renderer/webgl/defaultmapshader/index.d.ts b/types/ol/renderer/webgl/defaultmapshader/index.d.ts new file mode 100644 index 0000000000..98fac274bf --- /dev/null +++ b/types/ol/renderer/webgl/defaultmapshader/index.d.ts @@ -0,0 +1,4 @@ +import WebGLFragment from 'ol/webgl/Fragment'; +import WebGLVertex from 'ol/webgl/Vertex'; +export const fragment: WebGLFragment; +export const vertex: WebGLVertex; diff --git a/types/ol/renderer/webgl/tilelayershader/Locations.d.ts b/types/ol/renderer/webgl/tilelayershader/Locations.d.ts new file mode 100644 index 0000000000..35d5cd5f85 --- /dev/null +++ b/types/ol/renderer/webgl/tilelayershader/Locations.d.ts @@ -0,0 +1,3 @@ +export default class Locations { + constructor(gl: WebGLRenderingContext, program: WebGLProgram); +} diff --git a/types/ol/renderer/webgl/tilelayershader/index.d.ts b/types/ol/renderer/webgl/tilelayershader/index.d.ts new file mode 100644 index 0000000000..98fac274bf --- /dev/null +++ b/types/ol/renderer/webgl/tilelayershader/index.d.ts @@ -0,0 +1,4 @@ +import WebGLFragment from 'ol/webgl/Fragment'; +import WebGLVertex from 'ol/webgl/Vertex'; +export const fragment: WebGLFragment; +export const vertex: WebGLVertex; diff --git a/types/ol/reproj/Image.d.ts b/types/ol/reproj/Image.d.ts new file mode 100644 index 0000000000..bddb7d2bf6 --- /dev/null +++ b/types/ol/reproj/Image.d.ts @@ -0,0 +1,8 @@ +import { Extent } from 'ol/extent'; +import ImageBase from 'ol/ImageBase'; +import Projection from 'ol/proj/Projection'; +export type FunctionType = (() => void); +export default class ReprojImage extends ImageBase { + constructor(sourceProj: Projection, targetProj: Projection, targetExtent: Extent, targetResolution: number, pixelRatio: number, getImageFunction: FunctionType); + getProjection(): Projection; +} diff --git a/types/ol/reproj/Tile.d.ts b/types/ol/reproj/Tile.d.ts new file mode 100644 index 0000000000..03e2c462e3 --- /dev/null +++ b/types/ol/reproj/Tile.d.ts @@ -0,0 +1,9 @@ +import Projection from 'ol/proj/Projection'; +import Tile from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export type FunctionType = (() => void); +export default class ReprojTile extends Tile { + constructor(sourceProj: Projection, sourceTileGrid: TileGrid, targetProj: Projection, targetTileGrid: TileGrid, tileCoord: TileCoord, wrappedTileCoord: TileCoord, pixelRatio: number, gutter: number, getTileFunction: FunctionType, opt_errorThreshold?: number, opt_renderEdges?: boolean); + getImage(): HTMLCanvasElement; +} diff --git a/types/ol/reproj/Triangulation.d.ts b/types/ol/reproj/Triangulation.d.ts new file mode 100644 index 0000000000..027b2f242d --- /dev/null +++ b/types/ol/reproj/Triangulation.d.ts @@ -0,0 +1,12 @@ +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import Projection from 'ol/proj/Projection'; +export interface Triangle { + source: Coordinate[]; + target: Coordinate[]; +} +export default class Triangulation { + constructor(sourceProj: Projection, targetProj: Projection, targetExtent: Extent, maxSourceExtent: Extent, errorThreshold: number); + calculateSourceExtent(): Extent; + getTriangles(): Triangle[]; +} diff --git a/types/ol/reproj/common.d.ts b/types/ol/reproj/common.d.ts new file mode 100644 index 0000000000..514988bd04 --- /dev/null +++ b/types/ol/reproj/common.d.ts @@ -0,0 +1,2 @@ +export const ENABLE_RASTER_REPROJECTION: boolean; +export const ERROR_THRESHOLD: number; diff --git a/types/ol/reproj/index.d.ts b/types/ol/reproj/index.d.ts new file mode 100644 index 0000000000..e0f85df5ee --- /dev/null +++ b/types/ol/reproj/index.d.ts @@ -0,0 +1,6 @@ +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import Projection from 'ol/proj/Projection'; +import Triangulation from 'ol/reproj/Triangulation'; +export function calculateSourceResolution(sourceProj: Projection, targetProj: Projection, targetCenter: Coordinate, targetResolution: number): number; +export function render(width: number, height: number, pixelRatio: number, sourceResolution: number, sourceExtent: Extent, targetResolution: number, targetExtent: Extent, triangulation: Triangulation, sources: any[], gutter: number, opt_renderEdges?: boolean): HTMLCanvasElement; diff --git a/types/ol/resolutionconstraint.d.ts b/types/ol/resolutionconstraint.d.ts new file mode 100644 index 0000000000..2cf89c1812 --- /dev/null +++ b/types/ol/resolutionconstraint.d.ts @@ -0,0 +1,3 @@ +export function createSnapToPower(power: number, maxResolution: number, opt_maxLevel?: number): Type; +export function createSnapToResolutions(resolutions: number[]): Type; +export type Type = ((param0: number, param1: number, param2: number) => number); diff --git a/types/ol/rotationconstraint.d.ts b/types/ol/rotationconstraint.d.ts new file mode 100644 index 0000000000..79210d0d45 --- /dev/null +++ b/types/ol/rotationconstraint.d.ts @@ -0,0 +1,5 @@ +export function createSnapToN(n: number): Type; +export function createSnapToZero(opt_tolerance?: number): Type; +export function disable(rotation: number, delta: number): number; +export function none(rotation: number, delta: number): number; +export type Type = ((param0: number, param1: number) => number); diff --git a/types/ol/size.d.ts b/types/ol/size.d.ts new file mode 100644 index 0000000000..73f76b34f3 --- /dev/null +++ b/types/ol/size.d.ts @@ -0,0 +1,5 @@ +export function buffer(size: Size, num: number, opt_size?: Size): Size; +export function hasArea(size: Size): boolean; +export function scale(size: Size, ratio: number, opt_size?: Size): Size; +export function toSize(size: number | Size, opt_size?: Size): Size; +export type Size = number[]; diff --git a/types/ol/source/BingMaps.d.ts b/types/ol/source/BingMaps.d.ts index 963623bc7e..cd64984909 100644 --- a/types/ol/source/BingMaps.d.ts +++ b/types/ol/source/BingMaps.d.ts @@ -1,3 +1,69 @@ -import * as ol from 'openlayers'; - -export default ol.source.BingMaps; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { TileSourceEvent } from 'ol/source/Tile'; +import TileImage from 'ol/source/TileImage'; +import { LoadFunction } from 'ol/Tile'; +export default class BingMaps extends TileImage { + constructor(options: Options); + getApiKey(): string; + getImagerySet(): string; + handleImageryMetadataResponse(response: BingMapsImageryMetadataResponse): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} +export interface BingMapsImageryMetadataResponse { + statusCode: number; + statusDescription: string; + authenticationResultCode: string; + resourceSets: ResourceSet[]; +} +export interface CoverageArea { + zoomMin: number; + zoomMax: number; + bbox: number[]; +} +export interface ImageryProvider { + coverageAreas: CoverageArea[]; + attribution?: string; +} +export interface Options { + cacheSize?: number; + hidpi?: boolean; + culture?: string; + key: string; + imagerySet: string; + maxZoom?: number; + reprojectionErrorThreshold?: number; + tileLoadFunction?: LoadFunction; + wrapX?: boolean; + transition?: number; +} +export interface Resource { + imageHeight: number; + imageWidth: number; + zoomMin: number; + zoomMax: number; + imageUrl: string; + imageUrlSubdomains: string[]; + imageryProviders?: ImageryProvider[]; +} +export interface ResourceSet { + resources: Resource[]; +} diff --git a/types/ol/source/CartoDB.d.ts b/types/ol/source/CartoDB.d.ts index 28b44ebc4c..24561b7eb6 100644 --- a/types/ol/source/CartoDB.d.ts +++ b/types/ol/source/CartoDB.d.ts @@ -1,3 +1,47 @@ -import * as ol from 'openlayers'; - -export default ol.source.CartoDB; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import { AttributionLike } from 'ol/source/Source'; +import { TileSourceEvent } from 'ol/source/Tile'; +import XYZ from 'ol/source/XYZ'; +export default class CartoDB extends XYZ { + constructor(options: Options); + getConfig(): { [key: string]: any }; + setConfig(config: { [key: string]: any }): void; + updateConfig(config: { [key: string]: any }): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} +export interface CartoDBLayerInfo { + layergroupid: string; + cdn_url: { [key: string]: any }; +} +export interface Options { + attributions?: AttributionLike; + cacheSize?: number; + crossOrigin?: string; + projection?: ProjectionLike; + maxZoom?: number; + minZoom?: number; + wrapX?: boolean; + config?: { [key: string]: any }; + map?: string; + account: string; +} diff --git a/types/ol/source/Cluster.d.ts b/types/ol/source/Cluster.d.ts index 0a793ed0b2..45e37ce9c0 100644 --- a/types/ol/source/Cluster.d.ts +++ b/types/ol/source/Cluster.d.ts @@ -1,3 +1,48 @@ -import * as ol from 'openlayers'; - -export default ol.source.Cluster; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Feature from 'ol/Feature'; +import Point from 'ol/geom/Point'; +import { ObjectEvent } from 'ol/Object'; +import { AttributionLike } from 'ol/source/Source'; +import VectorSource, { VectorSourceEvent } from 'ol/source/Vector'; +export default class Cluster extends VectorSource { + constructor(options: Options); + protected distance: number; + protected features: Feature[]; + protected geometryFunction: ((param0: Feature) => Point); + protected resolution: number; + protected source: VectorSource; + protected cluster(): void; + protected createCluster(features: Feature[]): Feature; + getDistance(): number; + getSource(): VectorSource; + setDistance(distance: number): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'addfeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + once(type: 'addfeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + un(type: 'addfeature', listener: (evt: VectorSourceEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'changefeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + once(type: 'changefeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + un(type: 'changefeature', listener: (evt: VectorSourceEvent) => void): void; + on(type: 'clear', listener: (evt: VectorSourceEvent) => void): EventsKey; + once(type: 'clear', listener: (evt: VectorSourceEvent) => void): EventsKey; + un(type: 'clear', listener: (evt: VectorSourceEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'removefeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + once(type: 'removefeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + un(type: 'removefeature', listener: (evt: VectorSourceEvent) => void): void; +} +export interface Options { + attributions?: AttributionLike; + distance?: number; + geometryFunction?: ((param0: Feature) => Point); + source: VectorSource; + wrapX?: boolean; +} diff --git a/types/ol/source/Image.d.ts b/types/ol/source/Image.d.ts index 82071b1636..21c047a3de 100644 --- a/types/ol/source/Image.d.ts +++ b/types/ol/source/Image.d.ts @@ -1,3 +1,42 @@ -import * as ol from 'openlayers'; - -export default ol.source.Image; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import ImageWrapper from 'ol/Image'; +import ImageBase from 'ol/ImageBase'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import Source, { AttributionLike } from 'ol/source/Source'; +import State from 'ol/source/State'; +export function defaultImageLoadFunction(image: ImageWrapper, src: string): void; +export default class ImageSource extends Source { + constructor(options: Options); + protected findNearestResolution(resolution: number): number; + protected getImageInternal(extent: Extent, resolution: number, pixelRatio: number, projection: Projection): ImageBase; + protected handleImageChange(event: Event): void; + getImage(extent: Extent, resolution: number, pixelRatio: number, projection: Projection): ImageBase; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export class ImageSourceEvent extends Event { + constructor(type: string, image: ImageWrapper); + image: ImageWrapper; +} +export enum ImageSourceEventType { + IMAGELOADSTART = 'imageloadstart', + IMAGELOADEND = 'imageloadend', + IMAGELOADERROR = 'imageloaderror', +} +export interface Options { + attributions?: AttributionLike; + projection?: ProjectionLike; + resolutions?: number[]; + state?: State; +} diff --git a/types/ol/source/ImageArcGISRest.d.ts b/types/ol/source/ImageArcGISRest.d.ts index ae296156cd..3ae16e822e 100644 --- a/types/ol/source/ImageArcGISRest.d.ts +++ b/types/ol/source/ImageArcGISRest.d.ts @@ -1,3 +1,45 @@ -import * as ol from 'openlayers'; - -export default ol.source.ImageArcGISRest; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { LoadFunction } from 'ol/Image'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import ImageSource, { ImageSourceEvent } from 'ol/source/Image'; +import { AttributionLike } from 'ol/source/Source'; +export default class ImageArcGISRest extends ImageSource { + constructor(opt_options?: Options); + getImageLoadFunction(): LoadFunction; + getParams(): { [key: string]: any }; + getUrl(): string; + setImageLoadFunction(imageLoadFunction: LoadFunction): void; + setUrl(url: string): void; + updateParams(params: { [key: string]: any }): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + attributions?: AttributionLike; + crossOrigin?: string; + hidpi?: boolean; + imageLoadFunction?: LoadFunction; + params?: { [key: string]: any }; + projection?: ProjectionLike; + ratio?: number; + resolutions?: number[]; + url?: string; +} diff --git a/types/ol/source/ImageCanvas.d.ts b/types/ol/source/ImageCanvas.d.ts index cbfee5d9d5..8b8c214d2b 100644 --- a/types/ol/source/ImageCanvas.d.ts +++ b/types/ol/source/ImageCanvas.d.ts @@ -1,3 +1,32 @@ -import * as ol from 'openlayers'; - -export default ol.source.ImageCanvas; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import ImageCanvas from 'ol/ImageCanvas'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import { Size } from 'ol/size'; +import ImageSource from 'ol/source/Image'; +import { AttributionLike } from 'ol/source/Source'; +import State from 'ol/source/State'; +export type FunctionType = ((this: ImageCanvas, param1: Extent, param2: number, param3: number, param4: Size, param5: Projection) => HTMLCanvasElement); +export default class ImageCanvasSource extends ImageSource { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + attributions?: AttributionLike; + canvasFunction?: FunctionType; + projection?: ProjectionLike; + ratio?: number; + resolutions?: number[]; + state?: State; +} diff --git a/types/ol/source/ImageMapGuide.d.ts b/types/ol/source/ImageMapGuide.d.ts index 42877b1052..0341875cd3 100644 --- a/types/ol/source/ImageMapGuide.d.ts +++ b/types/ol/source/ImageMapGuide.d.ts @@ -1,3 +1,48 @@ -import * as ol from 'openlayers'; - -export default ol.source.ImageMapGuide; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import { LoadFunction } from 'ol/Image'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import { Size } from 'ol/size'; +import ImageSource, { ImageSourceEvent } from 'ol/source/Image'; +export default class ImageMapGuide extends ImageSource { + constructor(options: Options); + getImageLoadFunction(): LoadFunction; + getParams(): { [key: string]: any }; + getUrl(baseUrl: string, params: { [key: string]: any }, extent: Extent, size: Size, projection: Projection): string; + setImageLoadFunction(imageLoadFunction: LoadFunction): void; + updateParams(params: { [key: string]: any }): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + url?: string; + crossOrigin?: string; + displayDpi?: number; + metersPerUnit?: number; + hidpi?: boolean; + useOverlay?: boolean; + projection?: ProjectionLike; + ratio?: number; + resolutions?: number[]; + imageLoadFunction?: LoadFunction; + params?: { [key: string]: any }; +} diff --git a/types/ol/source/ImageStatic.d.ts b/types/ol/source/ImageStatic.d.ts index 02a6d37e50..28e90147ea 100644 --- a/types/ol/source/ImageStatic.d.ts +++ b/types/ol/source/ImageStatic.d.ts @@ -1,3 +1,32 @@ -import * as ol from 'openlayers'; - -export default ol.source.ImageStatic; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import { LoadFunction } from 'ol/Image'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import { Size } from 'ol/size'; +import ImageSource from 'ol/source/Image'; +import { AttributionLike } from 'ol/source/Source'; +export interface Options { + attributions?: AttributionLike; + crossOrigin?: string; + imageExtent?: Extent; + imageLoadFunction?: LoadFunction; + projection?: ProjectionLike; + imageSize?: Size; + url: string; +} +export default class Static extends ImageSource { + constructor(options: Options); + getImageExtent(): Extent; + getUrl(): string; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/source/ImageVector.d.ts b/types/ol/source/ImageVector.d.ts deleted file mode 100644 index 2f1ae17a2d..0000000000 --- a/types/ol/source/ImageVector.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.source.ImageVector; diff --git a/types/ol/source/ImageWMS.d.ts b/types/ol/source/ImageWMS.d.ts index 0aeb5fb39c..2d73445531 100644 --- a/types/ol/source/ImageWMS.d.ts +++ b/types/ol/source/ImageWMS.d.ts @@ -1,3 +1,49 @@ -import * as ol from 'openlayers'; - -export default ol.source.ImageWMS; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { LoadFunction } from 'ol/Image'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import ImageSource, { ImageSourceEvent } from 'ol/source/Image'; +import { AttributionLike } from 'ol/source/Source'; +import WMSServerType from 'ol/source/WMSServerType'; +export default class ImageWMS extends ImageSource { + constructor(opt_options?: Options); + getGetFeatureInfoUrl(coordinate: Coordinate, resolution: number, projection: ProjectionLike, params: { [key: string]: any }): string; + getImageLoadFunction(): LoadFunction; + getParams(): { [key: string]: any }; + getUrl(): string; + setImageLoadFunction(imageLoadFunction: LoadFunction): void; + setUrl(url: string): void; + updateParams(params: { [key: string]: any }): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloadend', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloaderror', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): EventsKey; + once(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): EventsKey; + un(type: 'imageloadstart', listener: (evt: ImageSourceEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface Options { + attributions?: AttributionLike; + crossOrigin?: string; + hidpi?: boolean; + serverType?: WMSServerType | string; + imageLoadFunction?: LoadFunction; + params: { [key: string]: any }; + projection?: ProjectionLike; + ratio?: number; + resolutions?: number[]; + url: string; +} diff --git a/types/ol/source/OSM.d.ts b/types/ol/source/OSM.d.ts index 68b03db843..9ede80c336 100644 --- a/types/ol/source/OSM.d.ts +++ b/types/ol/source/OSM.d.ts @@ -1,3 +1,40 @@ -import * as ol from 'openlayers'; - -export default ol.source.OSM; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { AttributionLike } from 'ol/source/Source'; +import { TileSourceEvent } from 'ol/source/Tile'; +import XYZ from 'ol/source/XYZ'; +import { LoadFunction } from 'ol/Tile'; +export const ATTRIBUTION: string; +export interface Options { + attributions?: AttributionLike; + cacheSize?: number; + crossOrigin?: string; + maxZoom?: number; + opaque?: boolean; + reprojectionErrorThreshold?: number; + tileLoadFunction?: LoadFunction; + url?: string; + wrapX?: boolean; +} +export default class OSM extends XYZ { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/Raster.d.ts b/types/ol/source/Raster.d.ts index de39ec8fce..30c9183748 100644 --- a/types/ol/source/Raster.d.ts +++ b/types/ol/source/Raster.d.ts @@ -1,3 +1,43 @@ -import * as ol from 'openlayers'; - -export default ol.source.Raster; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Layer, { State } from 'ol/layer/Layer'; +import { ObjectEvent } from 'ol/Object'; +import { FrameState } from 'ol/PluggableMap'; +import CanvasLayerRenderer from 'ol/renderer/canvas/Layer'; +import ImageSource from 'ol/source/Image'; +import Source from 'ol/source/Source'; +import TileSource from 'ol/source/Tile'; +export type Operation = ((param0: number[][] | ImageData[], param1: { [key: string]: any }) => number[] | ImageData); +export interface Options { + sources: any[]; + operation?: Operation; + lib?: { [key: string]: any }; + threads?: number; + operationType?: 'pixel' | 'image'; +} +export default class RasterSource extends ImageSource { + constructor(options: Options); + setOperation(operation: Operation, opt_lib?: { [key: string]: any }): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'afteroperations', listener: (evt: RasterSourceEvent) => void): EventsKey; + once(type: 'afteroperations', listener: (evt: RasterSourceEvent) => void): EventsKey; + un(type: 'afteroperations', listener: (evt: RasterSourceEvent) => void): void; + on(type: 'beforeoperations', listener: (evt: RasterSourceEvent) => void): EventsKey; + once(type: 'beforeoperations', listener: (evt: RasterSourceEvent) => void): EventsKey; + un(type: 'beforeoperations', listener: (evt: RasterSourceEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export class RasterSourceEvent extends Event { + constructor(type: string, frameState: FrameState, data: { [key: string]: any }); + data: { [key: string]: any }; + extent: Extent; + resolution: number; +} diff --git a/types/ol/source/Source.d.ts b/types/ol/source/Source.d.ts index 379f73e579..fef30d9fa6 100644 --- a/types/ol/source/Source.d.ts +++ b/types/ol/source/Source.d.ts @@ -1,3 +1,37 @@ -import * as ol from 'openlayers'; - -export default ol.source.Source; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import BaseObject, { ObjectEvent } from 'ol/Object'; +import { FrameState } from 'ol/PluggableMap'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import State from 'ol/source/State'; +export type Attribution = ((param0: FrameState) => string | string[]); +export type AttributionLike = string | string[] | Attribution; +export interface Options { + attributions?: AttributionLike; + attributionsCollapsible?: boolean; + projection?: ProjectionLike; + state?: State; + wrapX?: boolean; +} +export default class Source extends BaseObject { + constructor(options: Options); + protected setState(state: State): void; + getAttributions(): Attribution; + getAttributionsCollapsible(): boolean; + getProjection(): Projection; + getResolutions(): number[]; + getState(): State; + getWrapX(): boolean; + refresh(): void; + setAttributions(attributions: AttributionLike): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/source/Stamen.d.ts b/types/ol/source/Stamen.d.ts index 51d6d42006..8f4750703a 100644 --- a/types/ol/source/Stamen.d.ts +++ b/types/ol/source/Stamen.d.ts @@ -1,3 +1,37 @@ -import * as ol from 'openlayers'; - -export default ol.source.Stamen; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { TileSourceEvent } from 'ol/source/Tile'; +import XYZ from 'ol/source/XYZ'; +import { LoadFunction } from 'ol/Tile'; +export interface Options { + cacheSize?: number; + layer: string; + minZoom?: number; + maxZoom?: number; + reprojectionErrorThreshold?: number; + tileLoadFunction?: LoadFunction; + url?: string; + wrapX?: boolean; +} +export default class Stamen extends XYZ { + constructor(options: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/State.d.ts b/types/ol/source/State.d.ts new file mode 100644 index 0000000000..192381b677 --- /dev/null +++ b/types/ol/source/State.d.ts @@ -0,0 +1,8 @@ +declare enum State { + UNDEFINED = 'undefined', + LOADING = 'loading', + READY = 'ready', + ERROR = 'error', +} + +export default State; diff --git a/types/ol/source/Tile.d.ts b/types/ol/source/Tile.d.ts index 7c7cb3d874..158e13eb91 100644 --- a/types/ol/source/Tile.d.ts +++ b/types/ol/source/Tile.d.ts @@ -1,3 +1,61 @@ -import * as ol from 'openlayers'; - -export default ol.source.Tile; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import { Size } from 'ol/size'; +import Source, { AttributionLike } from 'ol/source/Source'; +import State from 'ol/source/State'; +import Tile, { Options as Options_1 } from 'ol/Tile'; +import TileCache from 'ol/TileCache'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +import TileRange from 'ol/TileRange'; +export class TileSourceEvent extends Event { + constructor(); + tile: Tile; +} +export interface Options { + attributions?: AttributionLike; + attributionsCollapsible?: boolean; + cacheSize?: number; + opaque?: boolean; + tilePixelRatio?: number; + projection?: ProjectionLike; + state?: State; + tileGrid?: TileGrid; + wrapX?: boolean; + transition?: number; + key?: string; +} +export default class TileSource extends Source { + constructor(options: Options); + protected tileCache: TileCache; + protected tileGrid: TileGrid; + protected tileOptions: Options_1; + protected tmpSize: Size; + protected getKey(): string; + protected getTileCacheForProjection(projection: Projection): TileCache; + protected setKey(key: string): void; + getTileGrid(): TileGrid; + getTileCoordForTileUrlFunction(tileCoord: TileCoord, opt_projection?: Projection): TileCoord; + expireCache(projection: Projection, usedTiles: { [key: string]: TileRange }): void; + getTileGridForProjection(projection: Projection): TileGrid; + getTilePixelRatio(pixelRatio: number): number; + getTilePixelSize(z: number, pixelRatio: number, projection: Projection): Size; + getGutterForProjection(projection: Projection): number; + canExpireCache(): boolean; + getOpaque(projection: Projection): boolean; + getTile(z: number, x: number, y: number, pixelRatio: number, projection: Projection): Tile; + forEachLoadedTile(projection: Projection, z: number, tileRange: TileRange, callback: ((param0: Tile) => boolean | void)): boolean; + useTile(z: number, x: number, y: number, projection: Projection): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/source/TileArcGISRest.d.ts b/types/ol/source/TileArcGISRest.d.ts index 45f7f529ff..7d81d6faa7 100644 --- a/types/ol/source/TileArcGISRest.d.ts +++ b/types/ol/source/TileArcGISRest.d.ts @@ -1,3 +1,48 @@ -import * as ol from 'openlayers'; - -export default ol.source.TileArcGISRest; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import { AttributionLike } from 'ol/source/Source'; +import { TileSourceEvent } from 'ol/source/Tile'; +import TileImage from 'ol/source/TileImage'; +import { LoadFunction } from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export interface Options { + attributions?: AttributionLike; + cacheSize?: number; + crossOrigin?: string; + params?: { [key: string]: any }; + tileGrid?: TileGrid; + projection?: ProjectionLike; + reprojectionErrorThreshold?: number; + tileLoadFunction?: LoadFunction; + url?: string; + wrapX?: boolean; + transition?: number; + urls: string[]; +} +export default class TileArcGISRest extends TileImage { + constructor(opt_options?: Options); + getParams(): { [key: string]: any }; + updateParams(params: { [key: string]: any }): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/TileDebug.d.ts b/types/ol/source/TileDebug.d.ts index f09371a620..613742f6a7 100644 --- a/types/ol/source/TileDebug.d.ts +++ b/types/ol/source/TileDebug.d.ts @@ -1,3 +1,26 @@ -import * as ol from 'openlayers'; - -export default ol.source.TileDebug; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import { Size } from 'ol/size'; +import TileSource from 'ol/source/Tile'; +import Tile from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export interface Options { + projection?: ProjectionLike; + tileGrid?: TileGrid; + wrapX?: boolean; +} +export default class TileDebug extends TileSource { + constructor(options: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} diff --git a/types/ol/source/TileEventType.d.ts b/types/ol/source/TileEventType.d.ts new file mode 100644 index 0000000000..3947e9f315 --- /dev/null +++ b/types/ol/source/TileEventType.d.ts @@ -0,0 +1,7 @@ +declare enum TileEventType { + TILELOADSTART = 'tileloadstart', + TILELOADEND = 'tileloadend', + TILELOADERROR = 'tileloaderror', +} + +export default TileEventType; diff --git a/types/ol/source/TileImage.d.ts b/types/ol/source/TileImage.d.ts index bd3bf922b4..fb3d9dac7e 100644 --- a/types/ol/source/TileImage.d.ts +++ b/types/ol/source/TileImage.d.ts @@ -1,3 +1,62 @@ -import * as ol from 'openlayers'; - -export default ol.source.TileImage; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import ImageTile from 'ol/ImageTile'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import { AttributionLike } from 'ol/source/Source'; +import State from 'ol/source/State'; +import { TileSourceEvent } from 'ol/source/Tile'; +import UrlTile from 'ol/source/UrlTile'; +import Tile, { LoadFunction, UrlFunction } from 'ol/Tile'; +import TileCache from 'ol/TileCache'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export interface Options { + attributions?: AttributionLike; + attributionsCollapsible?: boolean; + cacheSize?: number; + crossOrigin?: string; + opaque?: boolean; + projection?: ProjectionLike; + reprojectionErrorThreshold?: number; + state?: State; + tileClass?: ImageTile; + tileGrid?: TileGrid; + tileLoadFunction?: LoadFunction; + tilePixelRatio?: number; + tileUrlFunction?: UrlFunction; + url?: string; + urls?: string[]; + wrapX?: boolean; + transition?: number; + key?: string; +} +export default class TileImage extends UrlTile { + constructor(options: Options); + protected crossOrigin: string; + protected tileCacheForProjection: { [key: string]: TileCache }; + protected tileClass: ImageTile; + protected tileGridForProjection: { [key: string]: TileGrid }; + protected getTileInternal(z: number, x: number, y: number, pixelRatio: number, projection: Projection): Tile; + getGutter(): number; + setRenderReprojectionEdges(render: boolean): void; + setTileGridForProjection(projection: ProjectionLike, tilegrid: TileGrid): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/TileJSON.d.ts b/types/ol/source/TileJSON.d.ts index c9d52d2903..726dd13c6c 100644 --- a/types/ol/source/TileJSON.d.ts +++ b/types/ol/source/TileJSON.d.ts @@ -1,3 +1,58 @@ -import * as ol from 'openlayers'; - -export default ol.source.TileJSON; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { AttributionLike } from 'ol/source/Source'; +import { TileSourceEvent } from 'ol/source/Tile'; +import TileImage from 'ol/source/TileImage'; +import { LoadFunction } from 'ol/Tile'; +export interface Config { + name?: string; + description?: string; + version?: string; + attribution?: string; + template?: string; + legend?: string; + scheme?: string; + tiles: string[]; + grids?: string[]; + minzoom?: number; + maxzoom?: number; + bounds?: number[]; + center?: number[]; +} +export interface Options { + attributions?: AttributionLike; + cacheSize?: number; + crossOrigin?: string; + jsonp?: boolean; + reprojectionErrorThreshold?: number; + tileJSON?: Config; + tileLoadFunction?: LoadFunction; + url?: string; + wrapX?: boolean; + transition?: number; +} +export default class TileJSON extends TileImage { + constructor(options: Options); + protected handleTileJSONError(): void; + protected handleTileJSONResponse(tileJSON: Config): void; + getTileJSON(): Config; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/TileUTFGrid.d.ts b/types/ol/source/TileUTFGrid.d.ts deleted file mode 100644 index 17ae2022a2..0000000000 --- a/types/ol/source/TileUTFGrid.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.source.TileUTFGrid; diff --git a/types/ol/source/TileWMS.d.ts b/types/ol/source/TileWMS.d.ts index 7ae163f2c5..ea30f49a19 100644 --- a/types/ol/source/TileWMS.d.ts +++ b/types/ol/source/TileWMS.d.ts @@ -1,3 +1,56 @@ -import * as ol from 'openlayers'; - -export default ol.source.TileWMS; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import ImageTile from 'ol/ImageTile'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import { AttributionLike } from 'ol/source/Source'; +import { TileSourceEvent } from 'ol/source/Tile'; +import TileImage from 'ol/source/TileImage'; +import WMSServerType from 'ol/source/WMSServerType'; +import { LoadFunction } from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export interface Options { + attributions?: AttributionLike; + cacheSize?: number; + crossOrigin?: string; + params: { [key: string]: any }; + gutter?: number; + hidpi?: boolean; + projection?: ProjectionLike; + reprojectionErrorThreshold?: number; + tileClass?: ImageTile; + tileGrid?: TileGrid; + serverType?: WMSServerType | string; + tileLoadFunction?: LoadFunction; + url?: string; + urls?: string[]; + wrapX?: boolean; + transition?: number; +} +export default class TileWMS extends TileImage { + constructor(opt_options?: Options); + getGetFeatureInfoUrl(coordinate: Coordinate, resolution: number, projection: ProjectionLike, params: { [key: string]: any }): string; + getParams(): { [key: string]: any }; + updateParams(params: { [key: string]: any }): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/UTFGrid.d.ts b/types/ol/source/UTFGrid.d.ts new file mode 100644 index 0000000000..7959131874 --- /dev/null +++ b/types/ol/source/UTFGrid.d.ts @@ -0,0 +1,43 @@ +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import { ObjectEvent } from 'ol/Object'; +import TileSource from 'ol/source/Tile'; +import { Config } from 'ol/source/TileJSON'; +import Tile from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileState from 'ol/TileState'; +export class CustomTile extends Tile { + constructor(tileCoord: TileCoord, state: TileState, src: string, extent: Extent, preemptive: boolean, jsonp: boolean); + forDataAtCoordinate(coordinate: Coordinate, callback: ((this: T, param1: any) => void), opt_this?: T, opt_request?: boolean): void; + getData(coordinate: Coordinate): any; + getImage(): HTMLImageElement; +} +export interface Options { + preemptive?: boolean; + jsonp?: boolean; + tileJSON?: Config; + url?: string; +} +export default class UTFGrid extends TileSource { + constructor(options: Options); + protected handleTileJSONError(): void; + protected handleTileJSONResponse(tileJSON: Config): void; + forDataAtCoordinateAndResolution(coordinate: Coordinate, resolution: number, callback: ((param0: any) => void), opt_request?: boolean): void; + getTemplate(): string; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; +} +export interface UTFGridJSON { + grid: string[]; + keys: string[]; + data?: { [key: string]: { [key: string]: any } }; +} diff --git a/types/ol/source/UrlTile.d.ts b/types/ol/source/UrlTile.d.ts index 606583cac4..2a31e45687 100644 --- a/types/ol/source/UrlTile.d.ts +++ b/types/ol/source/UrlTile.d.ts @@ -1,3 +1,58 @@ -import * as ol from 'openlayers'; - -export default ol.source.UrlTile; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import { AttributionLike } from 'ol/source/Source'; +import State from 'ol/source/State'; +import TileSource, { TileSourceEvent } from 'ol/source/Tile'; +import { LoadFunction, UrlFunction } from 'ol/Tile'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export interface Options { + attributions?: AttributionLike; + attributionsCollapsible?: boolean; + cacheSize?: number; + opaque?: boolean; + projection?: ProjectionLike; + state?: State; + tileGrid?: TileGrid; + tileLoadFunction: LoadFunction; + tilePixelRatio?: number; + tileUrlFunction?: UrlFunction; + url?: string; + urls?: string[]; + wrapX?: boolean; + transition?: number; + key?: string; +} +export default class UrlTile extends TileSource { + constructor(options: Options); + protected urls: string[]; + protected tileLoadFunction: LoadFunction; + protected tileUrlFunction: UrlFunction; + protected handleTileChange(event: Event): void; + setTileLoadFunction(tileLoadFunction: LoadFunction): void; + getTileUrlFunction(): UrlFunction; + setUrl(url: string): void; + setUrls(urls: string[]): void; + getUrls(): string[]; + getTileLoadFunction(): LoadFunction; + setTileUrlFunction(tileUrlFunction: UrlFunction, key?: string): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/source/Vector.d.ts b/types/ol/source/Vector.d.ts index ee2d968d28..d694dc3a55 100644 --- a/types/ol/source/Vector.d.ts +++ b/types/ol/source/Vector.d.ts @@ -1,3 +1,77 @@ -import * as ol from 'openlayers'; - -export default ol.source.Vector; +import Collection from 'ol/Collection'; +import { Coordinate } from 'ol/coordinate'; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import Feature from 'ol/Feature'; +import { FeatureLoader, FeatureUrlFunction } from 'ol/featureloader'; +import FeatureFormat from 'ol/format/Feature'; +import { ObjectEvent } from 'ol/Object'; +import Projection from 'ol/proj/Projection'; +import Source, { AttributionLike } from 'ol/source/Source'; +export class VectorSourceEvent extends Event { + constructor(); + feature: Feature; +} +export type LoadingStrategy = ((param0: Extent, param1: number) => Extent[]); +export interface Options { + attributions?: AttributionLike; + features?: Feature[] | Collection; + format?: FeatureFormat; + loader?: FeatureLoader; + overlaps?: boolean; + strategy?: LoadingStrategy; + url?: string | FeatureUrlFunction; + useSpatialIndex?: boolean; + wrapX?: boolean; +} +export default class VectorSource extends Source { + constructor(opt_options?: Options); + protected addFeaturesInternal(features: Feature[]): void; + protected addFeatureInternal(feature: Feature): void; + protected removeFeatureInternal(feature: Feature): void; + getFeaturesAtCoordinate(coordinate: Coordinate): Feature[]; + clear(opt_fast?: boolean): void; + forEachFeature(callback: ((param0: Feature) => T)): T; + forEachFeatureAtCoordinateDirect(coordinate: Coordinate, callback: ((param0: Feature) => T)): T; + forEachFeatureInExtent(extent: Extent, callback: ((param0: Feature) => T)): T; + forEachFeatureIntersectingExtent(extent: Extent, callback: ((param0: Feature) => T)): T; + getClosestFeatureToCoordinate(coordinate: Coordinate, opt_filter?: (() => void)): Feature; + getExtent(opt_extent?: Extent): Extent; + getFeatureById(id: string | number): Feature; + getFeatures(): Feature[]; + addFeatures(features: Feature[]): void; + getFeaturesCollection(): Collection; + getFeaturesInExtent(extent: Extent): Feature[]; + getFormat(): FeatureFormat; + getOverlaps(): boolean; + getUrl(): string | FeatureUrlFunction; + hasFeature(feature: Feature): boolean; + isEmpty(): boolean; + loadFeatures(extent: Extent, resolution: number, projection: Projection): void; + removeFeature(feature: Feature): void; + addFeature(feature: Feature): void; + removeLoadedExtent(extent: Extent): void; + setLoader(loader: FeatureLoader): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'addfeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + once(type: 'addfeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + un(type: 'addfeature', listener: (evt: VectorSourceEvent) => void): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'changefeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + once(type: 'changefeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + un(type: 'changefeature', listener: (evt: VectorSourceEvent) => void): void; + on(type: 'clear', listener: (evt: VectorSourceEvent) => void): EventsKey; + once(type: 'clear', listener: (evt: VectorSourceEvent) => void): EventsKey; + un(type: 'clear', listener: (evt: VectorSourceEvent) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'removefeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + once(type: 'removefeature', listener: (evt: VectorSourceEvent) => void): EventsKey; + un(type: 'removefeature', listener: (evt: VectorSourceEvent) => void): void; +} diff --git a/types/ol/source/VectorEventType.d.ts b/types/ol/source/VectorEventType.d.ts new file mode 100644 index 0000000000..311456808b --- /dev/null +++ b/types/ol/source/VectorEventType.d.ts @@ -0,0 +1,8 @@ +declare enum VectorEventType { + ADDFEATURE = 'addfeature', + CHANGEFEATURE = 'changefeature', + CLEAR = 'clear', + REMOVEFEATURE = 'removefeature', +} + +export default VectorEventType; diff --git a/types/ol/source/VectorTile.d.ts b/types/ol/source/VectorTile.d.ts index 1aa59678d3..2114b41516 100644 --- a/types/ol/source/VectorTile.d.ts +++ b/types/ol/source/VectorTile.d.ts @@ -1,3 +1,58 @@ -import * as ol from 'openlayers'; - -export default ol.source.VectorTile; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import FeatureFormat from 'ol/format/Feature'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import { Size } from 'ol/size'; +import { AttributionLike } from 'ol/source/Source'; +import State from 'ol/source/State'; +import { TileSourceEvent } from 'ol/source/Tile'; +import UrlTile from 'ol/source/UrlTile'; +import { LoadFunction, UrlFunction } from 'ol/Tile'; +import TileGrid from 'ol/tilegrid/TileGrid'; +import VectorTile_1 from 'ol/VectorTile'; +export interface Options { + attributions?: AttributionLike; + cacheSize?: number; + extent?: Extent; + format?: FeatureFormat; + overlaps?: boolean; + projection?: ProjectionLike; + state?: State; + tileClass?: VectorTile_1; + maxZoom?: number; + minZoom?: number; + tileSize?: number | Size; + tileGrid?: TileGrid; + tileLoadFunction?: LoadFunction; + tileUrlFunction?: UrlFunction; + url?: string; + transition?: number; + urls?: string[]; + wrapX?: boolean; +} +export default class VectorTile extends UrlTile { + constructor(options: Options); + protected tileClass: VectorTile_1; + clear(): void; + getOverlaps(): boolean; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/WMSServerType.d.ts b/types/ol/source/WMSServerType.d.ts new file mode 100644 index 0000000000..a891d3f4a3 --- /dev/null +++ b/types/ol/source/WMSServerType.d.ts @@ -0,0 +1,8 @@ +declare enum WMSServerType { + CARMENTA_SERVER = 'carmentaserver', + GEOSERVER = 'geoserver', + MAPSERVER = 'mapserver', + QGIS = 'qgis', +} + +export default WMSServerType; diff --git a/types/ol/source/WMTS.d.ts b/types/ol/source/WMTS.d.ts index afdc2c352b..cd83f39b85 100644 --- a/types/ol/source/WMTS.d.ts +++ b/types/ol/source/WMTS.d.ts @@ -1,3 +1,63 @@ -import * as ol from 'openlayers'; - -export default ol.source.WMTS; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import ImageTile from 'ol/ImageTile'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import { AttributionLike } from 'ol/source/Source'; +import { TileSourceEvent } from 'ol/source/Tile'; +import TileImage from 'ol/source/TileImage'; +import WMTSRequestEncoding from 'ol/source/WMTSRequestEncoding'; +import { UrlFunction, LoadFunction } from 'ol/Tile'; +import WMTSTileGrid from 'ol/tilegrid/WMTS'; +export function optionsFromCapabilities(wmtsCap: { [key: string]: any }, config: { [key: string]: any }): Options; +export interface Options { + attributions?: AttributionLike; + cacheSize?: number; + crossOrigin?: string; + tileGrid: WMTSTileGrid; + projection?: ProjectionLike; + reprojectionErrorThreshold?: number; + requestEncoding?: WMTSRequestEncoding | string; + layer: string; + style: string; + tileClass?: ImageTile; + tilePixelRatio?: number; + format?: string; + version?: string; + matrixSet: string; + dimensions?: { [key: string]: any }; + url?: string; + tileLoadFunction?: LoadFunction; + urls?: string[]; + wrapX?: boolean; + transition?: number; +} +export default class WMTS extends TileImage { + constructor(options: Options); + getDimensions(): { [key: string]: any }; + getFormat(): string; + getLayer(): string; + getMatrixSet(): string; + getRequestEncoding(): WMTSRequestEncoding; + getStyle(): string; + getVersion(): string; + updateDimensions(dimensions: { [key: string]: any }): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/WMTSRequestEncoding.d.ts b/types/ol/source/WMTSRequestEncoding.d.ts new file mode 100644 index 0000000000..de226a42b0 --- /dev/null +++ b/types/ol/source/WMTSRequestEncoding.d.ts @@ -0,0 +1,6 @@ +declare enum WMTSRequestEncoding { + KVP = 'KVP', + REST = 'REST', +} + +export default WMTSRequestEncoding; diff --git a/types/ol/source/XYZ.d.ts b/types/ol/source/XYZ.d.ts index d29b5f9e06..30367417b6 100644 --- a/types/ol/source/XYZ.d.ts +++ b/types/ol/source/XYZ.d.ts @@ -1,3 +1,51 @@ -import * as ol from 'openlayers'; - -export default ol.source.XYZ; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import { Size } from 'ol/size'; +import { AttributionLike } from 'ol/source/Source'; +import { TileSourceEvent } from 'ol/source/Tile'; +import TileImage from 'ol/source/TileImage'; +import { LoadFunction, UrlFunction } from 'ol/Tile'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export interface Options { + attributions?: AttributionLike; + attributionsCollapsible?: boolean; + cacheSize?: number; + crossOrigin?: string; + opaque?: boolean; + projection?: ProjectionLike; + reprojectionErrorThreshold?: number; + maxZoom?: number; + minZoom?: number; + tileGrid?: TileGrid; + tileLoadFunction?: LoadFunction; + tilePixelRatio?: number; + tileSize?: number | Size; + tileUrlFunction?: UrlFunction; + url?: string; + urls?: string[]; + wrapX?: boolean; + transition?: number; +} +export default class XYZ extends TileImage { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/Zoomify.d.ts b/types/ol/source/Zoomify.d.ts index a48e675012..63b2042e06 100644 --- a/types/ol/source/Zoomify.d.ts +++ b/types/ol/source/Zoomify.d.ts @@ -1,3 +1,51 @@ -import * as ol from 'openlayers'; - -export default ol.source.Zoomify; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import { Extent } from 'ol/extent'; +import ImageTile from 'ol/ImageTile'; +import { ObjectEvent } from 'ol/Object'; +import { ProjectionLike } from 'ol/proj'; +import { Size } from 'ol/size'; +import { AttributionLike } from 'ol/source/Source'; +import { TileSourceEvent } from 'ol/source/Tile'; +import TileImage from 'ol/source/TileImage'; +import { LoadFunction, Options as Options_1 } from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +import TileState from 'ol/TileState'; +export class CustomTile extends ImageTile { + constructor(tileGrid: TileGrid, tileCoord: TileCoord, state: TileState, src: string, crossOrigin: string, tileLoadFunction: LoadFunction, opt_options?: Options_1); +} +export interface Options { + attributions?: AttributionLike; + cacheSize?: number; + crossOrigin?: string; + projection?: ProjectionLike; + reprojectionErrorThreshold?: number; + url?: string; + tierSizeCalculation?: string; + size?: Size; + extent?: Extent; + transition?: number; + tileSize?: number; +} +export default class Zoomify extends TileImage { + constructor(opt_options?: Options); + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; + on(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + once(type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey; + un(type: 'propertychange', listener: (evt: ObjectEvent) => void): void; + on(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadend', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloaderror', listener: (evt: TileSourceEvent) => void): void; + on(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + once(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): EventsKey; + un(type: 'tileloadstart', listener: (evt: TileSourceEvent) => void): void; +} diff --git a/types/ol/source/common.d.ts b/types/ol/source/common.d.ts new file mode 100644 index 0000000000..ec11bd49d9 --- /dev/null +++ b/types/ol/source/common.d.ts @@ -0,0 +1 @@ +export const DEFAULT_WMS_VERSION: string; diff --git a/types/ol/source/index.d.ts b/types/ol/source/index.d.ts new file mode 100644 index 0000000000..67bb322cce --- /dev/null +++ b/types/ol/source/index.d.ts @@ -0,0 +1,26 @@ +export { default as BingMaps } from 'ol/source/BingMaps'; +export { default as CartoDB } from 'ol/source/CartoDB'; +export { default as Cluster } from 'ol/source/Cluster'; +export { default as Image } from 'ol/source/Image'; +export { default as ImageArcGISRest } from 'ol/source/ImageArcGISRest'; +export { default as ImageCanvas } from 'ol/source/ImageCanvas'; +export { default as ImageMapGuide } from 'ol/source/ImageMapGuide'; +export { default as ImageStatic } from 'ol/source/ImageStatic'; +export { default as ImageWMS } from 'ol/source/ImageWMS'; +export { default as OSM } from 'ol/source/OSM'; +export { default as Raster } from 'ol/source/Raster'; +export { default as Source } from 'ol/source/Source'; +export { default as Stamen } from 'ol/source/Stamen'; +export { default as Tile } from 'ol/source/Tile'; +export { default as TileArcGISRest } from 'ol/source/TileArcGISRest'; +export { default as TileDebug } from 'ol/source/TileDebug'; +export { default as TileImage } from 'ol/source/TileImage'; +export { default as TileJSON } from 'ol/source/TileJSON'; +export { default as TileWMS } from 'ol/source/TileWMS'; +export { default as UrlTile } from 'ol/source/UrlTile'; +export { default as UTFGrid } from 'ol/source/UTFGrid'; +export { default as Vector } from 'ol/source/Vector'; +export { default as VectorTile } from 'ol/source/VectorTile'; +export { default as WMTS } from 'ol/source/WMTS'; +export { default as XYZ } from 'ol/source/XYZ'; +export { default as Zoomify } from 'ol/source/Zoomify'; diff --git a/types/ol/sphere.d.ts b/types/ol/sphere.d.ts new file mode 100644 index 0000000000..583ff5609b --- /dev/null +++ b/types/ol/sphere.d.ts @@ -0,0 +1,11 @@ +import { Coordinate } from 'ol/coordinate'; +import Geometry from 'ol/geom/Geometry'; +import { ProjectionLike } from 'ol/proj'; +export function getArea(geometry: Geometry, opt_options?: SphereMetricOptions): number; +export function getDistance(c1: any[], c2: any[], opt_radius?: number): number; +export function getLength(geometry: Geometry, opt_options?: SphereMetricOptions): number; +export function offset(c1: Coordinate, distance: number, bearing: number, opt_radius?: number): Coordinate; +export interface SphereMetricOptions { + projection?: ProjectionLike; + radius?: number; +} diff --git a/types/ol/sphere/index.d.ts b/types/ol/sphere/index.d.ts deleted file mode 100644 index a3481e4339..0000000000 --- a/types/ol/sphere/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as ol from 'openlayers'; - -export default ol.Sphere; diff --git a/types/ol/string.d.ts b/types/ol/string.d.ts new file mode 100644 index 0000000000..945cf6c916 --- /dev/null +++ b/types/ol/string.d.ts @@ -0,0 +1,2 @@ +export function compareVersions(v1: string | number, v2: string | number): number; +export function padNumber(number: number, width: number, opt_precision?: number): string; diff --git a/types/ol/structs/LRUCache.d.ts b/types/ol/structs/LRUCache.d.ts new file mode 100644 index 0000000000..71d91c53b3 --- /dev/null +++ b/types/ol/structs/LRUCache.d.ts @@ -0,0 +1,35 @@ +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import Target from 'ol/events/Target'; +export interface Entry { + key_: string; + newer: { [key: string]: any }; + older: { [key: string]: any }; + value_: any; +} +export default class LRUCache extends Target { + constructor(opt_highWaterMark?: number); + peekFirstKey(): string; + canExpireCache(): boolean; + containsKey(key: string): boolean; + forEach(f: ((this: S, param1: T, param2: string, param3: LRUCache) => void), opt_this?: S): void; + get(key: string): T; + getCount(): number; + getKeys(): string[]; + getValues(): T[]; + clear(): void; + peekLast(): T; + peekLastKey(): string; + pop(): T; + prune(): void; + remove(key: string): T; + replace(key: string, value: T): void; + set(key: string, value: T): void; + setSize(size: number): void; + on(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + once(type: string | string[], listener: ((param0: any) => void)): EventsKey | EventsKey[]; + un(type: string | string[], listener: ((param0: any) => void)): void; + on(type: 'change', listener: (evt: Event) => void): EventsKey; + once(type: 'change', listener: (evt: Event) => void): EventsKey; + un(type: 'change', listener: (evt: Event) => void): void; +} diff --git a/types/ol/structs/LinkedList.d.ts b/types/ol/structs/LinkedList.d.ts new file mode 100644 index 0000000000..d59cbe62c4 --- /dev/null +++ b/types/ol/structs/LinkedList.d.ts @@ -0,0 +1,20 @@ +export interface Item { + prev?: Item; + next?: Item; + data: any; +} +export default class LinkedList { + constructor(opt_circular?: boolean); + insertItem(data: any): void; + concat(list: LinkedList): void; + getCurrItem(): any; + getLength(): number; + getNextItem(): any; + getPrevItem(): any; + firstItem(): any; + lastItem(): any; + nextItem(): any; + prevItem(): any; + removeItem(): void; + setFirstItem(): void; +} diff --git a/types/ol/structs/PriorityQueue.d.ts b/types/ol/structs/PriorityQueue.d.ts new file mode 100644 index 0000000000..0888b65e90 --- /dev/null +++ b/types/ol/structs/PriorityQueue.d.ts @@ -0,0 +1,11 @@ +export default class PriorityQueue { + constructor(priorityFunction: ((param0: T) => number), keyFunction: ((param0: T) => string)); + clear(): void; + dequeue(): T; + enqueue(element: T): boolean; + getCount(): number; + isEmpty(): boolean; + isKeyQueued(key: string): boolean; + isQueued(element: T): boolean; + reprioritize(): void; +} diff --git a/types/ol/structs/RBush.d.ts b/types/ol/structs/RBush.d.ts new file mode 100644 index 0000000000..2ddbb5ff41 --- /dev/null +++ b/types/ol/structs/RBush.d.ts @@ -0,0 +1,23 @@ +import { Extent } from 'ol/extent'; +export interface Entry { + minX: number; + minY: number; + maxX: number; + maxY: number; + value?: { [key: string]: any }; +} +export default class RBush { + constructor(opt_maxEntries?: number); + getInExtent(extent: Extent): T[]; + clear(): void; + forEach(callback: ((this: S, param1: T) => void), opt_this?: S): any; + forEachInExtent(extent: Extent, callback: ((this: S, param1: T) => void), opt_this?: S): any; + getAll(): T[]; + getExtent(opt_extent?: Extent): Extent; + concat(rbush: RBush): void; + insert(extent: Extent, value: T): void; + isEmpty(): boolean; + load(extents: Extent[], values: T[]): void; + remove(value: T): boolean; + update(extent: Extent, value: T): void; +} diff --git a/types/ol/style/Atlas.d.ts b/types/ol/style/Atlas.d.ts new file mode 100644 index 0000000000..6e34165da7 --- /dev/null +++ b/types/ol/style/Atlas.d.ts @@ -0,0 +1,16 @@ +export default class Atlas { + constructor(size: number, space: number); + add(id: string, width: number, height: number, renderCallback: ((param0: CanvasRenderingContext2D, param1: number, param2: number) => void), opt_this?: { [key: string]: any }): AtlasInfo; + get(id: string): AtlasInfo; +} +export interface AtlasBlock { + x: number; + y: number; + width: number; + height: number; +} +export interface AtlasInfo { + offsetX: number; + offsetY: number; + image: HTMLCanvasElement; +} diff --git a/types/ol/style/AtlasManager.d.ts b/types/ol/style/AtlasManager.d.ts index 0be77a6621..b40d98b335 100644 --- a/types/ol/style/AtlasManager.d.ts +++ b/types/ol/style/AtlasManager.d.ts @@ -1,3 +1,16 @@ -import * as ol from 'openlayers'; - -export default ol.style.AtlasManager; +export default class AtlasManager { + constructor(opt_options?: Options); + add(id: string, width: number, height: number, renderCallback: ((param0: CanvasRenderingContext2D, param1: number, param2: number) => void), opt_renderHitCallback?: (() => void), opt_this?: { [key: string]: any }): AtlasManagerInfo; + getInfo(id: string): AtlasManagerInfo; +} +export interface AtlasManagerInfo { + offsetX: number; + offsetY: number; + image: HTMLCanvasElement; + hitImage: HTMLCanvasElement; +} +export interface Options { + initialSize?: number; + maxSize?: number; + space?: number; +} diff --git a/types/ol/style/Circle.d.ts b/types/ol/style/Circle.d.ts index ff593230b5..e7219b2829 100644 --- a/types/ol/style/Circle.d.ts +++ b/types/ol/style/Circle.d.ts @@ -1,3 +1,14 @@ -import * as ol from 'openlayers'; - -export default ol.style.Circle; +import AtlasManager from 'ol/style/AtlasManager'; +import Fill from 'ol/style/Fill'; +import RegularShape from 'ol/style/RegularShape'; +import Stroke from 'ol/style/Stroke'; +export default class CircleStyle extends RegularShape { + constructor(opt_options?: Options); + setRadius(radius: number): void; +} +export interface Options { + fill?: Fill; + radius: number; + stroke?: Stroke; + atlasManager?: AtlasManager; +} diff --git a/types/ol/style/Fill.d.ts b/types/ol/style/Fill.d.ts index ef6b246ad5..86a7dcfd1f 100644 --- a/types/ol/style/Fill.d.ts +++ b/types/ol/style/Fill.d.ts @@ -1,3 +1,12 @@ -import * as ol from 'openlayers'; - -export default ol.style.Fill; +import { Color } from 'ol/color'; +import { ColorLike } from 'ol/colorlike'; +export default class Fill { + constructor(opt_options?: Options); + clone(): Fill; + getChecksum(): string; + getColor(): Color | ColorLike; + setColor(color: Color | ColorLike): void; +} +export interface Options { + color?: Color | ColorLike; +} diff --git a/types/ol/style/Icon.d.ts b/types/ol/style/Icon.d.ts index 4100f3fbf8..b703a0bfed 100644 --- a/types/ol/style/Icon.d.ts +++ b/types/ol/style/Icon.d.ts @@ -1,3 +1,31 @@ -import * as ol from 'openlayers'; - -export default ol.style.Icon; +import { Color } from 'ol/color'; +import { Size } from 'ol/size'; +import IconAnchorUnits from 'ol/style/IconAnchorUnits'; +import IconOrigin from 'ol/style/IconOrigin'; +import ImageStyle from 'ol/style/Image'; +export default class Icon extends ImageStyle { + constructor(opt_options?: Options); + clone(): Icon; + clone(): ImageStyle; + getColor(): Color; + getSrc(): string; + setAnchor(anchor: number[]): void; +} +export interface Options { + anchor?: number[]; + anchorOrigin?: IconOrigin; + anchorXUnits?: IconAnchorUnits; + anchorYUnits?: IconAnchorUnits; + color?: Color | string; + crossOrigin?: string; + img?: HTMLImageElement | HTMLCanvasElement; + offset?: number[]; + offsetOrigin?: IconOrigin; + opacity?: number; + scale?: number; + rotateWithView?: boolean; + rotation?: number; + size?: Size; + imgSize?: Size; + src?: string; +} diff --git a/types/ol/style/IconAnchorUnits.d.ts b/types/ol/style/IconAnchorUnits.d.ts new file mode 100644 index 0000000000..17d8efc263 --- /dev/null +++ b/types/ol/style/IconAnchorUnits.d.ts @@ -0,0 +1,6 @@ +declare enum IconAnchorUnits { + FRACTION = 'fraction', + PIXELS = 'pixels', +} + +export default IconAnchorUnits; diff --git a/types/ol/style/IconImage.d.ts b/types/ol/style/IconImage.d.ts new file mode 100644 index 0000000000..dd338437b4 --- /dev/null +++ b/types/ol/style/IconImage.d.ts @@ -0,0 +1,14 @@ +import { Color } from 'ol/color'; +import Target from 'ol/events/Target'; +import ImageState from 'ol/ImageState'; +import { Size } from 'ol/size'; +export function get(image: HTMLImageElement | HTMLCanvasElement, src: string, size: Size, crossOrigin: string, imageState: ImageState, color: Color): IconImage; +export default class IconImage extends Target { + constructor(image: HTMLImageElement | HTMLCanvasElement, src: string, size: Size, crossOrigin: string, imageState: ImageState, color: Color); + getHitDetectionImage(pixelRatio: number): HTMLImageElement | HTMLCanvasElement; + getImage(pixelRatio: number): HTMLImageElement | HTMLCanvasElement; + getImageState(): ImageState; + getSize(): Size; + getSrc(): string; + load(): void; +} diff --git a/types/ol/style/IconImageCache.d.ts b/types/ol/style/IconImageCache.d.ts new file mode 100644 index 0000000000..578f896ec4 --- /dev/null +++ b/types/ol/style/IconImageCache.d.ts @@ -0,0 +1,11 @@ +import { Color } from 'ol/color'; +import IconImage from 'ol/style/IconImage'; +export default class IconImageCache { + constructor(); + clear(): void; + expire(): void; + get(src: string, crossOrigin: string, color: Color): IconImage; + set(src: string, crossOrigin: string, color: Color, iconImage: IconImage): void; + setSize(maxCacheSize: number): void; +} +export const shared: IconImageCache; diff --git a/types/ol/style/IconOrigin.d.ts b/types/ol/style/IconOrigin.d.ts new file mode 100644 index 0000000000..e5b4d69be3 --- /dev/null +++ b/types/ol/style/IconOrigin.d.ts @@ -0,0 +1,8 @@ +declare enum IconOrigin { + BOTTOM_LEFT = 'bottom-left', + BOTTOM_RIGHT = 'bottom-right', + TOP_LEFT = 'top-left', + TOP_RIGHT = 'top-right', +} + +export default IconOrigin; diff --git a/types/ol/style/Image.d.ts b/types/ol/style/Image.d.ts index bdfb4319e3..304850241c 100644 --- a/types/ol/style/Image.d.ts +++ b/types/ol/style/Image.d.ts @@ -1,3 +1,35 @@ -import * as ol from 'openlayers'; - -export default ol.style.Image; +import { EventsKey } from 'ol/events'; +import Event from 'ol/events/Event'; +import ImageState from 'ol/ImageState'; +import { Size } from 'ol/size'; +export default class ImageStyle { + constructor(options: Options); + getScale(): number; + clone(): ImageStyle; + getHitDetectionImage(pixelRatio: number): HTMLCanvasElement | HTMLVideoElement | HTMLImageElement; + getHitDetectionImageSize(): Size; + getImage(pixelRatio: number): HTMLCanvasElement | HTMLVideoElement | HTMLImageElement; + getImageSize(): Size; + getImageState(): ImageState; + getOpacity(): number; + getOrigin(): number[]; + getRotateWithView(): boolean; + getRotation(): number; + getAnchor(): number[]; + getSize(): Size; + getSnapToPixel(): boolean; + listenImageChange(listener: ((this: T, param1: Event) => void), thisArg: T): EventsKey; + load(): void; + setOpacity(opacity: number): void; + setRotateWithView(rotateWithView: boolean): void; + setRotation(rotation: number): void; + setScale(scale: number): void; + setSnapToPixel(snapToPixel: boolean): void; + unlistenImageChange(listener: ((this: T, param1: Event) => void), thisArg: T): void; +} +export interface Options { + opacity: number; + rotateWithView: boolean; + rotation: number; + scale: number; +} diff --git a/types/ol/style/RegularShape.d.ts b/types/ol/style/RegularShape.d.ts index fb4a227d1d..80031f891f 100644 --- a/types/ol/style/RegularShape.d.ts +++ b/types/ol/style/RegularShape.d.ts @@ -1,3 +1,42 @@ -import * as ol from 'openlayers'; - -export default ol.style.RegularShape; +import { ColorLike } from 'ol/colorlike'; +import AtlasManager from 'ol/style/AtlasManager'; +import Fill from 'ol/style/Fill'; +import ImageStyle from 'ol/style/Image'; +import Stroke from 'ol/style/Stroke'; +export interface Options { + fill?: Fill; + points: number; + radius?: number; + radius1?: number; + radius2?: number; + angle?: number; + stroke?: Stroke; + rotation?: number; + rotateWithView?: boolean; + atlasManager?: AtlasManager; +} +export default class RegularShape extends ImageStyle { + constructor(options: Options); + protected atlasManager_: AtlasManager; + protected radius_: number; + protected render_(atlasManager: AtlasManager): void; + getChecksum(): string; + getFill(): Fill; + clone(): RegularShape; + clone(): ImageStyle; + getRadius(): number; + getRadius2(): number; + getStroke(): Stroke; + getAngle(): number; + getPoints(): number; +} +export interface RenderOptions { + strokeStyle?: ColorLike; + strokeWidth: number; + size: number; + lineCap: string; + lineDash: number[]; + lineDashOffset: number; + lineJoin: string; + miterLimit: number; +} diff --git a/types/ol/style/Stroke.d.ts b/types/ol/style/Stroke.d.ts index af7a49d6b5..ae056e8575 100644 --- a/types/ol/style/Stroke.d.ts +++ b/types/ol/style/Stroke.d.ts @@ -1,3 +1,30 @@ -import * as ol from 'openlayers'; - -export default ol.style.Stroke; +import { Color } from 'ol/color'; +import { ColorLike } from 'ol/colorlike'; +export interface Options { + color?: Color | ColorLike; + lineCap?: string; + lineJoin?: string; + lineDash?: number[]; + lineDashOffset?: number; + miterLimit?: number; + width?: number; +} +export default class Stroke { + constructor(opt_options?: Options); + getWidth(): number; + clone(): Stroke; + getColor(): Color | ColorLike; + getLineCap(): string; + getLineDash(): number[]; + getLineDashOffset(): number; + getLineJoin(): string; + getMiterLimit(): number; + getChecksum(): string; + setColor(color: Color | ColorLike): void; + setLineCap(lineCap: string): void; + setLineDash(lineDash: number[]): void; + setLineDashOffset(lineDashOffset: number): void; + setLineJoin(lineJoin: string): void; + setMiterLimit(miterLimit: number): void; + setWidth(width: number): void; +} diff --git a/types/ol/style/Style.d.ts b/types/ol/style/Style.d.ts index 839583e313..2961ae34be 100644 --- a/types/ol/style/Style.d.ts +++ b/types/ol/style/Style.d.ts @@ -1,3 +1,45 @@ -import * as ol from 'openlayers'; - -export default ol.style.Style; +import { Coordinate } from 'ol/coordinate'; +import { FeatureLike } from 'ol/Feature'; +import Geometry from 'ol/geom/Geometry'; +import GeometryType from 'ol/geom/GeometryType'; +import { State } from 'ol/render'; +import RenderFeature from 'ol/render/Feature'; +import Fill from 'ol/style/Fill'; +import ImageStyle from 'ol/style/Image'; +import Stroke from 'ol/style/Stroke'; +import Text from 'ol/style/Text'; +export function createDefaultStyle(feature: FeatureLike, resolution: number): Style[]; +export function createEditingStyle(): { [key in GeometryType]: Style[] }; +export function toFunction(obj: StyleFunction | Style[] | Style): StyleFunction; +export type GeometryFunction = ((param0: FeatureLike) => Geometry | RenderFeature); +export interface Options { + geometry?: string | Geometry | GeometryFunction; + fill?: Fill; + image?: ImageStyle; + renderer?: RenderFunction; + stroke?: Stroke; + text?: Text; + zIndex?: number; +} +export type RenderFunction = ((param0: Coordinate | Coordinate[] | Coordinate[][], param1: State) => void); +export default class Style { + constructor(opt_options?: Options); + getZIndex(): number; + clone(): Style; + getGeometry(): string | Geometry | GeometryFunction; + getGeometryFunction(): GeometryFunction; + getImage(): ImageStyle; + getRenderer(): RenderFunction; + getStroke(): Stroke; + getText(): Text; + getFill(): Fill; + setFill(fill: Fill): void; + setGeometry(geometry: string | Geometry | GeometryFunction): void; + setImage(image: ImageStyle): void; + setRenderer(renderer: RenderFunction): void; + setStroke(stroke: Stroke): void; + setText(text: Text): void; + setZIndex(zIndex: number): void; +} +export type StyleFunction = ((param0: FeatureLike, param1: number) => Style | Style[]); +export type StyleLike = Style | Style[] | StyleFunction; diff --git a/types/ol/style/Text.d.ts b/types/ol/style/Text.d.ts index 33d1b50962..a1e7bae029 100644 --- a/types/ol/style/Text.d.ts +++ b/types/ol/style/Text.d.ts @@ -1,3 +1,59 @@ -import * as ol from 'openlayers'; - -export default ol.style.Text; +import Fill from 'ol/style/Fill'; +import Stroke from 'ol/style/Stroke'; +import TextPlacement from 'ol/style/TextPlacement'; +export interface Options { + font?: string; + maxAngle?: number; + offsetX?: number; + offsetY?: number; + overflow?: boolean; + placement?: TextPlacement | string; + scale?: number; + rotateWithView?: boolean; + rotation?: number; + text?: string; + textAlign?: string; + textBaseline?: string; + fill?: Fill; + stroke?: Stroke; + backgroundFill?: Fill; + backgroundStroke?: Stroke; + padding?: number[]; +} +export default class Text { + constructor(opt_options?: Options); + getTextBaseline(): string; + clone(): Text; + getBackgroundStroke(): Stroke; + getFill(): Fill; + getFont(): string; + getMaxAngle(): number; + getOffsetX(): number; + getOffsetY(): number; + getOverflow(): boolean; + getPadding(): number[]; + getPlacement(): TextPlacement | string; + getRotateWithView(): boolean; + getRotation(): number; + getScale(): number; + getStroke(): Stroke; + getText(): string; + getTextAlign(): string; + getBackgroundFill(): Fill; + setBackgroundFill(fill: Fill): void; + setBackgroundStroke(stroke: Stroke): void; + setFill(fill: Fill): void; + setFont(font: string): void; + setMaxAngle(maxAngle: number): void; + setOffsetX(offsetX: number): void; + setOffsetY(offsetY: number): void; + setOverflow(overflow: boolean): void; + setPadding(padding: number[]): void; + setPlacement(placement: TextPlacement | string): void; + setRotation(rotation: number): void; + setScale(scale: number): void; + setStroke(stroke: Stroke): void; + setText(text: string): void; + setTextAlign(textAlign: string): void; + setTextBaseline(textBaseline: string): void; +} diff --git a/types/ol/style/TextPlacement.d.ts b/types/ol/style/TextPlacement.d.ts new file mode 100644 index 0000000000..ea0150f0b9 --- /dev/null +++ b/types/ol/style/TextPlacement.d.ts @@ -0,0 +1,6 @@ +declare enum TextPlacement { + POINT = 'point', + LINE = 'line', +} + +export default TextPlacement; diff --git a/types/ol/style/index.d.ts b/types/ol/style/index.d.ts new file mode 100644 index 0000000000..fef9ce0705 --- /dev/null +++ b/types/ol/style/index.d.ts @@ -0,0 +1,11 @@ +export { default as Atlas } from 'ol/style/Atlas'; +export { default as AtlasManager } from 'ol/style/AtlasManager'; +export { default as Circle } from 'ol/style/Circle'; +export { default as Fill } from 'ol/style/Fill'; +export { default as Icon } from 'ol/style/Icon'; +export { default as IconImage } from 'ol/style/IconImage'; +export { default as Image } from 'ol/style/Image'; +export { default as RegularShape } from 'ol/style/RegularShape'; +export { default as Stroke } from 'ol/style/Stroke'; +export { default as Style } from 'ol/style/Style'; +export { default as Text } from 'ol/style/Text'; diff --git a/types/ol/tilecoord.d.ts b/types/ol/tilecoord.d.ts new file mode 100644 index 0000000000..8f109e931d --- /dev/null +++ b/types/ol/tilecoord.d.ts @@ -0,0 +1,9 @@ +import TileGrid from 'ol/tilegrid/TileGrid'; +export function createOrUpdate(z: number, x: number, y: number, opt_tileCoord?: TileCoord): TileCoord; +export function fromKey(key: string): TileCoord; +export function getKey(tileCoord: TileCoord): string; +export function getKeyZXY(z: number, x: number, y: number): string; +export function hash(tileCoord: TileCoord): number; +export function quadKey(tileCoord: TileCoord): string; +export function withinExtentAndZ(tileCoord: TileCoord, tileGrid: TileGrid): boolean; +export type TileCoord = number[]; diff --git a/types/ol/tilegrid/TileGrid.d.ts b/types/ol/tilegrid/TileGrid.d.ts index b6edeba4aa..d3ac5f76ef 100644 --- a/types/ol/tilegrid/TileGrid.d.ts +++ b/types/ol/tilegrid/TileGrid.d.ts @@ -1,3 +1,39 @@ -import * as ol from 'openlayers'; - -export default ol.tilegrid.TileGrid; +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import { Size } from 'ol/size'; +import { TileCoord } from 'ol/tilecoord'; +import TileRange from 'ol/TileRange'; +export interface Options { + extent?: Extent; + minZoom?: number; + origin?: Coordinate; + origins?: Coordinate[]; + resolutions: number[]; + sizes?: Size[]; + tileSize?: number | Size; + tileSizes?: Size[]; +} +export default class TileGrid { + constructor(options: Options); + protected minZoom: number; + protected maxZoom: number; + getExtent(): Extent; + getFullTileRange(z: number): TileRange; + getMaxZoom(): number; + getMinZoom(): number; + getOrigin(z: number): Coordinate; + getResolution(z: number): number; + getResolutions(): number[]; + getTileCoordCenter(tileCoord: TileCoord): Coordinate; + forEachTileCoordParentTileRange(tileCoord: TileCoord, callback: ((this: T, param1: number, param2: TileRange) => boolean), opt_this?: T, opt_tileRange?: TileRange, opt_extent?: Extent): boolean; + getTileCoordExtent(tileCoord: TileCoord, opt_extent?: Extent): Extent; + getTileCoordForCoordAndResolution(coordinate: Coordinate, resolution: number, opt_tileCoord?: TileCoord): TileCoord; + getTileCoordForCoordAndZ(coordinate: Coordinate, z: number, opt_tileCoord?: TileCoord): TileCoord; + getTileCoordResolution(tileCoord: TileCoord): number; + getTileRangeExtent(z: number, tileRange: TileRange, opt_extent?: Extent): Extent; + getTileRangeForExtentAndZ(extent: Extent, z: number, opt_tileRange?: TileRange): TileRange; + getTileSize(z: number): number | Size; + getZForResolution(resolution: number, opt_direction?: number): number; + forEachTileCoord(extent: Extent, zoom: number, callback: ((param0: TileCoord) => void)): void; + getTileCoordChildTileRange(tileCoord: TileCoord, opt_tileRange?: TileRange, opt_extent?: Extent): TileRange; +} diff --git a/types/ol/tilegrid/WMTS.d.ts b/types/ol/tilegrid/WMTS.d.ts index 3f1f33e647..583c6356ef 100644 --- a/types/ol/tilegrid/WMTS.d.ts +++ b/types/ol/tilegrid/WMTS.d.ts @@ -1,3 +1,21 @@ -import * as ol from 'openlayers'; - -export default ol.tilegrid.WMTS; +import { Coordinate } from 'ol/coordinate'; +import { Extent } from 'ol/extent'; +import { Size } from 'ol/size'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export function createFromCapabilitiesMatrixSet(matrixSet: { [key: string]: any }, opt_extent?: Extent, opt_matrixLimits?: { [key: string]: any }[]): WMTSTileGrid; +export interface Options { + extent?: Extent; + origin?: Coordinate; + origins?: Coordinate[]; + resolutions: number[]; + matrixIds: string[]; + sizes?: Size[]; + tileSize?: number | Size; + tileSizes?: Size[]; + widths?: number[]; +} +export default class WMTSTileGrid extends TileGrid { + constructor(options: Options); + getMatrixId(z: number): string; + getMatrixIds(): string[]; +} diff --git a/types/ol/tilegrid/common.d.ts b/types/ol/tilegrid/common.d.ts new file mode 100644 index 0000000000..326f826e05 --- /dev/null +++ b/types/ol/tilegrid/common.d.ts @@ -0,0 +1,2 @@ +export const DEFAULT_MAX_ZOOM: number; +export const DEFAULT_TILE_SIZE: number; diff --git a/types/ol/tilegrid/index.d.ts b/types/ol/tilegrid/index.d.ts index 467e92480f..4cb9493e12 100644 --- a/types/ol/tilegrid/index.d.ts +++ b/types/ol/tilegrid/index.d.ts @@ -1,3 +1,19 @@ -import * as ol from 'openlayers'; - -export default ol.tilegrid; +import { Extent } from 'ol/extent'; +import Corner from 'ol/extent/Corner'; +import { ProjectionLike } from 'ol/proj'; +import Projection from 'ol/proj/Projection'; +import { Size } from 'ol/size'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export function createForExtent(extent: Extent, opt_maxZoom?: number, opt_tileSize?: number | Size, opt_corner?: Corner): TileGrid; +export function createForProjection(projection: ProjectionLike, opt_maxZoom?: number, opt_tileSize?: number | Size, opt_corner?: Corner): TileGrid; +export function createXYZ(opt_options?: XYZOptions): TileGrid; +export function extentFromProjection(projection: ProjectionLike): Extent; +export function getForProjection(projection: Projection): TileGrid; +export function wrapX(tileGrid: TileGrid, tileCoord: TileCoord, projection: Projection): TileCoord; +export interface XYZOptions { + extent?: Extent; + maxZoom?: number; + minZoom?: number; + tileSize?: number | Size; +} diff --git a/types/ol/tileurlfunction.d.ts b/types/ol/tileurlfunction.d.ts new file mode 100644 index 0000000000..e54d43ebfc --- /dev/null +++ b/types/ol/tileurlfunction.d.ts @@ -0,0 +1,9 @@ +import Projection from 'ol/proj/Projection'; +import { UrlFunction } from 'ol/Tile'; +import { TileCoord } from 'ol/tilecoord'; +import TileGrid from 'ol/tilegrid/TileGrid'; +export function createFromTemplate(template: string, tileGrid: TileGrid): UrlFunction; +export function createFromTemplates(templates: string[], tileGrid: TileGrid): UrlFunction; +export function createFromTileUrlFunctions(tileUrlFunctions: UrlFunction[]): UrlFunction; +export function expandUrl(url: string): string[]; +export function nullTileUrlFunction(tileCoord: TileCoord, pixelRatio: number, projection: Projection): string; diff --git a/types/ol/transform.d.ts b/types/ol/transform.d.ts new file mode 100644 index 0000000000..e6a1a63046 --- /dev/null +++ b/types/ol/transform.d.ts @@ -0,0 +1,15 @@ +import { Coordinate } from 'ol/coordinate'; +import { Pixel } from 'ol/pixel'; +export function apply(transform: Transform, coordinate: Coordinate | Pixel): Coordinate | Pixel; +export function compose(transform: Transform, dx1: number, dy1: number, sx: number, sy: number, angle: number, dx2: number, dy2: number): Transform; +export function create(): Transform; +export function determinant(mat: Transform): number; +export function invert(transform: Transform): Transform; +export function multiply(transform1: Transform, transform2: Transform): Transform; +export function reset(transform: Transform): Transform; +export function rotate(transform: Transform, angle: number): Transform; +export function scale(transform: Transform, x: number, y: number): Transform; +export function set(transform: Transform, a: number, b: number, c: number, d: number, e: number, f: number): Transform; +export function setFromArray(transform1: Transform, transform2: Transform): Transform; +export function translate(transform: Transform, dx: number, dy: number): Transform; +export type Transform = number[]; diff --git a/types/ol/tsconfig.json b/types/ol/tsconfig.json index 8751d240da..f832583124 100644 --- a/types/ol/tsconfig.json +++ b/types/ol/tsconfig.json @@ -1,51 +1,99 @@ { "compilerOptions": { - "module": "commonjs", + "baseUrl": "../", + "forceConsistentCasingInFileNames": true, "lib": [ "es6", "dom" ], + "module": "commonjs", + "noEmit": true, "noImplicitAny": true, "noImplicitThis": true, - "strictNullChecks": true, "strictFunctionTypes": true, - "baseUrl": "../", + "strictNullChecks": true, "typeRoots": [ "../" ], - "types": [], - "noEmit": true, - "forceConsistentCasingInFileNames": true + "types": [] }, "files": [ - "index.d.ts", - "ol-tests.ts", + "array.d.ts", + "AssertionError.d.ts", + "asserts.d.ts", + "centerconstraint.d.ts", + "Collection.d.ts", + "CollectionEventType.d.ts", + "color.d.ts", + "colorlike.d.ts", "control/Attribution.d.ts", "control/Control.d.ts", - "control/Fullscreen.d.ts", + "control/FullScreen.d.ts", + "control/index.d.ts", "control/MousePosition.d.ts", "control/OverviewMap.d.ts", "control/Rotate.d.ts", "control/ScaleLine.d.ts", + "control/util.d.ts", "control/Zoom.d.ts", "control/ZoomSlider.d.ts", "control/ZoomToExtent.d.ts", + "coordinate.d.ts", + "css.d.ts", + "Disposable.d.ts", + "dom.d.ts", + "easing.d.ts", "events/condition.d.ts", "events/Event.d.ts", - "events/EventTarget.d.ts", + "events/EventType.d.ts", + "events/index.d.ts", + "events/KeyCode.d.ts", + "events/Target.d.ts", + "extent/Corner.d.ts", + "extent/index.d.ts", + "extent/Relationship.d.ts", + "Feature.d.ts", + "featureloader.d.ts", "format/EsriJSON.d.ts", "format/Feature.d.ts", - "format/filter.d.ts", + "format/filter/And.d.ts", + "format/filter/Bbox.d.ts", + "format/filter/Comparison.d.ts", + "format/filter/ComparisonBinary.d.ts", + "format/filter/Contains.d.ts", + "format/filter/During.d.ts", + "format/filter/EqualTo.d.ts", + "format/filter/Filter.d.ts", + "format/filter/GreaterThan.d.ts", + "format/filter/GreaterThanOrEqualTo.d.ts", + "format/filter/index.d.ts", + "format/filter/Intersects.d.ts", + "format/filter/IsBetween.d.ts", + "format/filter/IsLike.d.ts", + "format/filter/IsNull.d.ts", + "format/filter/LessThan.d.ts", + "format/filter/LessThanOrEqualTo.d.ts", + "format/filter/LogicalNary.d.ts", + "format/filter/Not.d.ts", + "format/filter/NotEqualTo.d.ts", + "format/filter/Or.d.ts", + "format/filter/Spatial.d.ts", + "format/filter/Within.d.ts", + "format/FormatType.d.ts", "format/GeoJSON.d.ts", + "format/GML.d.ts", "format/GML2.d.ts", "format/GML3.d.ts", + "format/GML32.d.ts", "format/GMLBase.d.ts", "format/GPX.d.ts", "format/IGC.d.ts", + "format/index.d.ts", "format/JSONFeature.d.ts", "format/KML.d.ts", "format/MVT.d.ts", "format/OSMXML.d.ts", + "format/OWS.d.ts", "format/Polyline.d.ts", "format/TextFeature.d.ts", "format/TopoJSON.d.ts", @@ -54,28 +102,64 @@ "format/WMSCapabilities.d.ts", "format/WMSGetFeatureInfo.d.ts", "format/WMTSCapabilities.d.ts", + "format/XLink.d.ts", "format/XML.d.ts", "format/XMLFeature.d.ts", + "format/xsd.d.ts", + "functions.d.ts", + "Geolocation.d.ts", "geom/Circle.d.ts", - "geom/GeometryCollection.d.ts", + "geom/flat/area.d.ts", + "geom/flat/center.d.ts", + "geom/flat/closest.d.ts", + "geom/flat/contains.d.ts", + "geom/flat/deflate.d.ts", + "geom/flat/flip.d.ts", + "geom/flat/geodesic.d.ts", + "geom/flat/inflate.d.ts", + "geom/flat/interiorpoint.d.ts", + "geom/flat/interpolate.d.ts", + "geom/flat/intersectsextent.d.ts", + "geom/flat/length.d.ts", + "geom/flat/orient.d.ts", + "geom/flat/reverse.d.ts", + "geom/flat/segments.d.ts", + "geom/flat/simplify.d.ts", + "geom/flat/straightchunk.d.ts", + "geom/flat/textpath.d.ts", + "geom/flat/topology.d.ts", + "geom/flat/transform.d.ts", "geom/Geometry.d.ts", + "geom/GeometryCollection.d.ts", + "geom/GeometryLayout.d.ts", + "geom/GeometryType.d.ts", + "geom/index.d.ts", "geom/LinearRing.d.ts", "geom/LineString.d.ts", - "geom/MultilineString.d.ts", + "geom/MultiLineString.d.ts", "geom/MultiPoint.d.ts", "geom/MultiPolygon.d.ts", "geom/Point.d.ts", "geom/Polygon.d.ts", "geom/SimpleGeometry.d.ts", + "Graticule.d.ts", + "has.d.ts", + "Image.d.ts", + "ImageBase.d.ts", + "ImageCanvas.d.ts", + "ImageState.d.ts", + "ImageTile.d.ts", + "index.d.ts", "interaction/DoubleClickZoom.d.ts", "interaction/DragAndDrop.d.ts", "interaction/DragBox.d.ts", "interaction/DragPan.d.ts", - "interaction/DragRotateAndZoom.d.ts", "interaction/DragRotate.d.ts", + "interaction/DragRotateAndZoom.d.ts", "interaction/DragZoom.d.ts", "interaction/Draw.d.ts", "interaction/Extent.d.ts", + "interaction/index.d.ts", "interaction/Interaction.d.ts", "interaction/KeyboardPan.d.ts", "interaction/KeyboardZoom.d.ts", @@ -84,95 +168,206 @@ "interaction/PinchRotate.d.ts", "interaction/PinchZoom.d.ts", "interaction/Pointer.d.ts", + "interaction/Property.d.ts", "interaction/Select.d.ts", "interaction/Snap.d.ts", "interaction/Translate.d.ts", + "Kinetic.d.ts", "layer/Base.d.ts", "layer/Group.d.ts", "layer/Heatmap.d.ts", "layer/Image.d.ts", + "layer/index.d.ts", "layer/Layer.d.ts", + "layer/Property.d.ts", "layer/Tile.d.ts", + "layer/TileProperty.d.ts", "layer/Vector.d.ts", + "layer/VectorRenderType.d.ts", "layer/VectorTile.d.ts", + "layer/VectorTileRenderType.d.ts", + "LayerType.d.ts", + "loadingstrategy.d.ts", + "Map.d.ts", + "MapBrowserEvent.d.ts", + "MapBrowserEventHandler.d.ts", + "MapBrowserEventType.d.ts", + "MapBrowserPointerEvent.d.ts", + "MapEvent.d.ts", + "MapEventType.d.ts", + "MapProperty.d.ts", + "math.d.ts", + "net.d.ts", + "obj.d.ts", + "Object.d.ts", + "ObjectEventType.d.ts", + "Observable.d.ts", + "Overlay.d.ts", + "OverlayPositioning.d.ts", + "pixel.d.ts", + "PluggableMap.d.ts", + "pointer/EventSource.d.ts", + "pointer/EventType.d.ts", + "pointer/MouseSource.d.ts", + "pointer/MsSource.d.ts", + "pointer/NativeSource.d.ts", "pointer/PointerEvent.d.ts", + "pointer/PointerEventHandler.d.ts", + "pointer/TouchSource.d.ts", + "proj/epsg3857.d.ts", + "proj/epsg4326.d.ts", "proj/index.d.ts", + "proj/proj4.d.ts", "proj/Projection.d.ts", - "render/canvas.d.ts", + "proj/projections.d.ts", + "proj/transforms.d.ts", + "proj/Units.d.ts", + "render/Box.d.ts", + "render/canvas/ImageReplay.d.ts", + "render/canvas/Immediate.d.ts", + "render/canvas/index.d.ts", + "render/canvas/Instruction.d.ts", + "render/canvas/LineStringReplay.d.ts", + "render/canvas/PolygonReplay.d.ts", + "render/canvas/Replay.d.ts", + "render/canvas/ReplayGroup.d.ts", + "render/canvas/TextReplay.d.ts", "render/Event.d.ts", + "render/EventType.d.ts", "render/Feature.d.ts", + "render/index.d.ts", + "render/replay.d.ts", + "render/ReplayGroup.d.ts", + "render/ReplayType.d.ts", "render/VectorContext.d.ts", + "render/webgl/CircleReplay.d.ts", + "render/webgl/circlereplay/defaultshader/index.d.ts", + "render/webgl/circlereplay/defaultshader/Locations.d.ts", + "render/webgl/ImageReplay.d.ts", + "render/webgl/Immediate.d.ts", + "render/webgl/index.d.ts", + "render/webgl/LineStringReplay.d.ts", + "render/webgl/linestringreplay/defaultshader/index.d.ts", + "render/webgl/linestringreplay/defaultshader/Locations.d.ts", + "render/webgl/PolygonReplay.d.ts", + "render/webgl/polygonreplay/defaultshader/index.d.ts", + "render/webgl/polygonreplay/defaultshader/Locations.d.ts", + "render/webgl/Replay.d.ts", + "render/webgl/ReplayGroup.d.ts", + "render/webgl/TextReplay.d.ts", + "render/webgl/TextureReplay.d.ts", + "render/webgl/texturereplay/defaultshader/index.d.ts", + "render/webgl/texturereplay/defaultshader/Locations.d.ts", + "renderer/canvas/ImageLayer.d.ts", + "renderer/canvas/IntermediateCanvas.d.ts", + "renderer/canvas/Layer.d.ts", + "renderer/canvas/Map.d.ts", + "renderer/canvas/TileLayer.d.ts", + "renderer/canvas/VectorLayer.d.ts", + "renderer/canvas/VectorTileLayer.d.ts", + "renderer/Layer.d.ts", + "renderer/Map.d.ts", + "renderer/vector.d.ts", + "renderer/webgl/defaultmapshader/index.d.ts", + "renderer/webgl/defaultmapshader/Locations.d.ts", + "renderer/webgl/ImageLayer.d.ts", + "renderer/webgl/Layer.d.ts", + "renderer/webgl/Map.d.ts", + "renderer/webgl/TileLayer.d.ts", + "renderer/webgl/tilelayershader/index.d.ts", + "renderer/webgl/tilelayershader/Locations.d.ts", + "renderer/webgl/VectorLayer.d.ts", + "reproj/common.d.ts", + "reproj/Image.d.ts", + "reproj/index.d.ts", + "reproj/Tile.d.ts", + "reproj/Triangulation.d.ts", + "resolutionconstraint.d.ts", + "rotationconstraint.d.ts", + "size.d.ts", "source/BingMaps.d.ts", "source/CartoDB.d.ts", "source/Cluster.d.ts", + "source/common.d.ts", + "source/Image.d.ts", "source/ImageArcGISRest.d.ts", "source/ImageCanvas.d.ts", - "source/Image.d.ts", "source/ImageMapGuide.d.ts", "source/ImageStatic.d.ts", - "source/ImageVector.d.ts", "source/ImageWMS.d.ts", + "source/index.d.ts", "source/OSM.d.ts", "source/Raster.d.ts", "source/Source.d.ts", "source/Stamen.d.ts", + "source/State.d.ts", + "source/Tile.d.ts", "source/TileArcGISRest.d.ts", "source/TileDebug.d.ts", - "source/Tile.d.ts", + "source/TileEventType.d.ts", "source/TileImage.d.ts", "source/TileJSON.d.ts", - "source/TileUTFGrid.d.ts", "source/TileWMS.d.ts", "source/UrlTile.d.ts", + "source/UTFGrid.d.ts", "source/Vector.d.ts", + "source/VectorEventType.d.ts", "source/VectorTile.d.ts", + "source/WMSServerType.d.ts", "source/WMTS.d.ts", + "source/WMTSRequestEncoding.d.ts", "source/XYZ.d.ts", "source/Zoomify.d.ts", + "sphere.d.ts", + "string.d.ts", + "structs/LinkedList.d.ts", + "structs/LRUCache.d.ts", + "structs/PriorityQueue.d.ts", + "structs/RBush.d.ts", + "style/Atlas.d.ts", "style/AtlasManager.d.ts", "style/Circle.d.ts", "style/Fill.d.ts", "style/Icon.d.ts", + "style/IconAnchorUnits.d.ts", + "style/IconImage.d.ts", + "style/IconImageCache.d.ts", + "style/IconOrigin.d.ts", "style/Image.d.ts", + "style/index.d.ts", "style/RegularShape.d.ts", "style/Stroke.d.ts", "style/Style.d.ts", "style/Text.d.ts", + "style/TextPlacement.d.ts", + "Tile.d.ts", + "TileCache.d.ts", + "tilecoord.d.ts", + "tilegrid/common.d.ts", + "tilegrid/index.d.ts", "tilegrid/TileGrid.d.ts", "tilegrid/WMTS.d.ts", - "AssertionError/index.d.ts", - "Attribution/index.d.ts", - "Collection/index.d.ts", - "color/index.d.ts", - "colorlike/index.d.ts", - "control/index.d.ts", - "coordinate/index.d.ts", - "deviceorientation/index.d.ts", - "Disposable/index.d.ts", - "easing/index.d.ts", - "events/index.d.ts", - "extent/index.d.ts", - "Feature/index.d.ts", - "featureloader/index.d.ts", - "Geolocation/index.d.ts", - "Graticule/index.d.ts", - "ImageBase/index.d.ts", - "Image/index.d.ts", - "ImageTile/index.d.ts", - "interaction/index.d.ts", - "Kinetic/index.d.ts", - "loadingstrategy/index.d.ts", - "MapBrowserEvent/index.d.ts", - "MapBrowserPointerEvent/index.d.ts", - "MapEvent/index.d.ts", - "Map/index.d.ts", - "Object/index.d.ts", - "Observable/index.d.ts", - "Overlay/index.d.ts", - "sphere/index.d.ts", - "Tile/index.d.ts", - "tilegrid/index.d.ts", - "VectorTile/index.d.ts", - "View/index.d.ts" + "TileQueue.d.ts", + "TileRange.d.ts", + "TileState.d.ts", + "tileurlfunction.d.ts", + "transform.d.ts", + "uri.d.ts", + "util.d.ts", + "vec/mat4.d.ts", + "VectorImageTile.d.ts", + "VectorTile.d.ts", + "View.d.ts", + "ViewHint.d.ts", + "ViewProperty.d.ts", + "webgl/Buffer.d.ts", + "webgl/Context.d.ts", + "webgl/ContextEventType.d.ts", + "webgl/Fragment.d.ts", + "webgl/index.d.ts", + "webgl/Shader.d.ts", + "webgl/Vertex.d.ts", + "WebGLMap.d.ts", + "xml.d.ts" ] -} +} \ No newline at end of file diff --git a/types/ol/tslint.json b/types/ol/tslint.json index 3db14f85ea..d0cf9d5e80 100644 --- a/types/ol/tslint.json +++ b/types/ol/tslint.json @@ -1 +1,12 @@ -{ "extends": "dtslint/dt.json" } +{ + "extends": "dtslint/dt.json", + "rules": { + "adjacent-overload-signatures": false, + "array-type": false, + "max-line-length": false, + "no-self-import": false, + "no-unnecessary-class": false, + "no-unnecessary-generics": false, + "unified-signatures": false + } +} \ No newline at end of file diff --git a/types/ol/uri.d.ts b/types/ol/uri.d.ts new file mode 100644 index 0000000000..2d85ace8a9 --- /dev/null +++ b/types/ol/uri.d.ts @@ -0,0 +1 @@ +export function appendParams(uri: string, params: { [key: string]: any }): string; diff --git a/types/ol/util.d.ts b/types/ol/util.d.ts new file mode 100644 index 0000000000..566dbb6e05 --- /dev/null +++ b/types/ol/util.d.ts @@ -0,0 +1,2 @@ +export function abstract(): any; +export const VERSION: string; diff --git a/types/ol/vec/mat4.d.ts b/types/ol/vec/mat4.d.ts new file mode 100644 index 0000000000..c81a7434eb --- /dev/null +++ b/types/ol/vec/mat4.d.ts @@ -0,0 +1,3 @@ +import { Transform } from 'ol/transform'; +export function create(): number[]; +export function fromTransform(mat4: number[], transform: Transform): number[]; diff --git a/types/ol/webgl/Buffer.d.ts b/types/ol/webgl/Buffer.d.ts new file mode 100644 index 0000000000..0faceedbe8 --- /dev/null +++ b/types/ol/webgl/Buffer.d.ts @@ -0,0 +1,5 @@ +export default class WebGLBuffer { + constructor(opt_arr?: number[], opt_usage?: number); + getArray(): number[]; + getUsage(): number; +} diff --git a/types/ol/webgl/Context.d.ts b/types/ol/webgl/Context.d.ts new file mode 100644 index 0000000000..815deae924 --- /dev/null +++ b/types/ol/webgl/Context.d.ts @@ -0,0 +1,24 @@ +import Disposable from 'ol/Disposable'; +import WebGLBuffer from 'ol/webgl/Buffer'; +import WebGLFragment from 'ol/webgl/Fragment'; +import WebGLShader from 'ol/webgl/Shader'; +import WebGLVertex from 'ol/webgl/Vertex'; +export function createEmptyTexture(gl: WebGLRenderingContext, width: number, height: number, opt_wrapS?: number, opt_wrapT?: number): WebGLTexture; +export function createTexture(gl: WebGLRenderingContext, image: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement, opt_wrapS?: number, opt_wrapT?: number): WebGLTexture; +export interface BufferCacheEntry { + buf: WebGLBuffer; + buffer: WebGLBuffer; +} +export default class WebGLContext extends Disposable { + constructor(canvas: HTMLCanvasElement, gl: WebGLRenderingContext); + bindBuffer(target: number, buf: WebGLBuffer): void; + deleteBuffer(buf: WebGLBuffer): void; + getCanvas(): HTMLCanvasElement; + getGL(): WebGLRenderingContext; + getHitDetectionFramebuffer(): WebGLFramebuffer; + getProgram(fragmentShaderObject: WebGLFragment, vertexShaderObject: WebGLVertex): WebGLProgram; + getShader(shaderObject: WebGLShader): WebGLShader; + handleWebGLContextLost(): void; + handleWebGLContextRestored(): void; + useProgram(program: WebGLProgram): boolean; +} diff --git a/types/ol/webgl/ContextEventType.d.ts b/types/ol/webgl/ContextEventType.d.ts new file mode 100644 index 0000000000..d709178fe5 --- /dev/null +++ b/types/ol/webgl/ContextEventType.d.ts @@ -0,0 +1,6 @@ +declare enum ContextEventType { + LOST = 'webglcontextlost', + RESTORED = 'webglcontextrestored', +} + +export default ContextEventType; diff --git a/types/ol/webgl/Fragment.d.ts b/types/ol/webgl/Fragment.d.ts new file mode 100644 index 0000000000..e14fdca6c5 --- /dev/null +++ b/types/ol/webgl/Fragment.d.ts @@ -0,0 +1,4 @@ +import WebGLShader from 'ol/webgl/Shader'; +export default class WebGLFragment extends WebGLShader { + constructor(source: string); +} diff --git a/types/ol/webgl/Shader.d.ts b/types/ol/webgl/Shader.d.ts new file mode 100644 index 0000000000..d49bf5a4b1 --- /dev/null +++ b/types/ol/webgl/Shader.d.ts @@ -0,0 +1,6 @@ +export default class WebGLShader { + constructor(source: string); + getSource(): string; + getType(): number; + isAnimated(): boolean; +} diff --git a/types/ol/webgl/Vertex.d.ts b/types/ol/webgl/Vertex.d.ts new file mode 100644 index 0000000000..aff112356c --- /dev/null +++ b/types/ol/webgl/Vertex.d.ts @@ -0,0 +1,4 @@ +import WebGLShader from 'ol/webgl/Shader'; +export default class WebGLVertex extends WebGLShader { + constructor(source: string); +} diff --git a/types/ol/webgl/index.d.ts b/types/ol/webgl/index.d.ts new file mode 100644 index 0000000000..33edd36679 --- /dev/null +++ b/types/ol/webgl/index.d.ts @@ -0,0 +1,2 @@ +export function getContext(canvas: HTMLCanvasElement, opt_attributes?: { [key: string]: any }): WebGLRenderingContext; +export const HAS: boolean; diff --git a/types/ol/xml.d.ts b/types/ol/xml.d.ts new file mode 100644 index 0000000000..eaa74cea67 --- /dev/null +++ b/types/ol/xml.d.ts @@ -0,0 +1,24 @@ +export function createElementNS(namespaceURI: string, qualifiedName: string): Element; +export function getAllTextContent(node: Node, normalizeWhitespace: boolean): string; +export function getAttributeNS(node: Element, namespaceURI: string, name: string): string; +export function isDocument(object: { [key: string]: any }): boolean; +export function makeArrayExtender(valueReader: ((this: T, param1: Node, param2: any[]) => any[]), opt_this?: T): Parser; +export function makeArrayPusher(valueReader: ((this: T, param1: Element, param2: any[]) => void), opt_this?: T): Parser; +export function makeArraySerializer(nodeWriter: ((this: T, param1: Element, param2: V, param3: any[]) => void), opt_this?: T): Serializer; +export function makeChildAppender(nodeWriter: ((this: T, param1: Node, param2: V, param3: any[]) => void), opt_this?: T): Serializer; +export function makeObjectPropertyPusher(valueReader: ((this: T, param1: Element, param2: any[]) => void), opt_property?: string, opt_this?: T): Parser; +export function makeObjectPropertySetter(valueReader: ((this: T, param1: Element, param2: any[]) => void), opt_property?: string, opt_this?: T): Parser; +export function makeReplacer(valueReader: ((this: T, param1: Node, param2: any[]) => void), opt_this?: T): Parser; +export function makeSequence(object: { [key: string]: V }, orderedKeys: string[]): V[]; +export function makeSimpleNodeFactory(opt_nodeName?: string, opt_namespaceURI?: string): ((param0: any, param1: any[], param2: string) => Node); +export function makeStructureNS(namespaceURIs: string[], structure: T, opt_structureNS?: { [key: string]: T }): { [key: string]: T }; +export function parse(xml: string): Document; +export function parseNode(parsersNS: { [key: string]: { [key: string]: Parser } }, node: Element, objectStack: any[], opt_this?: any): void; +export function pushParseAndPop(object: T, parsersNS: { [key: string]: { [key: string]: Parser } }, node: Element, objectStack: any[], opt_this?: any): T; +export function pushSerializeAndPop(object: O, serializersNS: { [key: string]: { [key: string]: Serializer } }, nodeFactory: ((this: T, param1: any, param2: any[], param3: string) => Node), values: any[], objectStack: any[], opt_keys?: string[], opt_this?: T): O; +export function serialize(serializersNS: { [key: string]: { [key: string]: Serializer } }, nodeFactory: ((this: T, param1: any, param2: any[], param3: string) => Node), values: any[], objectStack: any[], opt_keys?: string[], opt_this?: T): void; +export interface NodeStackItem { + node: Node; +} +export type Parser = ((param0: Element, param1: any[]) => void); +export type Serializer = ((param0: Element, param1: any, param2: any[]) => void);