@opengeoweb/webmap 2.0.1

package/lib/components/WMJSMap.d.ts

@@ -0,0 +1,310 @@
+import WMBBOX from './WMBBOX';
+import WMListener from './WMListener';
+import WMJSDimension from './WMJSDimension';
+import MapPin from './WMMapPin';
+import WMLayer from './WMLayer';
+import { LinkedInfo } from './types';
+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[];
+/**
+/**
+  * WMJSMap class
+  */
+export default class WMJSMap {
+    mapPin: MapPin;
+    mapdimensions: WMJSDimension[];
+    stopAnimating: () => void;
+    isAnimating: boolean;
+    animationDelay: number;
+    animationList: any;
+    _animationList: any;
+    currentAnimationStep: number;
+    setAnimationDelay: (delay: any) => void;
+    isAnimatingLoopRunning: boolean;
+    checkAnimation: () => void;
+    animateBusy: boolean;
+    animationTimer: any;
+    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;
+    private _displayLegendInMap;
+    private bbox;
+    updateBBOX: WMBBOX;
+    private loadedBBOX;
+    drawnBBOX: WMBBOX;
+    private divBuffer;
+    private isDestroyed;
+    private mapHeader;
+    private currentCursor;
+    private mapIsActivated;
+    private isMapHeaderEnabled;
+    private showScaleBarInMap;
+    private callBack;
+    private initialized;
+    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;
+    private resizeWidth;
+    private resizeHeight;
+    private _resizeTimerBusy;
+    private _resizeTimer;
+    private wmAnimate;
+    private wmTileRenderer;
+    private loadingDivTimer;
+    private mouseWheelBusy;
+    private wMFlyToBBox;
+    private mouseWheelEventBBOXCurrent;
+    private mouseWheelEventBBOXNew;
+    private mouseUpX;
+    private mouseUpY;
+    private mouseDragging;
+    private controlsBusy;
+    private mouseDownPressed;
+    private mapMode;
+    private numGetFeatureInfoRequests;
+    private getFeatureInfoResult;
+    private oldMapMode;
+    private InValidMouseAction;
+    private resizingBBOXCursor;
+    private resizingBBOXEnabled;
+    private mouseGeoCoordXY;
+    private mouseUpdateCoordinates;
+    private mapPanning;
+    private mapPanStartGeoCoords;
+    private proj4;
+    private previousMouseButtonState;
+    private longlat;
+    xml2jsonrequest: string;
+    private tileRenderSettings;
+    private drawPending;
+    private needsRedraw;
+    private buildLayerDimsBusy;
+    constructor(_element: HTMLElement);
+    setXML2JSONURL(_xml2jsonrequest: string): void;
+    setWMTileRendererTileSettings(_WMTileRendererTileSettings: unknown): 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[];
+    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;
+    displayLayer(layer: WMLayer, enabled: boolean): void;
+    _getLayerIndex(layer: WMLayer): number;
+    removeAllLayers(): void;
+    deleteLayer(layerToDelete: WMLayer): void;
+    moveLayerDown(layerToMove: WMLayer): void;
+    swapLayers(_layerA: WMLayer, _layerB: WMLayer): void;
+    moveLayerUp(layerToMove: WMLayer): void;
+    configureMapDimensions(layer: WMLayer): void;
+    /**
+     * @param layer of type WMLayer
+     */
+    addLayer(layer: WMLayer): Promise<unknown>;
+    getActiveLayer(): WMLayer;
+    /**
+     * setProjection
+     * Set the projection of the current webmap object
+     *_srs also accepts a projectionProperty object
+     */
+    setProjection(_srs: string | {
+        srs: string;
+        bbox: WMBBOX;
+    }, _bbox?: WMBBOX): void;
+    getBBOX(): WMBBOX;
+    getProjection(): {
+        srs: string;
+        bbox: WMBBOX;
+    };
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getWidth(): number;
+    getHeight(): number;
+    getMapPin(): MapPin;
+    repositionLegendGraphic(): void;
+    setSize(w: number, h: number): void;
+    _setSize(w: number, h: number): void;
+    abort(): void;
+    isBusy(): boolean;
+    _makeInfoHTML(): void;
+    showScaleBar(): void;
+    hideScaleBar(): void;
+    displayScaleBarInMap(display: boolean): void;
+    display(): void;
+    _animFrameRedraw(): void;
+    draw(animationList?: {}): void;
+    /**
+     * API Function called to draw the layers, fires getmap request and shows the layers on the screen
+     */
+    _draw(animationList: string | any[]): void;
+    _drawReady(): void;
+    _drawAndLoad(animationList: string | any[]): void;
+    _onLayersReadyCallbackFunction(): void;
+    _onMapReadyCallbackFunction(): void;
+    _onResumeSuspendCallbackFunction(): void;
+    getWMSRequests(): {
+        url: string;
+        headers: Headers[];
+    }[];
+    _pdraw(): 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: string, y: string, 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;
+    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;
+    _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: any;
+    };
+    getPixelCoordFromLatLong(coordinates: {
+        x: any;
+        y: any;
+    }): {
+        x: any;
+        y: any;
+    };
+    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;
+    suspendEvent(name: string): void;
+    resumeEvent(name: string): void;
+    getDimensionList(): WMJSDimension[];
+    getDimension(name: string): WMJSDimension;
+    setDimension(name: string, value: string, triggerEvent?: boolean, adjustLayerDims?: boolean): void;
+    zoomToLayer(_layer: WMLayer): void;
+    setBBOX(left: number | WMBBOX, bottom?: number, right?: number, top?: number): boolean;
+    zoomOut(): void;
+    zoomIn(ratio: number): void;
+    displayLegendInMap(_displayLegendInMap: boolean): void;
+    showBoundingBox(_bbox?: WMBBOX, _mapbbox?: WMBBOX): void;
+    hideBoundingBox(): void;
+    getDrawBBOX(): WMBBOX;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+import * as React from 'react';
+declare const _default: {
+    title: string;
+};
+export default _default;
+export declare const WMJSMapRadarDisplay: () => React.ReactElement;

