@opengeoweb/webmap 19.1.0 → 19.2.0

package/dist/src/index.d.ts

@@ -0,0 +1,16 @@
+import WMImageStore from './lib/components/WMImageStore';
+import { mockGetCapabilities } from './lib/specs';
+export * from './lib';
+export * as webmapUtils from './lib/utils/utils';
+export * as webmapTestSettings from './lib/specs';
+export { mockGetCapabilities };
+declare const privateWebMapUtils: {
+    privateWmsGetCapabilities: (serviceUrl: string, headers?: import("./lib").Header[], forceReload?: boolean) => Promise<import("./lib").WMSGetCapabilities>;
+    privateGetWMSServiceInfo: (getCapabilitiesJson: import("./lib").WMSGetCapabilities, serviceUrl: string) => import("./lib").WMSServiceInfo;
+    privateWmsGetLayerTree: (jsonData: import("./lib").OGCWMSWMTSGetCapabilities) => import("./lib").LayerTree | null;
+    privateWmsFlattenLayerTree: (layerTree: import("./lib").LayerTree) => import("./lib").LayerProps[];
+    privateWmtsGetCapabilities: (serviceUrl: string, headers?: import("./lib").Header[], forceReload?: boolean) => Promise<string>;
+    QUERYWMS_GETCAPABILITIES: string;
+};
+export { privateWebMapUtils };
+export { WMImageStore };

package/dist/src/lib/components/LoadDurationCounter.d.ts

@@ -0,0 +1,17 @@
+export declare enum WMImageStoreLoadType {
+    'PREFETCH' = "A",
+    'GETMAP' = "B"
+}
+export default class LoadDurationCounter {
+    constructor();
+    private _loadingListForIds;
+    private _loadingDurationForIds;
+    setLoadingStatusForId(type: WMImageStoreLoadType, identifier: string, doneLoading: number, totalLoading: number, resetDuration?: boolean): void;
+    setLoadDurationForId(identifier: string, duration: number | undefined): void;
+    getLoadDurationForId(identifier: string): number | undefined;
+    getTotalLoadingPercentageForIds(identifierList: string[]): {
+        percentage: number;
+        doneLoading: number;
+        totalLoading: number;
+    };
+}

package/dist/src/lib/components/WMBBOX.d.ts

