@opengeoweb/webmap 9.20.2 → 9.22.0

package/src/lib/components/WMJSMap.d.ts

@@ -1,89 +1,47 @@
 import WMImageStore from './WMImageStore';
-import WMBBOX from './WMBBOX';
+import WMBBOX, { Bbox } from './WMBBOX';
+import { WMProjectionWH } from './WMProjection';
 import WMListener from './WMListener';
 import { CanvasBBOX, CanvasGeoLayer } from './WMCanvasBuffer';
-import { proj4 } from './WMJSExternalDependencies';
 import WMJSDimension from './WMJSDimension';
 import MapPin from './WMMapPin';
 import WMLayer from './WMLayer';
-import { AnimationStep, Dimension, LinkedInfo } from './types';
+import { AnimationStep, IWMProj4, IWMJSMapMouseCoordinates } from './types';
 import { WMMemo } from './WMMemo';
 import type { TileServerDefinition, TileServerSettings } from '../utils';
-export declare const detectLeftButton: (evt: MouseEvent) => boolean;
-export declare const detectRightButton: (evt: MouseEvent) => boolean;
-export declare const getErrorsToDisplay: (canvasErrors: LinkedInfo[], getLayerByServiceAndName: (layerservice: string, layername: string) => WMLayer) => string[];
+import type IWMJSMap from './IWMJSMap';
+export declare const bgMapImageStore: WMImageStore;
 /**
-/**
-  * WMJSMap class
-  */
-export default class WMJSMap {
-    prefetchLayerImagesForTimeMemo: WMMemo;
-    shouldPrefetch: boolean;
-    mapPin: MapPin;
-    mapdimensions: WMJSDimension[];
-    timestepInMinutes: number | undefined;
-    stopAnimating: () => void;
-    enableAutoPrefetching: boolean;
-    showLayerInfo: boolean;
-    isAnimating: boolean;
-    animationDelay: number;
-    animationList: AnimationStep[] | string | undefined;
-    _animationList: AnimationStep[] | string | undefined;
-    currentAnimationStep: number;
-    initialAnimationStep: number;
-    setAnimationDelay: (delay: number) => void;
-    mouseHoverAnimationBox: boolean;
-    loadingDiv: HTMLElement;
-    baseDiv: HTMLElement;
-    mapZooming: 0 | 1;
-    mouseX: number;
-    mouseDownX: number;
-    mouseY: number;
-    mouseDownY: number;
-    private WebMapJSMapVersion;
-    private mainElement;
-    private srs;
-    private resizeBBOX;
-    private defaultBBOX;
-    private width;
-    private height;
-    private layers;
-    private baseLayers;
-    private numBaseLayers;
-    private _map?;
-    private renderer?;
-    private layersBusy?;
-    private mapBusy?;
-    private hasGeneratedId?;
-    private divZoomBox;
-    private divBoundingBox;
-    private divDimInfo;
+ * WMJSMap class
+ */
+export default class WMJSMap implements IWMJSMap {
+    private _mouseX;
+    private _mouseDownX;
+    private _mouseY;
+    private _mouseDownY;
+    private _enableAutoPrefetching;
+    private _WebMapJSMapVersion;
+    private _mainElement;
+    private _srs;
+    private _width;
+    private _height;
+    private _layers;
+    private _baseLayers;
+    private _numBaseLayers;
+    private _divZoomBox;
+    private _divBoundingBox;
+    private _divDimInfo;
     private _displayLegendInMap;
-    private bbox;
-    updateBBOX: WMBBOX;
-    private loadedBBOX?;
-    drawnBBOX: WMBBOX;
+    private _mapHeader;
+    private _currentCursor;
+    private _mapIsActivated;
+    private _isMapHeaderEnabled;
+    private _showScaleBarInMap;
+    private _showCursorCoordinates;
+    private _wmEventListener;
     private canvasLayerBuffer;
-    private mapHeader;
-    private currentCursor;
-    private mapIsActivated;
-    private isMapHeaderEnabled;
-    private showScaleBarInMap;
-    private showCursorCoordinates;
-    private callBack;
-    initialized: boolean;
-    isDestroyed: boolean;
     private internalMapId;
-    private suspendDrawing;
     private activeLayer;
-    private MaxUndos;
-    private NrOfUndos;
-    private UndoPointer;
-    private DoUndo;
-    private DoRedo;
-    private WMProjectionUndo;
-    private WMProjectionTempUndo;
-    private gfiDialogList;
     private setTimeOffsetValue;
     private setMessageValue;
     private canvasErrors;
@@ -93,74 +51,118 @@ export default class WMJSMap {
     private wmTileRenderer;
     private mouseWheelBusy;
     private wMFlyToBBox;
-    private mouseWheelEventBBOXCurrent;
-    private mouseWheelEventBBOXNew;
+    private _mouseWheelEventBBOXCurrent;
+    private _mouseWheelEventBBOXNew;
     private mouseUpX;
     private mouseUpY;
     private mouseDragging;
-    private controlsBusy;
     private mouseDownPressed;
     private mapMode;
-    private numGetFeatureInfoRequests;
     private oldMapMode;
-    private InValidMouseAction;
     private resizingBBOXCursor;
     private resizingBBOXEnabled;
     private mouseGeoCoordXY;
     private mouseUpdateCoordinates;
     private mapPanning;
     private mapPanStartGeoCoords;
-    private proj4;
     private previousMouseButtonState;
-    private longlat;
     private tileRenderSettings;
-    private drawPending?;
     private needsRedraw;
-    private buildLayerDimsBusy;
-    isProjectionSupported: (srs: string) => boolean;
+    private _pixelCoordinatesToXY;
+    private _makeComponentId;
+    private _adagucBeforeDraw;
+    private _adagucBeforeCanvasDisplay;
+    private _init;
+    private _rebuildMapDimensions;
+    private _checkInvalidMouseAction;
+    private _updateMouseCursorCoordinates;
+    private _setActive;
+    private _setActiveLayer;
+    private _calculateNumBaseLayers;
+    private _setSize;
+    private _abort;
+    private _makeInfoHTML;
+    private _draw;
+    private _drawReady;
+    private _drawAndLoad;
+    private _mouseDragStart;
+    private _mouseDrag;
+    private _mouseDragEnd;
+    private _mapPan;
+    private _mapPanPercentageEnd;
+    private _mapZoomStart;
+    private _showBoundingBox;
+    private _hideBoundingBox;
+    private _animFrameRedraw;
+    constructor(_element: HTMLElement);
+    _resizeBBOX: WMBBOX;
+    _defaultBBOX: WMBBOX;
+    _bbox: WMBBOX;
+    _updateBBOX: WMBBOX;
+    _drawnBBOX: WMBBOX;
+    _loadingDiv: HTMLElement;
+    _baseDiv: HTMLElement;
+    _mapZooming: 0 | 1;
+    _initialized: boolean;
+    _animationList: AnimationStep[] | string | undefined;
+    getLayerByServiceAndName(layerService: string, layerName: string): WMLayer;
+    redrawBuffer(): void;
+    addLayersToCanvasAndDisplayThem(): void;
+    _mouseDownEvent(e: MouseEvent): void;
+    _mouseMoveEvent(e: MouseEvent): void;
+    _mouseUpEvent(e: MouseEvent): void;
+    _display(): void;
+    _updateBoundingBox(_mapbbox: WMBBOX, triggerEvent?: boolean): void;
+    _mouseWheelEvent(event: WheelEvent): void;
+    _detachEvents(): void;
+    _attachEvents(): void;
+    _onContextMenu: () => boolean;
+    _mapPanStart(x: number, y: number): void;
+    _mapPanEnd(x: number, y: number): void;
+    _mapZoom(): void;
+    _mapZoomEnd(): void;
+    _getMouseCoordinatesForDocument(e: MouseEvent | TouchEvent): {
+        x: number;
+        y: number;
+    };
+    _setMouseCoordinates: (x: number, y: number) => void;
+    _getMouseCoordsForElement(e: MouseEvent | TouchEvent): {
+        x: number;
+        y: number;
+    };
+    prefetchLayerImagesForTimeMemo: WMMemo;
+    shouldPrefetch: boolean;
+    mapPin: MapPin;
+    mapdimensions: WMJSDimension[];
+    timestepInMinutes: number | undefined;
+    showLayerInfo: boolean;
+    stopAnimating: () => void;
+    isAnimating: boolean;
+    animationList: AnimationStep[] | string | undefined;
+    animationDelay: number;
+    currentAnimationStep: number;
+    initialAnimationStep: number;
+    setAnimationDelay: (delay: number) => void;
+    isDestroyed: boolean;
     getMapImageStore: WMImageStore;
     holdShiftToScroll: boolean;
-    constructor(_element: HTMLElement);
+    getMapMouseCoordinates(): IWMJSMapMouseCoordinates;
     setWMTileRendererTileSettings(tileRenderSettings: TileServerSettings): void;
     addWMTileRendererTileSetting(tileRenderSetting: TileServerDefinition): void;
-    /**
-     * Function which make a component ID which is unique over several WebMapJS instances
-     * @param the desired id
-     * @return the unique id
-     */
-    makeComponentId(id: string): string;
     setMessage(message: string): void;
     setTimeOffset(message: string): void;
-    _adagucBeforeDraw(ctx: CanvasRenderingContext2D): void;
-    _adagucBeforeCanvasDisplay(ctx: CanvasRenderingContext2D): void;
-    init(): void;
-    rebuildMapDimensions(): void;
-    getLayerByServiceAndName(layerService: string, layerName: string): WMLayer;
-    getLayers(): WMLayer[];
+    getLayers(reverseOrder?: boolean): WMLayer[];
     hasLayer(layer: WMLayer): boolean;
-    setLayer(layer: WMLayer): Promise<unknown>;
-    setActive(active: boolean): void;
-    setActiveLayer(layer: WMLayer): void;
-    calculateNumBaseLayers(): void;
-    enableLayer(layer: WMLayer): void;
-    disableLayer(layer: WMLayer): void;
-    toggleLayer(layer: WMLayer): void;
+    setLayer(layer: WMLayer): Promise<IWMJSMap>;
     displayLayer(layer: WMLayer, enabled: boolean): void;
-    _getLayerIndex(layer: WMLayer): number;
     removeAllLayers(): void;
     deleteLayer(layerToDelete: WMLayer): void;
-    moveLayerDown(layerToMove: WMLayer): void;
     /**
      * Reorder layers according to an index array with indices on how the layers should be reordered.
      */
     reorderLayers(order: number[]): boolean;
-    swapLayers(_layerA: WMLayer, _layerB: WMLayer): void;
-    moveLayerUp(layerToMove: WMLayer): void;
     configureMapDimensions(layer: WMLayer): void;
-    /**
-     * @param layer of type WMLayer
-     */
-    addLayer(layer: WMLayer): Promise<WMJSMap>;
+    addLayer(layer: WMLayer): Promise<IWMJSMap>;
     getActiveLayer(): WMLayer;
     /**
      * setProjection
@@ -169,151 +171,36 @@ export default class WMJSMap {
      */
     setProjection(_srs: string | {
         srs: string;
-        bbox: WMBBOX;
-    }, _bbox?: WMBBOX): void;
+        bbox: Bbox;
+    }, _bbox?: Bbox): void;
+    getDrawBBOX(): WMBBOX;
     getBBOX(): WMBBOX;
-    getProjection(): {
-        srs: string;
-        bbox: WMBBOX;
-    };
+    getProjection(): WMProjectionWH;
     getSize(): {
         width: number;
         height: number;
     };
-    getWidth(): number;
-    getHeight(): number;
     getMapPin(): MapPin;
-    repositionLegendGraphic(): void;
+    private _repositionLegendGraphic;
     setSize(w: number, h: number): void;
-    _setSize(w: number, h: number): void;
-    abort(): void;
-    _makeInfoHTML(): void;
-    showScaleBar(): void;
-    hideScaleBar(): void;
-    showMouseCursorProperties(): void;
     hideMouseCursorProperties(): void;
     displayScaleBarInMap(display: boolean): void;
-    display(): void;
-    _animFrameRedraw(): void;
     draw(animationList?: AnimationStep[] | string | undefined): void;
-    /**
-     * API Function called to draw the layers, fires getmap request and shows the layers on the screen
-     */
-    _draw(animationList: AnimationStep[] | string | undefined): void;
-    _drawReady(): void;
-    _drawAndLoad(inputAnimationList: AnimationStep[] | string | undefined): void;
-    _onLayersReadyCallbackFunction(): void;
-    _onMapReadyCallbackFunction(): void;
-    _onResumeSuspendCallbackFunction(): void;
-    getWMSRequests(dimensionOverride?: Dimension[]): {
-        url: string;
-        headers: Headers[];
-    }[];
     getAlternativeImage(imageUrl: string, bbox: CanvasBBOX, filterBad?: boolean): CanvasGeoLayer[];
-    addLayersToCanvasAndDisplayThem(): void;
-    _updateBoundingBox(_mapbbox: WMBBOX, triggerEvent?: boolean): void;
-    redrawBuffer(): void;
-    addBaseLayers(layer: WMLayer): void;
     setBaseLayers(layer: WMLayer[]): void;
     getBaseLayers(): WMLayer[];
     getNumLayers(): number;
     getBaseElement(): HTMLElement;
-    mouseWheelEvent(event: WheelEvent): void;
     destroy(): void;
-    detachEvents(): void;
-    attachEvents(): void;
-    onContextMenu: () => boolean;
-    _buildLayerDims(): void;
-    getMapMode(): string;
-    getWMSGetFeatureInfoRequestURL(layer: WMLayer, x: number, y: number, format?: string): string;
-    setMapModeGetInfo(): void;
-    setMapModeZoomBoxIn(): void;
-    setMapModeZoomOut(): void;
-    setMapModePan(): void;
-    setMapModePoint(): void;
-    setMapModeNone(): void;
-    getMouseCoordinatesForDocument(e: MouseEvent | TouchEvent): {
-        x: number;
-        y: number;
-    };
-    setMouseCoordinates: (x: number, y: number) => void;
-    getMouseCoordinatesForElement(e: MouseEvent | TouchEvent): {
-        x: number;
-        y: number;
-    };
-    mouseDown(mouseCoordX: number, mouseCoordY: number, event: MouseEvent): void;
-    _checkInvalidMouseAction(MX: number, MY: number): -1 | 0;
-    updateMouseCursorCoordinates(coordinates: {
-        x: number;
-        y: number;
-    }): void;
-    mouseDownEvent(e: MouseEvent): void;
-    mouseMoveEvent(e: MouseEvent): void;
-    mouseUpEvent(e: MouseEvent): void;
-    mouseMove(mouseCoordX: number, mouseCoordY: number, event: MouseEvent): void;
+    mouseDown(mouseCoordX: number, mouseCoordY: number, event?: MouseEvent): void;
+    mouseMove(mouseCoordX: number, mouseCoordY: number, event?: MouseEvent): void;
     mouseUp(mouseCoordX: number, mouseCoordY: number, e: MouseEvent): void;
-    _mouseDragStart(x: number, y: number): void;
-    mouseDrag(x: number, y: number): void;
-    mouseDragEnd(x: number, y: number): void;
-    _mapPanStart(x: number, y: number): void;
-    _mapPan(x: number, y: number): void;
-    _mapPanEnd(x: number, y: number): void;
     mapPanPercentage(percentageDiffX: number, percentageDiffY: number): void;
-    _mapPanPercentageEnd(): void;
-    _mapZoomStart(): void;
-    _mapZoom(): void;
-    _mapZoomEnd(): void;
     setCursor(cursor?: string): void;
     getId(): string;
-    zoomTo(_newbbox: WMBBOX): void;
-    pixelCoordinatesToXY(coordinates: {
-        x: number;
-        y: number;
-    }): {
-        x: number;
-        y: number;
-    };
-    getGeoCoordFromPixelCoord(coordinates: {
-        x: number;
-        y: number;
-    }, _bbox?: WMBBOX): {
-        x: number;
-        y: number;
-    };
-    getProj4(): {
-        lonlat: string;
-        crs: string;
-        proj4: typeof proj4;
-    };
-    getPixelCoordFromLatLong(coordinates: {
-        x: number;
-        y: number;
-    }): {
-        x: number;
-        y: number;
-    };
-    getGeoCoordFromLatLong(coordinates: {
-        x: number;
-        y: number;
-    }): {
-        x: number;
-        y: number;
-    };
+    zoomTo(_newbbox: Bbox): void;
+    getProj4(): IWMProj4;
     calculateBoundingBoxAndZoom(lat: number, lng: number): void;
-    getLatLongFromPixelCoord(coordinates: {
-        x: number;
-        y: number;
-    }): {
-        x: number;
-        y: number;
-    };
-    getPixelCoordFromGeoCoord(coordinates: {
-        x: number;
-        y: number;
-    }, _bbox?: WMBBOX, _width?: number, _height?: number): {
-        x: number;
-        y: number;
-    };
     addListener(name: string, f: (param?: any) => void, keep?: boolean): boolean;
     removeListener(name: string, f: (param?: any) => void): void;
     getListener(): WMListener;
@@ -321,21 +208,13 @@ export default class WMJSMap {
     resumeEvent(name: string): void;
     getDimensionList(): WMJSDimension[];
     getDimension(name: string): WMJSDimension;
-    setTimeDimension(value: string, triggerEvent: boolean): void;
     setDimension(name: string, value: string, triggerEvent?: boolean, adjustLayerDims?: boolean): void;
     zoomToLayer(_layer: WMLayer): void;
     setDefaultBBOX(bbox: WMBBOX): void;
-    setBBOX(left: number | WMBBOX, bottom?: number, right?: number, top?: number): boolean;
-    /**
-     *
-     * @param ratio 1.0, meanse zoomout using full boundingbox width, 0.1 means zoom out 10% of full boundingbox width
-     */
+    setBBOX(left: number | Bbox, bottom?: number, right?: number, top?: number): boolean;
     zoomOut(ratio?: number): void;
     zoomIn(ratio: number): void;
     displayLegendInMap(_displayLegendInMap: boolean): void;
-    showBoundingBox(_bbox?: WMBBOX, _mapbbox?: WMBBOX): void;
-    hideBoundingBox(): void;
-    getDrawBBOX(): WMBBOX;
     getImageStore(): WMImageStore;
     clearImageCache(): void;
 }

package/src/lib/components/WMJSMapHelpers.d.ts

@@ -1,9 +1,58 @@
-import type WMJSMap from './WMJSMap';
 import type WMLayer from './WMLayer';
-import type { Dimension } from './types';
-export declare const getBBOXandProjString: (map: WMJSMap, layer: WMLayer) => string;
-export declare const buildWMSGetMapRequest: (map: WMJSMap, layer: WMLayer, dimensionOverride?: Dimension[]) => {
+import type { Dimension, LinkedInfo, WMPosition } from './types';
+import type IWMJSMap from './IWMJSMap';
+import { WMProjectionWH } from './WMProjection';
+import { Bbox } from './WMBBOX';
+export declare const getBBOXandProjString: (layer: WMLayer, projection: WMProjectionWH) => string;
+export declare const buildWMSGetMapRequest: (layer: WMLayer, projection: WMProjectionWH, dimensionOverride?: Dimension[]) => {
     url: string;
     headers: Headers[];
 } | undefined;
 export declare const isProjectionSupported: (srs: string, proj4Defintions?: string[][]) => boolean;
+export declare const getWMSRequests: (map: IWMJSMap, dimensionOverride?: Dimension[]) => {
+    url: string;
+    headers: Headers[];
+}[];
+export declare const getLayerIndex: (layer: WMLayer, layers: WMLayer[]) => number;
+export declare const buildMapLayerDims: (map: IWMJSMap) => void;
+/**
+ *  Makes a valid getfeatureinfoURL for each layer
+ * @param layer
+ * @param x
+ * @param y
+ * @param format
+ * @returns
+ */
+export declare const getWMSGetFeatureInfoRequestURL: (layer: WMLayer, x: number, y: number, format?: string) => string;
+export declare const getGeoCoordFromPixelCoord: (coordinates: WMPosition, bbox: Bbox, width: number, height: number) => WMPosition;
+export declare const getPixelCoordFromLatLong: (map: IWMJSMap, coordinates: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+};
+export declare const getGeoCoordFromLatLong: (map: IWMJSMap, coordinates: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+};
+export declare const getLatLongFromPixelCoord: (map: IWMJSMap, coordinates: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+};
+export declare const getPixelCoordFromGeoCoord: (map: IWMJSMap, coordinates: {
+    x: number;
+    y: number;
+}, _bbox?: Bbox, _width?: number, _height?: number) => {
+    x: number;
+    y: number;
+};
+export declare const getErrorsToDisplay: (canvasErrors: LinkedInfo[], getLayerByServiceAndName: (layerservice: string, layername: string) => WMLayer) => string[];
+export declare const detectLeftButton: (evt?: MouseEvent) => boolean;
+export declare const detectRightButton: (evt?: MouseEvent) => boolean;

package/src/lib/components/WMLayer.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { FeatureCollection } from 'geojson';
-import type WMJSMap from './WMJSMap';
+import type IWMJSMap from './IWMJSMap';
 import WMJSDimension from './WMJSDimension';
 import WMProjection from './WMProjection';
 import { GetCapabilitiesJson } from './WMJSService';
@@ -41,12 +41,12 @@ export interface LayerOptions extends LayerFoundation {
     keepOnTop?: boolean;
     transparent?: boolean;
     onReady?: (param: LayerOptions) => void;
-    parentMap?: WMJSMap;
+    parentMap?: IWMJSMap;
     headers?: Headers[];
     failure?: (layer: WMLayer, message: string) => void;
     ReactWMJSLayerId?: string;
-    onLayerError?: (layer: WMLayer, error: Error, webmapInstance: WMJSMap) => void;
-    onLayerReady?: (layer: WMLayer, webmap?: WMJSMap) => void;
+    onLayerError?: (layer: WMLayer, error: Error, webmapInstance: IWMJSMap) => void;
+    onLayerReady?: (layer: WMLayer, webmap?: IWMJSMap) => void;
     geojson?: GeoJSON.FeatureCollection;
 }
 /**
@@ -105,7 +105,7 @@ export default class WMLayer {
     queryable: boolean;
     styles: Style[];
     serviceTitle: string;
-    parentMap: WMJSMap;
+    parentMap: IWMJSMap;
     sldURL: string;
     active: boolean;
     getgraphinfoURL: string;
@@ -129,8 +129,6 @@ export default class WMLayer {
     setOpacity(opacityValue: number): void;
     getOpacity(): number;
     remove(): void;
-    moveUp(): void;
-    moveDown(): void;
     zoomToLayer(): void;
     draw(e: string): void;
     handleReferenceTime(name: string, value: string, updateMapDimensions?: boolean): void;

package/src/lib/components/WMMapPin.d.ts

@@ -1,5 +1,5 @@
-import WMBBOX from './WMBBOX';
-import type WMJSMap from './WMJSMap';
+import WMBBOX, { Bbox } from './WMBBOX';
+import type IWMJSMap from './IWMJSMap';
 declare class MapPin {
     private _map;
     private x;
@@ -10,11 +10,11 @@ declare class MapPin {
     private geoPosY;
     displayMapPin: boolean;
     disableMapPin: boolean;
-    constructor(_map: WMJSMap);
+    constructor(_map: IWMJSMap);
     redrawMap: () => void;
     drawMarker(ctx: CanvasRenderingContext2D): void;
     repositionMapPin: (_bbox: WMBBOX) => void;
-    setMapPin: (_x: number, _y: number, _bbox?: WMBBOX) => void;
+    setMapPin: (_x: number, _y: number, _bbox?: Bbox) => void;
     positionMapPinByLatLon: (coord: {
         x: number;
         y: number;

package/src/lib/components/WMPrefetch.d.ts

@@ -1,9 +1,9 @@
-import type WMJSMap from './WMJSMap';
-export declare function prefetchImagesForAnimation(wmMap: WMJSMap, maxImagesToPrefetch?: number): void;
+import type IWMJSMap from './IWMJSMap';
+export declare function prefetchImagesForAnimation(wmMap: IWMJSMap, maxImagesToPrefetch?: number): void;
 interface PrefetchRequest {
     url: string;
     headers: Headers[];
 }
-export declare function getLayersImageUrlsForTime(wmMap: WMJSMap, timeToPrefetch: string): PrefetchRequest[];
-export declare function prefetchImagesForNonAnimation(wmMap: WMJSMap, maxImagesToPrefetch?: number, batchSize?: number): void;
+export declare function getLayersImageUrlsForTime(wmMap: IWMJSMap, timeToPrefetch: string): PrefetchRequest[];
+export declare function prefetchImagesForNonAnimation(wmMap: IWMJSMap, maxImagesToPrefetch?: number, batchSize?: number): void;
 export {};

package/src/lib/components/WMProjection.d.ts

@@ -1,4 +1,4 @@
-import WMBBOX from './WMBBOX';
+import WMBBOX, { Bbox } from './WMBBOX';
 /**
  * WMProjection Class
  * Keep all projection information, by a bbox and an srs value.
@@ -8,3 +8,9 @@ export default class WMProjection {
     srs: string;
     constructor();
 }
+export interface WMProjectionWH {
+    bbox: Bbox;
+    srs: string;
+    width: number;
+    height: number;
+}

package/src/lib/components/index.d.ts

@@ -1,4 +1,4 @@
-import WMJSMap from './WMJSMap';
+import type IWMJSMap from './IWMJSMap';
 import { isDefined, WMJScheckURL, URLDecode, URLEncode, toArray, debugLogger, DebugType, getUriWithParam } from './WMJSTools';
 import WMGetServiceFromStore from './WMGetServiceFromStore';
 import { parseISO8601DateToDate, DateInterval, parseISO8601IntervalToDateInterval, ParseISOTimeRangeDuration } from './WMTime';
@@ -8,13 +8,18 @@ import { getLegendGraphicURLForLayer, legendImageStore } from './WMLegend';
 import { WMImageEventType } from './WMImageStore';
 import { WMJSService, wmServiceListener } from './WMJSService';
 import WMListener from './WMListener';
+import WMJSMap from './WMJSMap';
+import WMProjection from './WMProjection';
 export { default as WMJSDimension, handleDateUtilsISOString, } from './WMJSDimension';
 export { default as WMLayer, LayerType } from './WMLayer';
 export type { LayerOptions, LayerFoundation } from './WMLayer';
 export { default as WMBBOX } from './WMBBOX';
 export type { Bbox } from './WMBBOX';
-export { WMJSMap, DateInterval, parseISO8601IntervalToDateInterval, ParseISOTimeRangeDuration, isDefined, WMGetServiceFromStore, WMJScheckURL, URLEncode, URLDecode, parseISO8601DateToDate, I18n, toArray, getLegendGraphicURLForLayer, legendImageStore, WMImage, debugLogger, DebugType, WMImageEventType, WMJSService, getUriWithParam, wmServiceListener, WMListener, };
+export type { WMProjectionWH } from './WMProjection';
+export { WMProjection };
+export { IWMJSMap, WMJSMap, DateInterval, parseISO8601IntervalToDateInterval, ParseISOTimeRangeDuration, isDefined, WMGetServiceFromStore, WMJScheckURL, URLEncode, URLDecode, parseISO8601DateToDate, I18n, toArray, getLegendGraphicURLForLayer, legendImageStore, WMImage, debugLogger, DebugType, WMImageEventType, WMJSService, getUriWithParam, wmServiceListener, WMListener, };
 export * from './types';
 export * from './WMTimeTypes';
 export * from './WMConstants';
 export * from './WMJSMapHelpers';
+export * from './WMCanvasDrawFunctions';

package/src/lib/components/types.d.ts

@@ -1,8 +1,9 @@
+import proj4 from 'proj4';
 import type WMJSDimension from './WMJSDimension';
 import type WMLayer from './WMLayer';
 import { Bbox } from './WMBBOX';
 import type WMImage from './WMImage';
-import type WMJSMap from './WMJSMap';
+import type IWMJSMap from './IWMJSMap';
 export interface AnimationStep {
     name: string;
     value: string;
@@ -156,8 +157,18 @@ export interface WMSLayerFromGetCapabilities {
     }[];
 }
 export interface WMJSMapMouseClickEvent {
-    map: WMJSMap;
+    map: IWMJSMap;
     x: number;
     y: number;
     shiftKeyPressed: boolean;
 }
+export interface IWMJSMapMouseCoordinates {
+    mouseX: number;
+    mouseDownX: number;
+    mouseY: number;
+    mouseDownY: number;
+}
+export interface IWMProj4 {
+    crs: string;
+    proj4: typeof proj4;
+}