package/lib/components/WMJSMapHelpers.d.ts

@@ -0,0 +1,7 @@
+import type WMJSMap from './WMJSMap';
+import WMLayer from './WMLayer';
+export declare const getBBOXandProjString: (map: WMJSMap, layer: WMLayer) => string;
+export declare const buildWMSGetMapRequest: (map: WMJSMap, layer: WMLayer) => {
+    url: string;
+    headers: Headers[];
+};

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

@@ -0,0 +1 @@
+export {};

package/lib/components/WMJSService.d.ts

@@ -0,0 +1,77 @@
+export interface GetCapabilitiesJson {
+    WMS_Capabilities?: any;
+    WMT_MS_Capabilities?: any;
+    ServiceExceptionReport?: any;
+}
+export interface Capability {
+    Layer: any;
+    Request: any;
+    Exception?: any;
+}
+export declare const loadGetCapabilitiesViaProxy: (url: string, succes: (param: string) => void, fail: (param: string) => void, xml2jsonrequestURL: string) => void;
+export declare const getWMSUrl: (service?: string, additionalParams?: {}) => string;
+/**
+ * Global getcapabilities function
+ */
+export declare const WMJSGetCapabilities: (service: string, succes: (param: any) => void, fail: (param: string) => void, xml2jsonrequestURL: string, options: {
+    headers?: any;
+}, disableCache?: boolean) => void;
+interface NodeObject {
+    text: string;
+    leaf: boolean;
+    name?: string;
+    path?: string;
+    children?: [];
+}
+export declare const sortByKey: (array: NodeObject[], key: string) => NodeObject[];
+export declare const recursivelyFindLayer: (layers: any[], rootNode: any[], path: string) => void;
+/**
+ * WMJSService Class
+ *
+ * options:
+ *   service
+ *   xml2jsonrequestURL
+ *   title (optional)
+ */
+export declare class WMJSService {
+    service: string;
+    title: string;
+    onlineresource: string;
+    abstract: string;
+    version: string;
+    getcapabilitiesDoc: GetCapabilitiesJson;
+    busy: boolean;
+    _flatLayerObject: any[];
+    xml2jsonrequestURL: string;
+    functionCallbackList: any[];
+    _options: any;
+    nodeCache: any;
+    constructor(options: {
+        service: string;
+        xml2jsonrequestURL: string;
+        title?: string;
+    });
+    checkVersion111(jsonData: GetCapabilitiesJson): void;
+    checkVersion130(jsonData: GetCapabilitiesJson): void;
+    getCapabilityElement(jsonData: GetCapabilitiesJson): Capability;
+    checkVersion(jsonData: GetCapabilitiesJson): string;
+    /**
+     * Does getcapabilities for a service.
+     * When multple getCapabilities for the same service are made,
+     * this method makes one get request and fires all callbacks with the same result.
+     * @param succescallback Function called upon succes, cannot be left blank
+     * @param failcallback Function called upon failure, cannot be left blank
+     */
+    getCapabilities(succescallback: (param: GetCapabilitiesJson) => void, failcallback: (param: unknown) => void, forceReload: boolean, xml2jsonrequestURL: string, options: unknown): void;
+    checkException(jsonData: GetCapabilitiesJson): string | undefined;
+    /**
+     * Calls succes with a hierarchical node structure
+     * Calls failure with a string when someting goes wrong
+     */
+    getNodes(succes: (param: unknown) => void, failure: (param: unknown) => void, forceReload: boolean, xml2jsonrequestURL?: string, options?: unknown): void;
+    /** Calls succes with an array of all layerobjects
+     * Calls failure when something goes wrong
+     */
+    getLayerObjectsFlat(succes: (param: unknown) => void, failure: (param: unknown) => void, forceReload: boolean, xml2jsonrequestURL?: string, options?: any): void;
+}
+export {};