@@ -0,0 +1,32 @@
+export interface Bbox {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export default class WMBBOX implements Bbox {
+    left: number;
+    bottom: number;
+    right: number;
+    top: number;
+    constructor(left?: number | string | Bbox, bottom?: number, right?: number, top?: number);
+    /**
+     * Clone an existing BBOX
+     */
+    clone(): WMBBOX;
+    copy(bbox: WMBBOX): void;
+    /**
+     * setBBOX method
+     * Creates a WebMapJS bounding box based on 4 numeric values
+     * Creates a WebMapJS bounding box based on 1 string with commaseparated numeric values
+     * Creates a WebMapJS bounding box based on an exisiting WebMapJS bounding box.
+     * When no parameters are given, a global latlon bbox is generated.
+     */
+    setBBOX(left?: number | string | Bbox, bottom?: number, right?: number, top?: number): void;
+    equals(left: number | string | WMBBOX | Bbox, bottom: number, right: number, top: number): boolean;
+    /**
+     * Returns the current BBOX as a string, useful for generating WMS requests.
+     */
+    toString(): string;
+    getExtent(): [number, number, number, number];
+}

package/dist/src/lib/components/WMConstants.d.ts

@@ -0,0 +1,32 @@
+export declare const WMEmptyLayerName = "empty_layer";
+export declare const WMEmptyLayerTitle = "empty layer";
+export declare const WMDefaultStyleName = "default";
+export declare const WMDateOutSideRange = "outside range";
+export declare const WMDateTooEarlyString = "date too early";
+export declare const WMDateTooLateString = "date too late";
+export declare const WMDateUnit = "ISO8601";
+export declare const WMInvalidDateValues: Set<string>;
+export declare const WMSVersion: {
+    version100: string;
+    version111: string;
+    version130: string;
+};
+export declare const WMProj4Defs: string[][];
+export declare const mapImageStoreLength = 1000;
+export declare const bgImageStoreLength = 360;
+export declare const legendImageStoreLength = 500;
+export declare const EVENT_GETCAPABILITIES_START = "onstartgetcapabilities";
+export declare const EVENT_GETCAPABILITIES_READY = "onreadygetcapabilities";
+export declare const WMJSMAP_LONLAT_EPSGCODE: "EPSG:4326";
+export declare const isProjectionSupported: (srs: string, proj4Defintions?: string[][]) => boolean;
+export interface RefTimeDimensionMode {
+    id: string;
+    servicematch: string;
+    layermatch: string;
+    ruleset: {
+        id: string;
+        moduloHH: number[];
+        relativeSteps: number[];
+    }[];
+}
+export type RefTimeDimensionModes = RefTimeDimensionMode[];

package/dist/src/lib/components/WMImage.d.ts

@@ -0,0 +1,115 @@
+export interface WMHeader {
+    name: string;
+    value: string;
+}
+export interface WMImageOptions {
+    randomizer?: boolean;
+    headers: WMHeader[];
+    fakeMaxAge?: number;
+}
+export interface WMGeoReference {
+    extent: number[];
+    resolution: number;
+}
+/**
+ * Returns the current time in ms
+ * @returns the current time in ms
+ */
+export declare const getCurrentImageTime: () => number;
+/**
+ * WMImage provides an API to the HTML image element. It is used for caching and easier access to images.
+ */
+export default class WMImage {
+    imageLife: number;
+    randomize: boolean;
+    _srcLoaded: string;
+    _isLoaded: boolean;
+    _isLoading: boolean;
+    _hasError: boolean;
+    srcToLoad: string;
+    loadEventCallback?: (image: WMImage) => void;
+    el: HTMLImageElement;
+    headers: WMHeader[];
+    _imageTimeStampAtError: number;
+    _numFailedAttempts: number;
+    _loadStartTime: number;
+    _loadDuration?: number;
+    _maxAgeSeconds?: number | null;
+    _loadedAtTime?: number;
+    _resolveList: ((i: WMImage) => void)[];
+    geoReference: WMGeoReference | null;
+    hashUrl: string | undefined;
+    setGeoReference(geoReference: WMGeoReference): void;
+    /**
+     *
+     * @param src Optionally set the source URL to load
+     * @param callback Optionally set the callback function to trigger once image has loaded
+     * @param options Additional options to the image. You can set { randomizer: true } to force unique url's and prevent caching.
+     */
+    constructor(src: string, callback?: (image: WMImage) => void, options?: WMImageOptions);
+    private init;
+    /**
+     * Returns true if the image has been loaded
+     */
+    isLoaded(): boolean;
+    isLoadedWithoutErrors(): boolean;
+    hasNotStartedLoading(): boolean;
+    isStale(): boolean;
+    /**
+     * Returns true if the image is still loading
+     */
+    isLoading(): boolean;
+    /**
+     * Get the amount of milliseconds since the image experienced an image load.
+     * @returns milliseconds since the image had an error
+     */
+    getLastErrorMSecondsAgo(): number;
+    /**
+     * @returns The number of failed attempts for this image
+     */
+    getNumFailedAttempts(): number;
+    /**
+     * Set source of image, but it will not load the image yet.
+     * @param src URL of the image to load
+     * @param options WMImageOptions to give to the image
+     */
+    setSource(src: string, options: WMImageOptions): void;
+    /**
+     * Re-intialize the image
+     */
+    clear(): void;
+    /**
+     * Get the URL of the image
+     */
+    getSrc(): string;
+    /**
+     * Check if the image has an error
+     */
+    hasError(): boolean;
+    clearError(): void;
+    private _resolveAll;
+    /**
+     * Start loading the image
+     */
+    loadAwait(): Promise<WMImage>;
+    load(): void;
+    forceReload(randomize?: boolean): void;
+    private static _parseMaxAgeFromCacheControl;
+    private _setMaxAgeFromResponseHeaders;
+    _getImageWithHeaders(url: string, headers: WMHeader[]): void;
+    _load(): void;
+    _loadEvent(hasError: boolean): void;
+    getLoadDuration(): number | undefined;
+    /**
+     * Get the width of the current image
+     */
+    getWidth(): number;
+    /**
+     * Get the height of the current image
+     */
+    getHeight(): number;
+    /**
+     * Get the HTMLImageElement behind the WMImage
+     */
+    getElement(): HTMLImageElement;
+}

package/dist/src/lib/components/WMImageStore.d.ts

@@ -0,0 +1,61 @@
+import LoadDurationCounter from './LoadDurationCounter';
+import type { WMGeoReference, WMImageOptions } from './WMImage';
+import WMImage from './WMImage';
+export declare enum WMImageEventType {
+    Loaded = 0,
+    Deleted = 1
+}
+export default class WMImageStore {
+    imagesbysrc: Map<string, WMImage>;
+    imageLife: number;
+    _imageLifeCounter: number;
+    _loadEventCallbackList: {
+        id: string;
+        callback: (image: WMImage, id: string, imageEventType: WMImageEventType) => void;
+    }[];
+    _maxNumberOfImages: number;
+    _options: {
+        id: string;
+    };
+    emptyImage: WMImage;
+    imagesbyGeoRef: Map<string, WMImage[]>;
+    loadDuration: LoadDurationCounter;
+    /**
+     * Constructs a new WMImageStore with given amount of image cache.
+     * @param {*} maxNumberOfImages
+     * @param {*} options
+     */
+    constructor(maxNumberOfImages: number, options: {
+        id: string;
+    });
+    load(imageUrl: string): Promise<WMImage>;
+    imageLoadEventCallback(_img: WMImage, imageEventType: WMImageEventType): void;
+    /**
+     * Check if we have similar images with the same source in the pipeline
+     */
+    getImageForSrc(src: string): WMImage | undefined;
+    clear(): void;
+    addImageEventCallback(callback: (image: WMImage, id: string, imageEventType: WMImageEventType) => void, id: string): void;
+    removeAllEventCallbacks(): void;
+    removeEventCallback(id: string): void;
+    getNumImagesLoading(): number;
+    /**
+     * getAltGeoReferencedImage will return an ready and loaded image for similar query parameters as requested.
+     * This image can be used to display something during the period when the requested image one is still loading.
+     * The alternative image will have the same query parameters but can have a different extent and resolution.
+     * @param srcToLoad The url of the image for which we want to find an alternative
+     * @param _extent Extent of the requested image
+     * @param _resolution Resolution of the request image
+     * @returns A WMImage which is ready to display. Can have a different extent and resolution then what was asked in srcToLoad
+     */
+    getAltGeoReferencedImage(srcToLoad: string, _extent: number[], _resolution: number): WMImage | false;
+    getAltGeoReferencedImages(srcToLoad: string, _extent: number[], _resolution: number): WMImage[];
+    getImageAndSetGeoReference(src: string, geoReference: WMGeoReference): WMImage;
+    getNumCached(): number;
+    /**
+     * Get an WMImage object for given URL
+     * @param {*} src The url for the image
+     * @returns WMImage object
+     */
+    getImage(src: string, loadOptions?: WMImageOptions): WMImage;
+}

package/dist/src/lib/components/WMJSDimension.d.ts

@@ -0,0 +1,126 @@
+import type { Dimension, TimeInterval } from './types';
+import type { RefTimeDimensionMode } from './WMConstants';
+import { ParseISOTimeRangeDuration } from './WMTime';
+import type { CustomDate } from './WMTimeTypes';
+/**
+ * Re-formats isoString to the string that is expected by WMJSDimension (for time).
+ * @param dateIn The input date to re-format, usually in the format `YYYY-MM-DDThh:mm:ss.uuuZ`
+ * @returns The formated input date in the format `YYYY-MM-DDThh:mm:ssZ`
+ */
+export declare const handleDateUtilsISOString: (dateIn: string) => string;
+interface WMJSDimensionConfig {
+    name?: string;
+    units?: string;
+    values?: string;
+    currentValue?: string;
+    defaultValue?: string;
+    linked?: boolean;
+    unitSymbol?: string;
+    synced?: boolean;
+    refTimeDimensionMode?: RefTimeDimensionMode;
+}
+/**
+ * WMJSDimension Class
+ * Keep all information for a single dimension, like time.
+ * Author : MaartenPlieger (plieger at knmi.nl)
+ * Copyright KNMI
+ */
+export default class WMJSDimension implements Dimension {
+    currentValue: string;
+    defaultValue: string;
+    name: string;
+    units: string;
+    unitSymbol: string;
+    linked: boolean;
+    synced: boolean;
+    used?: boolean;
+    values?: string;
+    refTimeDimensionMode?: RefTimeDimensionMode;
+    private timeRangeDuration?;
+    private _initialized;
+    private _timeRangeDurationDate;
+    private _allDates;
+    private _type;
+    private _allValues;
+    private dimMinValue;
+    private dimMaxValue;
+    private dimTimeInterval;
+    private calculatedTimeInterval;
+    constructor(config?: WMJSDimensionConfig);
+    generateAllValues(): string[];
+    setTimeValuesForReferenceTimeStandardMode(referenceTimeValueToSet: string, referenceTimeDim: WMJSDimension): void;
+    setTimeValuesForReferenceTime(referenceTimeValueToSet: string, referenceTimeDim: WMJSDimension): void;
+    reInitializeValues(values: string, forceReferenceTimeValue?: boolean): void;
+    initialize(forceothervalues?: string | undefined, forceReferenceTimeValue?: boolean): void;
+    /**
+     * Returns the current value of this dimensions.
+     * If a ISO8601 period is set, the getValue will return a timeRange using addTimeRangeDurationToValue instead of a single value
+     */
+    getValue(): string;
+    processCompressedRefTimeValues(ogcdimvalues: string): void;
+    createTimeStepsArray(partTimeRanges: ParseISOTimeRangeDuration): string[];
+    /**
+     * Set current value of this dimension
+     * @param value The new value for this dimension (string)
+     * @param forceValue When set to false,check if the given value is outside range, and do nothing if this is the case
+     */
+    setValue(value: string, forceValue?: boolean): void;
+    /**
+     * Returns values of the dimension, according to values defined in WMS specification, e.g. 2011-01-01T00:00:00Z/2012-01-01T00:00:00Z/P1M or list of values.
+     * @returns
+     */
+    getValues(): string;
+    setClosestValue(newValue?: string | null, evenWhenOutsideRange?: boolean): void;
+    addTimeRangeDurationToValue(value: string): string;
+    setTimeRangeDuration(duration: string): void;
+    getClosestValueForTime(timeStamp: number): string;
+    getValueForSpecialString(inputValue: string, evenWhenOutsideRange?: boolean): string;
+    getExactMatchingValue(inputValue: string): string;
+    getClosestValue(inputValue: string, evenWhenOutsideRange?: boolean): string;
+    /**
+     * Get dimension value for specified index
+     */
+    getValueForIndex(index: number): string | CustomDate;
+    /**
+     * Get value for index in as epoch time in milliseconds
+     * @param index
+     * @returns
+     */
+    getValueForIndexAsTime(index: number): number;
+    /**
+     * Hint about the timestep size / time resolution of this dimension.
+     * @returns The dimTimeInterval
+     */
+    getDimInterval(): TimeInterval | undefined;
+    /**
+     * Shorthand functionf or getValueForIndex
+     */
+    get(index: number): string;
+    /**
+     * Returns the first dimension value
+     */
+    getFirstValue(): string;
+    getMiddleValue(): string;
+    /**
+     * Returns the last dimension value
+     */
+    getLastValue(): string;
+    /**
+     * Get index value for specified value. Returns the index in the store for the given time value, either a date or a iso8601 string can be passes as input.
+     * @param value Either a JS Date object or an ISO8601 String
+     * @return The index of the value.  If outSideOfRangeFlag is false, a valid index will
+     * always be returned. If outSideOfRangeFlag is true:
+     * -1 if the value is not in the store, and is lower than available values,
+     * -2 if the value is not in the store, and is higher than available values
+     */
+    getIndexForValue(value: string, outSideOfRangeFlag?: boolean): number;
+    /**
+     * Get number of values
+     */
+    size(): number;
+    /**
+     * Clone this dimension
+     */
+    clone(): WMJSDimension;
+}
+export {};

package/dist/src/lib/components/WMJSDimensionModes.d.ts

@@ -0,0 +1,15 @@
+import type { LayerOptions, RefTimeDimensionMode, RefTimeDimensionModes } from '.';
+import type WMJSDimension from './WMJSDimension';
+/**
+ * Determine if the time values have a special sequencing for certain services.
+ * Please check https://gitlab.com/opengeoweb/geoweb-assets/-/issues/4311 for details.
+ * @param layer
+ * @returns
+ */
+export declare const wmDetermineDimensionMode: (layer: LayerOptions, refTimeDimensionModes?: RefTimeDimensionModes) => RefTimeDimensionMode | undefined;
+/**
+ * Based on https://gitlab.com/opengeoweb/geoweb-assets/-/issues/4311
+ * @param wmDimension
+ * @param referenceTimeValueToSet
+ */
+export declare const wmDimensionHandleCustomTimeFunction: (wmDimension: WMJSDimension, referenceTimeValueToSet: string) => void;

package/dist/src/lib/components/WMJSTools.d.ts

@@ -0,0 +1,62 @@
+import type { Dimension, GeographicBoundingBox, LayerProps, Style, WMSLayerFromGetCapabilities } from './types';
+import type WMLayer from './WMLayer';
+export declare const enableConsoleDebugging = false;
+export declare enum DebugType {
+    Log = 0,
+    Warning = 1,
+    Error = 2
+}
+export declare const debugLogger: (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: <T>(variable?: T) => variable is T;
+/**
+ * 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: <T>(array: T | T[] | null | undefined) => T[];
+export declare const getMapDimURL: (layer: WMLayer, dimensionOverride?: Dimension[]) => URLSearchParams;
+/**
+ * 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, unknown>) => 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, unknown>) => string;
+/**
+ * Helper function to figure out the styles from the WMS layer object from the WMS GetCapabilities document
+ * @param layerObjectFromWMS The layer object from the WMS GetCapabilities JSON document
+ * @returns Style[] Array of style objects.
+ */
+export declare const addStylesForLayer: (layerObjectFromWMS: WMSLayerFromGetCapabilities) => Style[];
+export declare const addDimensionsForLayer: (layerObjectFromWMS: WMSLayerFromGetCapabilities) => Dimension[];
+export declare const addBoundingBoxForLayer: (layerObjectFromWMS: WMSLayerFromGetCapabilities) => GeographicBoundingBox | undefined;
+/**
+ * Sorts an array with objects by object key.
+ *
+ * @param array Array of objects
+ * @param key The key of the object to use for sorting
+ * @returns Sorted array.
+ */
+export declare function sortArrayOfObjectsByKey<T>(array: T[], key: keyof T): T[];
+/**
+ * Makes a LayerProps object from the WMSLayerFromGetCapabilities and nestedLayerPath
+ * @param layer WMSLayerFromGetCapabilities
+ * @param path The path of the layer in the WMS GetCapabilities tree (Array of strings)
+ * @param isleaf Is this a group layer or an actual layer
+ * @param nestedLayerPath The path of the layer in the WMS GetCapabilities, in this case array of LayerProps
+ * @returns
+ */
+export declare const makeNodeLayerFromWMSGetCapabilityLayer: (layer: WMSLayerFromGetCapabilities, path?: string[], isleaf?: boolean, nestedLayerPath?: LayerProps[]) => LayerProps;
+export declare const getFirstPartOfDimensionValueSet: (inputValue: string) => string;

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

@@ -0,0 +1,117 @@
+import type { Style, GeographicBoundingBox, OGCWMSWMTSGetCapabilities } from './types';
+import type { RefTimeDimensionMode } from './WMConstants';
+import WMJSDimension from './WMJSDimension';
+import type { LayerOptions } from './WMLayerTypes';
+import { LayerType } from './WMLayerTypes';
+import WMProjection from './WMProjection';
+export default class WMLayer {
+    id: string;
+    name?: string;
+    ReactWMJSLayerId?: string;
+    hasError?: boolean;
+    enabled?: boolean;
+    lastError?: string;
+    legendGraphic?: string;
+    title?: string;
+    opacity?: number;
+    service: string;
+    layerType: LayerType;
+    currentStyle?: string;
+    linkedInfo: {
+        layer: string;
+        message: string;
+    };
+    headers: Headers[];
+    autoupdate: boolean;
+    timer: NodeJS.Timeout | number;
+    getmapURL: string;
+    getfeatureinfoURL: string;
+    getlegendgraphicURL: string;
+    keepOnTop: boolean;
+    transparent: boolean;
+    wms130bboxcompatibilitymode: boolean;
+    version: string;
+    path: string;
+    type: string;
+    abstract: string;
+    dimensions: WMJSDimension[];
+    projectionProperties: WMProjection[];
+    queryable: boolean;
+    styles: Style[];
+    serviceTitle: string;
+    sldURL: string;
+    active: boolean;
+    getgraphinfoURL: string;
+    format: string;
+    _options: LayerOptions;
+    onReady: (param: LayerOptions) => void;
+    optimalFormat: string;
+    wmsextensions: {
+        url: string;
+        colorscalerange: Record<string, unknown>[];
+    };
+    isConfigured: boolean;
+    geographicBoundingBox?: GeographicBoundingBox;
+    geojson?: GeoJSON.FeatureCollection;
+    currentRequestedGetMapURL?: string;
+    olSource: object | null;
+    refTimeDimensionMode: RefTimeDimensionMode | undefined;
+    init(): void;
+    constructor(options?: LayerOptions);
+    getLayerName(): string;
+    toggleAutoUpdate(): void;
+    setAutoUpdate(val: boolean, interval?: number): void;
+    setOpacity(opacityValue: number): void;
+    getOpacity(): number;
+    handleReferenceTime(name: string, value: string): void;
+    getDimensions(): WMJSDimension[];
+    setDimension(name: string, value: string): void;
+    _setWMSGetCapabilities(getCapabilitiesJson: OGCWMSWMTSGetCapabilities): 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 GetCapabilities document, but instead fetch new data from the server
+     * @returns WMLayer object
+     */
+    parseLayer(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>;
+    /**
+     * 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 | undefined;
+    /**
+     * 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;
+}

package/dist/src/lib/components/WMLayerTypes.d.ts

@@ -0,0 +1,66 @@
+import type { FeatureCollection } from 'geojson';
+import type { TileServerSettings } from '../utils';
+import type { Dimension } from './types';
+import type { RefTimeDimensionMode } from './WMConstants';
+import type WMLayer from './WMLayer';
+export declare enum LayerType {
+    mapLayer = "mapLayer",
+    wmtsMapLayer = "wmtsMapLayer",
+    baseLayer = "baseLayer",
+    overLayer = "overLayer",
+    featureLayer = "featureLayer",
+    edrFeatureLayer = "edrFeatureLayer",
+    stacGeoTIFFLayer = "stacGeoTIFFLayer"
+}
+export interface TiledLayerFoundation {
+    tileServer?: TileServerSettings;
+}
+export interface EDRFeatureLayerOptions {
+    collectionId: string;
+    parameterNames: string[];
+}
+export interface LayerFoundation extends TiledLayerFoundation {
+    acceptanceTimeInMinutes?: number | null;
+    dimensions?: Dimension[];
+    enabled?: boolean;
+    format?: string;
+    id?: string;
+    layerType?: LayerType;
+    name?: string;
+    opacity?: number;
+    service?: string;
+    style?: string;
+    title?: string;
+    type?: string;
+    geojson?: FeatureCollection;
+    options?: EDRFeatureLayerOptions;
+    showLayerLegend?: boolean;
+}
+export interface LayerOptions extends LayerFoundation {
+    id: string;
+    layerType: LayerType;
+    service: string;
+    getmapURL?: string;
+    active?: boolean;
+    getgraphinfoURL?: string;
+    currentStyle?: string;
+    sldURL?: string;
+    keepOnTop?: boolean;
+    transparent?: boolean;
+    onReady?: (param: LayerOptions) => void;
+    headers?: Headers[];
+    failure?: (layer: WMLayer, message: string) => void;
+    ReactWMJSLayerId?: string;
+    onLayerError?: (layer: WMLayer, error: Error) => void;
+    onLayerReady?: (layer: WMLayer) => void;
+    geojson?: GeoJSON.FeatureCollection;
+    refTimeDimensionMode?: RefTimeDimensionMode;
+}
+export interface WMSLayerDimInfo {
+    name: string;
+    units: string;
+    unitSymbol: string;
+    value: string;
+    default: string;
+    linkDimensionToMap: boolean;
+}