[@types/ol] Update to OpenLayers v6.2.1 (#43221)

types/ol/OTHER_FILES.txt

@@ -64,6 +64,7 @@ render/Box.d.ts
 render/canvas/Builder.d.ts
 render/canvas/BuilderGroup.d.ts
 render/canvas/BuilderType.d.ts
+render/canvas/Executor.d.ts
 render/canvas/ExecutorGroup.d.ts
 render/canvas/hitdetet.d.ts
 render/canvas/ImageBuilder.d.ts

types/ol/Tile.d.ts

@@ -21,5 +21,6 @@ export default abstract class Tile extends Target {
     inTransition(id: string): boolean;
     abstract load(): void;
     refreshInterimChain(): void;
+    release(): void;
     setState(state: TileState): void;
 }

types/ol/TileCache.d.ts

@@ -4,7 +4,7 @@ import LRUCache from './structs/LRUCache';
 import TileRange from './TileRange';
 
 export default class TileCache extends LRUCache<any> {
-    constructor(opt_highWaterMark?: number);
+    constructor();
     expireCache(usedTiles: { [key: string]: TileRange }): void;
     pruneExceptNewestZ(): void;
     on(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];

types/ol/TileState.d.ts

@@ -4,7 +4,6 @@ declare enum TileState {
     LOADED = 2,
     ERROR = 3,
     EMPTY = 4,
-    ABORT = 5,
 }
 
 export default TileState;

types/ol/VectorRenderTile.d.ts

@@ -3,7 +3,6 @@ import { OrderFunction } from './render';
 import Source from './source/Source';
 import Tile from './Tile';
 import { TileCoord } from './tilecoord';
-import TileGrid from './tilegrid/TileGrid';
 import TileState from './TileState';
 import VectorTile from './VectorTile';
 
@@ -22,9 +21,7 @@ export default class VectorRenderTile extends Tile {
         tileCoord: TileCoord,
         state: TileState,
         urlTileCoord: TileCoord,
-        sourceTileGrid: TileGrid,
         getSourceTiles: (p0: VectorRenderTile) => VectorTile[],
-        removeSourceTiles: (p0: VectorRenderTile) => void,
     );
     getContext(layer: Layer<Source>): CanvasRenderingContext2D;
     getImage(layer: Layer<Source>): HTMLCanvasElement;

types/ol/View.d.ts

@@ -72,6 +72,7 @@ export interface ViewOptions {
     multiWorld?: boolean;
     constrainResolution?: boolean;
     smoothResolutionConstraint?: boolean;
+    showFullExtent?: boolean;
     projection?: ProjectionLike;
     resolution?: number;
     resolutions?: number[];
@@ -139,6 +140,7 @@ export default class View extends BaseObject {
     setMinZoom(zoom: number): void;
     setResolution(resolution: number | undefined): void;
     setRotation(rotation: number): void;
+    setViewportSize(opt_size?: Size): void;
     setZoom(zoom: number): void;
     updateAnimations_(): void;
     on(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];

types/ol/control/Control.d.ts

@@ -14,6 +14,7 @@ export default class Control extends BaseObject {
     protected element: HTMLElement;
     protected listenerKeys: EventsKey[];
     getMap(): PluggableMap;
+    render(mapEvent: MapEvent): void;
     setMap(map: PluggableMap): void;
     setTarget(target: HTMLElement | string): void;
     on(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];

types/ol/dom.d.ts

@@ -1,4 +1,8 @@
-export function createCanvasContext2D(opt_width?: number, opt_height?: number): CanvasRenderingContext2D;
+export function createCanvasContext2D(
+    opt_width?: number,
+    opt_height?: number,
+    opt_canvasPool?: HTMLCanvasElement[],
+): CanvasRenderingContext2D;
 export function outerHeight(element: HTMLElement): number;
 export function outerWidth(element: HTMLElement): number;
 export function removeChildren(node: Node): void;

types/ol/events/EventType.d.ts

@@ -14,6 +14,7 @@ declare enum EventType {
     KEYPRESS = 'keypress',
     LOAD = 'load',
     RESIZE = 'resize',
+    TOUCHMOVE = 'touchmove',
     WHEEL = 'wheel',
 }
 

types/ol/format/KML.d.ts

@@ -29,6 +29,7 @@ export interface Options {
     showPointNames?: boolean;
     defaultStyle?: Style[];
     writeStyles?: boolean;
+    crossOrigin?: string;
 }
 export interface Vec2 {
     x: number;

types/ol/index.d.ts

@@ -1,11 +1,11 @@
-// Type definitions for ol 6.1
+// Type definitions for ol 6.2
 // Project: https://github.com/openlayers/openlayers, https://openlayers.org
 // Definitions by: Rifa'i M. Hanif <https://github.com/hanreev>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 3.1
 // Minimum TypeScript Version: 3.1
 
-// These definitions was generated using jsdoc. See https://github.com/hanreev/types-ol
+// These definitions is generated using jsdoc. See https://github.com/hanreev/types-ol
 
 export { default as AssertionError } from './AssertionError';
 export { default as Collection } from './Collection';

types/ol/interaction/Draw.d.ts

@@ -10,11 +10,12 @@ import LineString from '../geom/LineString';
 import SimpleGeometry from '../geom/SimpleGeometry';
 import VectorLayer from '../layer/Vector';
 import { ObjectEvent } from '../Object';
+import Projection from '../proj/Projection';
 import VectorSource from '../source/Vector';
 import { StyleFunction, StyleLike } from '../style/Style';
 import PointerInteraction from './Pointer';
 
-export type GeometryFunction = (p0: SketchCoordType, p1?: SimpleGeometry) => SimpleGeometry;
+export type GeometryFunction = (p0: SketchCoordType, p1: SimpleGeometry | undefined, p2: Projection) => SimpleGeometry;
 export type LineCoordType = Coordinate[];
 export interface Options {
     type: GeometryType;
@@ -44,6 +45,7 @@ export enum DrawEventType {
 }
 export default class Draw extends PointerInteraction {
     constructor(options: Options);
+    appendCoordinates(coordinates: LineCoordType): void;
     extend(feature: Feature<LineString>): void;
     finishDrawing(): void;
     getOverlay(): VectorLayer;

types/ol/interaction/MouseWheelZoom.d.ts

@@ -11,10 +11,6 @@ export interface Options {
     timeout?: number;
     useAnchor?: boolean;
 }
-export enum Mode {
-    TRACKPAD = 'trackpad',
-    WHEEL = 'wheel',
-}
 export default class MouseWheelZoom extends Interaction {
     constructor(opt_options?: Options);
     setMouseAnchor(useAnchor: boolean): void;

types/ol/interaction/Pointer.d.ts

@@ -22,6 +22,7 @@ export default class PointerInteraction extends Interaction {
     protected handleDragEvent(mapBrowserEvent: MapBrowserPointerEvent): void;
     protected handleMoveEvent(mapBrowserEvent: MapBrowserPointerEvent): void;
     protected handleUpEvent(mapBrowserEvent: MapBrowserPointerEvent): boolean;
+    getPointerCount(): number;
     stopDown(handled: boolean): boolean;
     on(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
     once(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];

types/ol/layer/Graticule.d.ts

@@ -40,6 +40,7 @@ export default class Graticule extends VectorLayer {
     getMeridians(): LineString[];
     getParallels(): LineString[];
     loaderFunction(extent: Extent, resolution: number, projection: Projection): void;
+    strategyFunction(extent: Extent, resolution: number): Extent[];
     on(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
     once(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
     un(type: string | string[], listener: (p0: any) => void): void;

types/ol/layer/VectorTileRenderType.d.ts

@@ -1,6 +1,7 @@
 declare enum VectorTileRenderType {
     IMAGE = 'image',
     HYBRID = 'hybrid',
+    VECTOR = 'vector',
 }
 
 export default VectorTileRenderType;

types/ol/ol-tests.ts

@@ -26,6 +26,7 @@ import { Circle, Fill, Stroke, Style } from 'ol/style';
 import { StyleFunction } from 'ol/style/Style';
 
 import proj4 = require('proj4');
+
 /**
  * ==================================================
  * # Styles
@@ -333,7 +334,7 @@ const view = new View({
 });
 
 const map = new Map({
-    target: document.getElementById('map') as HTMLElement,
+    target: 'map',
     view,
     layers,
     controls,

types/ol/render/canvas.d.ts

@@ -2,7 +2,6 @@ import { ColorLike } from '../colorlike';
 import Fill from '../style/Fill';
 import Stroke from '../style/Stroke';
 import { Transform } from '../transform';
-import LabelCache from './canvas/LabelCache';
 
 export type DeclutterGroup = any[];
 export type DeclutterGroups = DeclutterGroup[];
@@ -28,6 +27,11 @@ export interface FillStrokeState {
     lineWidth?: number;
     miterLimit?: number;
 }
+export interface Label {
+    width: number;
+    height: number;
+    contextInstructions: (string | number)[];
+}
 export interface StrokeState {
     lineCap: CanvasLineCap;
     lineDash: number[];
@@ -49,12 +53,12 @@ export interface TextState {
     scale?: number;
     padding?: number[];
 }
-export const labelCache: LabelCache;
-export function drawImage(
+export const labelCache: any;
+export function drawImageOrLabel(
     context: CanvasRenderingContext2D,
     transform: Transform | null,
     opacity: number,
-    image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement,
+    labelOrImage: Label | HTMLCanvasElement | HTMLImageElement | HTMLVideoElement,
     originX: number,
     originY: number,
     w: number,

types/ol/render/canvas/Executor.d.ts

@@ -1,9 +1,8 @@
 import { Coordinate } from '../../coordinate';
-import Disposable from '../../Disposable';
 import { Extent } from '../../extent';
 import { FeatureLike } from '../../Feature';
 import { Transform } from '../../transform';
-import { DeclutterGroup, FillState, StrokeState, TextState } from '../canvas';
+import { DeclutterGroup, FillState, Label, StrokeState, TextState } from '../canvas';
 
 export interface SerializableInstructions {
     instructions: any[];
@@ -13,7 +12,7 @@ export interface SerializableInstructions {
     fillStates: { [key: string]: FillState };
     strokeStates: { [key: string]: StrokeState };
 }
-export default class Executor extends Disposable {
+export default class Executor {
     constructor(resolution: number, pixelRatio: number, overlaps: boolean, instructions: SerializableInstructions);
     protected coordinates: number[];
     protected hitDetectionInstructions: any[];
@@ -21,6 +20,7 @@ export default class Executor extends Disposable {
     protected overlaps: boolean;
     protected pixelRatio: number;
     protected resolution: number;
+    createLabel(text: string, textKey: string, fillKey: string, strokeKey: string): Label;
     execute(context: CanvasRenderingContext2D, transform: Transform, viewRotation: number, snapToPixel: boolean): void;
     executeHitDetection<T>(
         context: CanvasRenderingContext2D,
@@ -29,13 +29,12 @@ export default class Executor extends Disposable {
         opt_featureCallback?: () => void,
         opt_hitExtent?: Extent,
     ): T;
-    getTextImage(text: string, textKey: string, fillKey: string, strokeKey: string): HTMLCanvasElement;
     renderDeclutter(declutterGroup: DeclutterGroup, feature: FeatureLike, opacity: number, declutterTree: any): any;
-    replayImage_(
+    replayImageOrLabel_(
         context: CanvasRenderingContext2D,
         x: number,
         y: number,
-        image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement,
+        imageOrLabel: Label | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement,
         anchorX: number,
         anchorY: number,
         declutterGroup: DeclutterGroup,

types/ol/render/canvas/ExecutorGroup.d.ts

@@ -1,5 +1,4 @@
 import { Coordinate } from '../../coordinate';
-import Disposable from '../../Disposable';
 import { Extent } from '../../extent';
 import { FeatureLike } from '../../Feature';
 import { DeclutterItems } from '../../PluggableMap';
@@ -8,7 +7,7 @@ import { DeclutterGroup } from '../canvas';
 import { SerializableInstructions } from './Builder';
 import BuilderType from './BuilderType';
 
-export default class ExecutorGroup extends Disposable {
+export default class ExecutorGroup {
     constructor(
         maxExtent: Extent,
         resolution: number,

types/ol/render/canvas/LabelCache.d.ts

@@ -1,18 +0,0 @@
-import { EventsKey } from '../../events';
-import BaseEvent from '../../events/Event';
-import LRUCache from '../../structs/LRUCache';
-import Executor from './Executor';
-
-export default class LabelCache extends LRUCache<any> {
-    constructor();
-    release(consumer: Executor): void;
-    on(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
-    once(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
-    un(type: string | string[], listener: (p0: any) => void): void;
-    on(type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
-    once(type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
-    un(type: 'change', listener: (evt: BaseEvent) => void): void;
-    on(type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
-    once(type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
-    un(type: 'error', listener: (evt: BaseEvent) => void): void;
-}

types/ol/resolutionconstraint.d.ts

@@ -7,6 +7,7 @@ export function createMinMaxResolution(
     minResolution: number,
     opt_smooth?: boolean,
     opt_maxExtent?: Extent,
+    opt_showFullExtent?: boolean,
 ): Type;
 export function createSnapToPower(
     power: number,
@@ -14,5 +15,11 @@ export function createSnapToPower(
     opt_minResolution?: number,
     opt_smooth?: boolean,
     opt_maxExtent?: Extent,
+    opt_showFullExtent?: boolean,
+): Type;
+export function createSnapToResolutions(
+    resolutions: number[],
+    opt_smooth?: boolean,
+    opt_maxExtent?: Extent,
+    opt_showFullExtent?: boolean,
 ): Type;
-export function createSnapToResolutions(resolutions: number[], opt_smooth?: boolean, opt_maxExtent?: Extent): Type;

types/ol/size.d.ts

@@ -1,4 +1,4 @@
-export type Size = number[];
+export type Size = [number, number];
 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;

types/ol/source/IIIF.d.ts

@@ -33,7 +33,7 @@ export interface Options {
     zDirection?: number;
 }
 export default class IIIF extends TileImage {
-    constructor(opt_options: Options);
+    constructor(opt_options?: Options);
     on(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
     once(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
     un(type: string | string[], listener: (p0: any) => void): void;

types/ol/source/VectorTile.d.ts

@@ -1,6 +1,7 @@
 import { EventsKey } from '../events';
 import BaseEvent from '../events/Event';
 import { Extent } from '../extent';
+import { FeatureLike } from '../Feature';
 import FeatureFormat from '../format/Feature';
 import { ObjectEvent } from '../Object';
 import { ProjectionLike } from '../proj';
@@ -40,12 +41,11 @@ export interface Options {
 export default class VectorTile extends UrlTile {
     constructor(options: Options);
     protected tileClass: VectorTile_1;
-    addSourceTiles(tile: VectorRenderTile, sourceTiles: VectorTile_1[]): void;
     clear(): void;
+    getFeaturesInExtent(extent: Extent): FeatureLike[];
     getOverlaps(): boolean;
     getSourceTiles(pixelRatio: number, projection: Projection, tile: VectorRenderTile): VectorTile_1[];
     getTile(z: number, x: number, y: number, pixelRatio: number, projection: Projection): Tile;
-    removeSourceTiles(tile: VectorRenderTile): void;
     on(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
     once(type: string | string[], listener: (p0: any) => void): EventsKey | EventsKey[];
     un(type: string | string[], listener: (p0: any) => void): void;

types/ol/source/Zoomify.d.ts

@@ -7,7 +7,6 @@ import { ProjectionLike } from '../proj';
 import { Size } from '../size';
 import { LoadFunction, Options as Options_1 } from '../Tile';
 import { TileCoord } from '../tilecoord';
-import TileGrid from '../tilegrid/TileGrid';
 import TileState from '../TileState';
 import { AttributionLike } from './Source';
 import { TileSourceEvent } from './Tile';
@@ -30,8 +29,7 @@ export interface Options {
 }
 export class CustomTile extends ImageTile {
     constructor(
-        tilePixelRatio: number,
-        tileGrid: TileGrid,
+        tileSize: Size,
         tileCoord: TileCoord,
         state: TileState,
         src: string,

types/ol/structs/LRUCache.d.ts

@@ -1,6 +1,5 @@
 import { EventsKey } from '../events';
 import BaseEvent from '../events/Event';
-import Target from '../events/Target';
 
 export interface Entry {
     key_: string;
@@ -8,7 +7,7 @@ export interface Entry {
     older: any;
     value_: any;
 }
-export default class LRUCache<T> extends Target {
+export default class LRUCache<T> {
     constructor(opt_highWaterMark?: number);
     canExpireCache(): boolean;
     clear(): void;

types/ol/style/Circle.d.ts

@@ -6,6 +6,7 @@ export interface Options {
     fill?: Fill;
     radius: number;
     stroke?: Stroke;
+    displacement?: number[];
 }
 export default class CircleStyle extends RegularShape {
     constructor(opt_options?: Options);

types/ol/style/Icon.d.ts

@@ -15,6 +15,7 @@ export interface Options {
     crossOrigin?: string;
     img?: HTMLImageElement | HTMLCanvasElement;
     offset?: number[];
+    displacement?: number[];
     offsetOrigin?: IconOrigin;
     opacity?: number;
     scale?: number;

types/ol/style/Image.d.ts

@@ -7,11 +7,13 @@ export interface Options {
     rotateWithView: boolean;
     rotation: number;
     scale: number;
+    displacement: number[];
 }
 export default abstract class ImageStyle {
     constructor(options: Options);
     clone(): ImageStyle;
     abstract getAnchor(): number[];
+    getDisplacement(): number[];
     abstract getHitDetectionImage(pixelRatio: number): HTMLCanvasElement | HTMLVideoElement | HTMLImageElement;
     abstract getHitDetectionImageSize(): Size;
     abstract getImage(pixelRatio: number): HTMLCanvasElement | HTMLVideoElement | HTMLImageElement;

types/ol/style/LiteralStyle.d.ts

@@ -13,6 +13,7 @@ export interface LiteralSymbolStyle {
     src?: string;
     color?: Color | ExpressionValue[] | string;
     opacity?: ExpressionValue;
+    rotation?: ExpressionValue;
     offset?: ExpressionValue[];
     textureCoord?: ExpressionValue[];
     rotateWithView?: boolean;

types/ol/style/RegularShape.d.ts

@@ -13,6 +13,7 @@ export interface Options {
     radius1?: number;
     radius2?: number;
     angle?: number;
+    displacement?: number[];
     stroke?: Stroke;
     rotation?: number;
     rotateWithView?: boolean;

types/ol/tilegrid/WMTS.d.ts

@@ -12,7 +12,6 @@ export interface Options {
     sizes?: Size[];
     tileSize?: number | Size;
     tileSizes?: Size[];
-    widths?: number[];
 }
 export default class WMTSTileGrid extends TileGrid {
     constructor(options: Options);

types/ol/transform.d.ts

@@ -13,6 +13,15 @@ export function compose(
     dx2: number,
     dy2: number,
 ): Transform;
+export function composeCssTransform(
+    dx1: number,
+    dy1: number,
+    sx: number,
+    sy: number,
+    angle: number,
+    dx2: number,
+    dy2: number,
+): string;
 export function create(): Transform;
 export function determinant(mat: Transform): number;
 export function invert(source: Transform): Transform;

types/ol/webgl/ShaderBuilder.d.ts

@@ -26,6 +26,7 @@ export class ShaderBuilder {
     getTextureCoordinateExpression(): string;
     setColorExpression(expression: string): ShaderBuilder;
     setFragmentDiscardExpression(expression: string): ShaderBuilder;
+    setRotationExpression(expression: string): ShaderBuilder;
     setSizeExpression(expression: string): ShaderBuilder;
     setSymbolOffsetExpression(expression: string): ShaderBuilder;
     setSymbolRotateWithView(rotateWithView: boolean): ShaderBuilder;

types/ol/xml.d.ts

@@ -6,6 +6,8 @@ export type Serializer = (p0: Element, p1: any, p2: any[]) => void;
 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 getDocument(): Document;
+export function getXMLSerializer(): XMLSerializer;
 export function isDocument(object: any): boolean;
 export function makeArrayExtender<T>(valueReader: (this: T, p0: Node, p1: any[]) => any[], opt_this?: T): Parser;
 export function makeArrayPusher<T>(valueReader: (this: T, p0: Element, p1: any[]) => any, opt_this?: T): Parser;
@@ -61,6 +63,8 @@ export function pushSerializeAndPop<O, T>(
     opt_keys?: string[],
     opt_this?: T,
 ): O;
+export function registerDocument(document: Document): void;
+export function registerXMLSerializer(xmlSerializer: XMLSerializer): void;
 export function serialize<T>(
     serializersNS: { [key: string]: { [key: string]: Serializer } },
     nodeFactory: (this: T, p0: any, p1: any[], p2: string | undefined) => Node,