package/lib/components/WMJSService.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMJSTools.d.ts

@@ -0,0 +1,60 @@
+import type WMLayer from './WMLayer';
+export declare const enableConsoleDebugging = false;
+export declare enum DebugType {
+    Log = 0,
+    Warning = 1,
+    Error = 2
+}
+export declare const debug: (type: DebugType, message: string, ...optionalParam: unknown[]) => void;
+/**
+ * Checks if variable is defined or not
+ * @param variable The variable to check
+ * @returns true if variable is indeed defined, otherwise false.
+ */
+export declare const isDefined: (variable: any) => boolean;
+/**
+ * Checks if a variable is null or not
+ * @param variable The variable to check
+ * @returns true if variable is indeed null, otherwise false.
+ */
+export declare const isNull: (variable: any) => boolean;
+/**
+ * Converts a variable to an array. If the variable is not an array it will be pushed as the first entry in a new array. If the variable is already an array, nothing will  be done.
+ * @param array The variable to convert
+ * @returns Always an array
+ */
+export declare const toArray: (array: unknown | unknown[]) => any[];
+/**
+ * Function which checks wether URL contains a ? token. If not, it is assumed that this token was not provided by the user,
+ * manually add the token later.
+ * @param url The URL to check
+ * @return the fixed URL
+ */
+export declare const WMJScheckURL: (url: string) => string;
+export declare const preventdefaultEvent: (e: Event) => void;
+export declare const getMouseXCoordinate: (event: MouseEvent) => number;
+export declare const getMouseYCoordinate: (event: MouseEvent) => number;
+export declare const URLDecode: (encodedURL: string) => string;
+export declare const URLEncode: (plaintext: string) => string;
+export declare const getCorrectWMSDimName: (origDimName: string) => string;
+export declare const getMapDimURL: (layer: WMLayer) => string;
+/**
+ * Parses url and then it it allows for setting / changing key value pairs in that URL (From https://stackoverflow.com/questions/5999118/how-can-i-add-or-update-a-query-string-parameter)
+ * @param baseUrl
+ * @param params
+ * @returns
+ */
+export declare const getUriWithParam: (baseUrl: string, params: Record<string, any>) => string;
+/**
+ * Parses url and then it it allows for setting additional key value pairs in that URL (From https://stackoverflow.com/questions/5999118/how-can-i-add-or-update-a-query-string-parameter)
+ * @param baseUrl
+ * @param params
+ * @returns
+ */
+export declare const getUriAddParam: (baseUrl: string, params: Record<string, any>) => string;
+/**
+ * Converts a JS date to a ISO8601 string
+ * @param date
+ * @returns ISO8601 string
+ */
+export declare const dateToISO8601: (date: Date) => string;

package/lib/components/WMJSTools.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMLayer.d.ts

@@ -0,0 +1,200 @@
+/// <reference types="react" />
+/// <reference types="node" />
+import type WMJSMap from './WMJSMap';
+import WMJSDimension from './WMJSDimension';
+import WMProjection from './WMProjection';
+import WMImage from './WMImage';
+import { GetCapabilitiesJson, WMJSService } from './WMJSService';
+import { Style, Dimension } from './types';
+export declare enum LayerType {
+    mapLayer = "mapLayer",
+    baseLayer = "baseLayer",
+    overLayer = "overLayer"
+}
+export interface LayerOptions {
+    id: string;
+    name?: string;
+    layerType: LayerType;
+    service: string;
+    active?: boolean;
+    format?: string;
+    getgraphinfoURL?: string;
+    style?: string;
+    currentStyle?: string;
+    sldURL?: string;
+    opacity?: number;
+    title?: string;
+    enabled?: boolean;
+    keepOnTop?: boolean;
+    transparent?: boolean;
+    onReady?: (param: any) => void;
+    type?: string;
+    parentMaps?: WMJSMap[];
+    dimensions?: Dimension[];
+    headers?: Headers[];
+    failure?: (layer: WMLayer, message: string) => void;
+    ReactWMJSLayerId?: string;
+}
+/**
+ * This interface is for reading from the WMS GetCapabilties document, which can have different structures for V1.1.1 and V1.3.0
+ */
+interface WMSLayerFromGetCapabilities {
+    Dimension: unknown;
+    Style: unknown;
+    Extent: unknown;
+}
+/**
+ * Helper function to figure out the styles from the WMS layer object from the WMS GetCapabilties document
+ * @param layerStyles The layer styles object from the WMS GetCapabilities
+ * @param layer The WMLayer to configure
+ */
+export declare const addStylesForLayer: (layerObjectFromWMS: WMSLayerFromGetCapabilities, layer: WMLayer) => void;
+/**
+ * Helper function to figure out the dimensions from the WMS layer object (From WMS GetCapabilities). Parses both WMS 1.1.1 and WMS 1.3.0.
+ * @param layerObjectFromWMS The corresponding layer object from the WMS GetCapabilities.
+ * @param layer THe WMLayer to configure
+ * @param layerDimNamesToRemove A set of dimensions names which are flagged for removal, this function removes the dimension from the set if found in the layer.
+ */
+export declare const addDimsForLayer: (layerObjectFromWMS: WMSLayerFromGetCapabilities, layer: WMLayer, layerDimNamesToRemove: Set<string>) => void;
+/**
+ * Helper function to configure the WMS Styles from the WMS GetCapabilities document.
+ * @param nestedLayerPath Array of WMS Layers from `[Root WMS Layer] => [Parent(s) WMS Layer] => [This WMS layer]`.
+ * @param wmLayer The WMLayer object to configure
+ */
+export declare const configureStyles: (nestedLayerPath: WMSLayerFromGetCapabilities[], wmLayer: WMLayer) => void;
+/**
+ * Helper function to configure the dimensions for this layer from the WMS GetCapabilities document.
+ * @param nestedLayerPath Array of WMS Layers from `[Root WMS Layer] => [Parent(s) WMS Layer] => [This WMS layer]`.
+ * @param wmLayer The WMLayer object to configure
+ */
+export declare const configureDimensions: (nestedLayerPath: WMSLayerFromGetCapabilities[], wmLayer: WMLayer) => void;
+export default class WMLayer {
+    id: string;
+    name?: string;
+    ReactWMJSLayerId?: string;
+    reactWebMapJSLayer?: React.ReactElement;
+    hasError?: boolean;
+    enabled?: boolean;
+    lastError?: string;
+    legendGraphic?: string;
+    title?: string;
+    opacity?: number;
+    service: string;
+    layerType: LayerType;
+    currentStyle?: string;
+    image?: WMImage;
+    linkedInfo: {
+        layer: string;
+        message: string;
+    };
+    headers: Headers[];
+    autoupdate: boolean;
+    timer: NodeJS.Timeout;
+    WMJSService: WMJSService;
+    getmapURL: string;
+    getfeatureinfoURL: string;
+    getlegendgraphicURL: string;
+    keepOnTop: boolean;
+    transparent: boolean;
+    legendIsDimensionDependent: boolean;
+    wms130bboxcompatibilitymode: boolean;
+    version: string;
+    path: string;
+    type: string;
+    abstract: string;
+    dimensions: WMJSDimension[];
+    projectionProperties: WMProjection[];
+    queryable: boolean;
+    styles: Style[];
+    getCapabilitiesDoc: GetCapabilitiesJson;
+    serviceTitle: string;
+    parentMaps: WMJSMap[];
+    sldURL: string;
+    active: boolean;
+    getgraphinfoURL: string;
+    format: string;
+    _options: LayerOptions;
+    onReady: (param: any) => void;
+    optimalFormat: string;
+    wmsextensions: {
+        url: string;
+        colorscalerange: Record<string, unknown>[];
+    };
+    jsonlayer: this;
+    isConfigured: boolean;
+    init(): void;
+    constructor(options?: LayerOptions);
+    getLayerName(): string;
+    toggleAutoUpdate(): void;
+    setAutoUpdate(val: boolean, interval?: number, callback?: () => void): void;
+    setOpacity(opacityValue: string): void;
+    getOpacity(): number;
+    remove(): void;
+    moveUp(): void;
+    moveDown(): void;
+    zoomToLayer(): void;
+    draw(e: string): void;
+    handleReferenceTime(name: string, value: string, updateMapDimensions?: boolean): void;
+    getDimensions(): WMJSDimension[];
+    setDimension(name: string, value: string, updateMapDimensions?: boolean): void;
+    __parseGetCapForLayer(layer: WMLayer, getcapabilitiesjson: GetCapabilitiesJson, layerDoneCallback: (layer: WMLayer) => void, fail: (layer: WMLayer, message: string) => void): void;
+    /**
+     * Calls success with a configured layer object
+     * Calls options.failure with error message.
+     * Throws string exceptions when someting goes wrong
+     */
+    parseLayer(_layerDoneCallback: (layer: WMLayer) => void, forceReload: boolean, xml2jsonrequest?: string): void;
+    /**
+     * A Promise to parse the layer, it will fetch the WMS GetCapabilities document, configure the layer and resolve to a WMLayer object
+     * @param forceReload Do not use the cache of the WMS GetCapabilties document, but instead fetch new data from the server
+     * @returns WMLayer object
+     */
+    parseLayerPromise(forceReload?: boolean): Promise<WMLayer>;
+    cloneLayer(): WMLayer;
+    /**
+     * Set or change the name of this layer. This involves re-parsing the WMS GetCapabilities document and updating the affected layer properties. When done, it resolves the WMLayer
+     * @param name The name of the layer
+     * @returns Promise resolving to a WMLayer object
+     */
+    setName(name: string): Promise<WMLayer>;
+    getLayerRelative(success: (layer: WMLayer, index: number, length: number) => void, failure: (param: string) => void, prevNext: number): void;
+    autoSelectLayer(success: (layer: WMLayer) => void, failure: (param: string) => void): void;
+    getNextLayer(success: (layer: WMLayer, index: number, length: number) => void, failure: (param: string) => void): void;
+    getPreviousLayer(success: (layer: WMLayer, index: number, length: number) => void, failure: (param: string) => void): void;
+    /**
+     * Sets the style by its name
+     * @param style: The name of the style (not the object)
+     */
+    setStyle(styleName: string): void;
+    getStyles(): Style[];
+    /**
+     * Get the styleobject by name
+     * @param styleName The name of the style
+     * @param nextPrev, can be -1 or +1 to get the next or previous style object in circular manner.
+     */
+    getStyleObject(styleName: string, nextPrev: number): Style;
+    getStyle(): string;
+    getDimension(name: string): WMJSDimension;
+    /**
+     * Returns the Coordinate Reference Systems for this layer
+     * @returns List of WMProjection objects
+     */
+    getCRS(): WMProjection[];
+    /**
+     * Get Coordinate reference system by name
+     *
+     * @param srsName Name of the coordinate reference system to get
+     * @returns A WMProjection object if found, otherwise undefined.
+     */
+    getCRSByName(srsName: string): WMProjection;
+    /**
+     * Get Coordinate reference system by name. Note 2021-05-17: It is more inline with other function names to use the getCRSByName function instead.
+     *
+     * @param srsName Name of the coordinate reference system to get
+     * @returns A WMProjection object if found, otherwise undefined.
+     */
+    getProjection(srsName: string): WMProjection;
+    setSLDURL(url: string): void;
+    display(displayornot: boolean): void;
+}
+export {};

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

@@ -0,0 +1 @@
+export {};

package/lib/components/WMLegend.d.ts

@@ -0,0 +1,6 @@
+import WMImageStore from './WMImageStore';
+import WMLayer from './WMLayer';
+export declare const legendImageStore: WMImageStore;
+export declare const getLegendGraphicURLForLayer: (layer: WMLayer, width?: number, height?: number) => string;
+export declare const getLegendImageStore: () => WMImageStore;
+export declare const drawLegend: (canvasContext: CanvasRenderingContext2D, width: number, height: number, layers: WMLayer[]) => void;

package/lib/components/WMLegend.spec.d.ts

@@ -0,0 +1 @@
+export {};