@opengeoweb/webmap 10.0.0 → 10.1.0

package/index.esm.js

@@ -383,6 +383,41 @@ function _unsupportedIterableToArray(r, a) {
   }
 }
 
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2024 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2024 - Finnish Meteorological Institute (FMI)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+/**
+ * Makes hashed georeferenced url without width, height and bbox
+ * @param url
+ * @returns
+ */
+var makeHashUrlForGeoReferencedImage = function makeHashUrlForGeoReferencedImage(url) {
+  try {
+    var urlAsURL = new URL(url);
+    var urlParams = new URLSearchParams(urlAsURL.search);
+    urlParams["delete"]('BBOX');
+    urlParams["delete"]('WIDTH');
+    urlParams["delete"]('HEIGHT');
+    return "" + urlAsURL.origin + urlAsURL.pathname + "?" + urlParams.toString();
+  } catch (e) {
+    return undefined;
+  }
+};
+
 /* *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -435,6 +470,7 @@ var WMEmptyLayerTitle = 'empty layer';
 var WMDateOutSideRange = 'outside range';
 var WMDateTooEarlyString = 'date too early';
 var WMDateTooLateString = 'date too late';
+var WMInvalidDateValues = new Set([WMDateOutSideRange, WMDateTooEarlyString, WMDateTooLateString]);
 var WMSJSMAP_MINIMUM_MAP_WIDTH = 4;
 var WMSJSMAP_MINIMUM_MAP_HEIGHT = 4;
 var WMSVersion = {
@@ -864,6 +900,8 @@ var WMImage = /*#__PURE__*/function () {
    */
   function WMImage(src, callback, options) {
     var _this = this;
+    this._resolveList = [];
+    this.geoReference = null;
     this._loadDuration = undefined;
     this._loadStartTime = 0;
     this.randomize = false;
@@ -916,6 +954,15 @@ var WMImage = /*#__PURE__*/function () {
     };
   }
   var _proto = WMImage.prototype;
+  _proto.setGeoReference = function setGeoReference(geoReference) {
+    if (this.geoReference) {
+      return;
+    }
+    this.geoReference = {
+      extent: [].concat(geoReference.extent),
+      resolution: geoReference.resolution
+    };
+  };
   _proto.init = function init() {
     this._srcLoaded = 'undefined image';
     this._isLoaded = false;
@@ -1019,10 +1066,39 @@ var WMImage = /*#__PURE__*/function () {
    */;
   _proto.hasError = function hasError() {
     return this._hasError;
+  };
+  _proto._resolveAll = function _resolveAll() {
+    while (this._resolveList.length !== 0) {
+      var resolve = this._resolveList.pop();
+      resolve && resolve(this);
+    }
   }
   /**
    * Start loading the image
    */;
+  _proto.loadAwait =
+  /*#__PURE__*/
+  function () {
+    var _loadAwait = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var _this2 = this;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", new Promise(function (resolve) {
+              _this2._resolveList.push(resolve);
+              _this2.load();
+            }));
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function loadAwait() {
+      return _loadAwait.apply(this, arguments);
+    }
+    return loadAwait;
+  }();
   _proto.load = function load() {
     if (!this._isLoading) {
       this._load();
@@ -1042,7 +1118,7 @@ var WMImage = /*#__PURE__*/function () {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ;
   _proto._getImageWithHeaders = function _getImageWithHeaders(url, headers) {
-    var _this2 = this;
+    var _this3 = this;
     var fetchHeaders = new Headers();
     if (headers && headers.length > 0) {
       for (var _iterator = _createForOfIteratorHelperLoose(headers), _step; !(_step = _iterator()).done;) {
@@ -1069,7 +1145,7 @@ var WMImage = /*#__PURE__*/function () {
       response.arrayBuffer().then(function (buffer) {
         var base64Flag = 'data:image/png;base64,';
         var imageStr = arrayBufferToBase64(buffer);
-        _this2.getElement().src = base64Flag + imageStr;
+        _this3.getElement().src = base64Flag + imageStr;
       })["catch"](function () {
         debugLogger(DebugType.Error);
       });
@@ -1078,7 +1154,7 @@ var WMImage = /*#__PURE__*/function () {
       if (url.startsWith('http://')) {
         debugLogger(DebugType.Error);
       }
-      _this2._loadEvent(true);
+      _this3._loadEvent(true);
     });
   };
   _proto._load = function _load() {
@@ -1140,6 +1216,7 @@ var WMImage = /*#__PURE__*/function () {
     this._isLoading = false;
     this._isLoaded = true;
     this._srcLoaded = this.srcToLoad;
+    this._resolveAll();
     (_this$loadEventCallba = this.loadEventCallback) == null || _this$loadEventCallba.call(this, this);
   };
   _proto.getLoadDuration = function getLoadDuration() {
@@ -1171,6 +1248,7 @@ var WMImageEventType;
   WMImageEventType[WMImageEventType["Loaded"] = 0] = "Loaded";
   WMImageEventType[WMImageEventType["Deleted"] = 1] = "Deleted";
 })(WMImageEventType || (WMImageEventType = {}));
+var WMIMAGESTORE_MAX_ALTIMAGES_TO_KEEP = 4;
 var WMImageStore = /*#__PURE__*/function () {
   /**
    * Constructs a new WMImageStore with given amount of image cache.
@@ -1179,12 +1257,13 @@ var WMImageStore = /*#__PURE__*/function () {
    */
   function WMImageStore(maxNumberOfImages, options) {
     this.imagesbysrc = new Map();
+    this.imagesbyGeoRef = new Map();
     this.imageLife = 0;
     this._imageLifeCounter = 0;
     this._loadEventCallbackList = []; // Array of callbacks, as multiple instances can register listeners
     this._maxNumberOfImages = maxNumberOfImages;
     this._options = options;
-    this.emptyImage = new WMImage(null, null, null);
+    this.emptyImage = new WMImage(null, null);
     this.imageLoadEventCallback = this.imageLoadEventCallback.bind(this);
     this.getImageForSrc = this.getImageForSrc.bind(this);
     this.clear = this.clear.bind(this);
@@ -1196,7 +1275,7 @@ var WMImageStore = /*#__PURE__*/function () {
   }
   var _proto = WMImageStore.prototype;
   _proto.load = function load(imageUrl) {
-    return this.getImage(imageUrl).load();
+    return this.getImage(imageUrl).loadAwait();
   };
   _proto.imageLoadEventCallback = function imageLoadEventCallback(_img, imageEventType) {
     for (var _iterator = _createForOfIteratorHelperLoose(this._loadEventCallbackList), _step; !(_step = _iterator()).done;) {
@@ -1249,6 +1328,68 @@ var WMImageStore = /*#__PURE__*/function () {
     });
     return numLoading;
   }
+  /**
+   * 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
+   */;
+  _proto.getAltGeoReferencedImage = function getAltGeoReferencedImage(srcToLoad,
+  // eslint-disable-next-line no-unused-vars
+  _extent,
+  // eslint-disable-next-line no-unused-vars
+  _resolution) {
+    var hashUrl = makeHashUrlForGeoReferencedImage(srcToLoad);
+    if (!hashUrl) {
+      return false;
+    }
+    // Sort the imagesbyGeoRef array
+    var imagesbyGeoRefArray = this.imagesbyGeoRef.get(hashUrl);
+    if (!imagesbyGeoRefArray || imagesbyGeoRefArray.length === 0) {
+      return false;
+    }
+    // Clean the set, only keep the most recent images
+    var imagesbyGeoRefArraySortByImageLife = imagesbyGeoRefArray.sort(function (a, b) {
+      if (a.imageLife > b.imageLife) {
+        return -1;
+      }
+      if (a.imageLife < b.imageLife) {
+        return 1;
+      }
+      return 0;
+    }).slice(0, WMIMAGESTORE_MAX_ALTIMAGES_TO_KEEP);
+    // Set this array back in the array
+    this.imagesbyGeoRef.set(hashUrl, imagesbyGeoRefArraySortByImageLife);
+    // Now filter out the loaded images, which can be used as alternative
+    var sortByImageLifeFilterdLoaded = imagesbyGeoRefArraySortByImageLife.filter(function (image) {
+      return image.isLoadedWithoutErrors();
+    });
+    // Just return most recent available image: TODO: Possibly make use of extent and resolution to find a better one.
+    return sortByImageLifeFilterdLoaded.length > 0 ? sortByImageLifeFilterdLoaded[0] : false;
+  };
+  _proto.getGeoReferencedImage = function getGeoReferencedImage(src, geoReference) {
+    var image = this.getImage(src);
+    if (image) {
+      // Make a hashUrl without BBOX
+      if (!image.hashUrl) {
+        var _this$imagesbyGeoRef$;
+        var hashUrl = makeHashUrlForGeoReferencedImage(image.srcToLoad);
+        if (!hashUrl) {
+          return null;
+        }
+        image.hashUrl = hashUrl;
+        if (image.hashUrl && !this.imagesbyGeoRef.has(image.hashUrl)) {
+          this.imagesbyGeoRef.set(image.hashUrl, []);
+        }
+        image.hashUrl && ((_this$imagesbyGeoRef$ = this.imagesbyGeoRef.get(image.hashUrl)) == null ? void 0 : _this$imagesbyGeoRef$.push(image));
+      }
+      image.setGeoReference(geoReference);
+    }
+    return image;
+  }
   /**
    * Get an WMImage object for given URL
    * @param {*} src The url for the image
@@ -1259,8 +1400,8 @@ var WMImageStore = /*#__PURE__*/function () {
     if (!src) {
       return null;
     }
-    /** Check if we have an image in the pipeline * */
-    var image = this.getImageForSrc(src);
+    // Check if we have an image in the pipeline
+    var image = this.imagesbysrc.get(src);
     if (image !== undefined) {
       this._imageLifeCounter += 1;
       image.imageLife = this._imageLifeCounter;
@@ -1268,41 +1409,50 @@ var WMImageStore = /*#__PURE__*/function () {
     }
     // Create  image
     if (this.imagesbysrc.size < this._maxNumberOfImages) {
-      image = new WMImage(src, function (img) {
+      var _newImage = new WMImage(src, function (img) {
         _this.imageLoadEventCallback(img, WMImageEventType.Loaded);
       });
-      image.setSource(src, loadOptions);
-      this.imagesbysrc.set(src, image);
+      _newImage.setSource(src, loadOptions);
+      this.imagesbysrc.set(src, _newImage);
       this._imageLifeCounter += 1;
-      image.imageLife = this._imageLifeCounter;
-      return image;
+      _newImage.imageLife = this._imageLifeCounter;
+      return _newImage;
     }
-    /* We have to reuse an image */
-    var imageId = '';
-    var minImageLife = this._imageLifeCounter;
-    this.imagesbysrc.forEach(function (img, url) {
-      if (img && img.isLoading() === false || img && img.hasError() === true) {
-        if (minImageLife >= img.imageLife) {
-          minImageLife = img.imageLife;
-          imageId = url;
-        }
+    // We have to reuse an image
+    var imagesAsList = Array.from(this.imagesbysrc.values()).filter(function (imageBySrc) {
+      return !imageBySrc || !imageBySrc.isLoading() || imageBySrc.hasError();
+    });
+    imagesAsList.sort(function (a, b) {
+      if (a.imageLife < b.imageLife) {
+        return -1;
+      }
+      if (a.imageLife > b.imageLife) {
+        return 1;
       }
+      return 0;
     });
-    if (imageId === '') {
-      return this.emptyImage;
-    }
-    image = this.imagesbysrc.get(imageId);
-    if (image) {
-      this.imagesbysrc["delete"](imageId);
-      this.imageLoadEventCallback(image, WMImageEventType.Deleted);
-      image.clear();
-      image.setSource(src, loadOptions);
-      this.imagesbysrc.set(src, image);
-      this._imageLifeCounter += 1;
-      image.imageLife = this._imageLifeCounter;
-      return image;
-    }
-    return null;
+    var imageIdByUrl = (imagesAsList == null ? void 0 : imagesAsList.length) > 0 ? imagesAsList[0].srcToLoad : '';
+    if (imageIdByUrl === '') {
+      console.error('IMAGESTORE TO LARGE TO LOAD');
+    } else {
+      var hashUrl = makeHashUrlForGeoReferencedImage(imageIdByUrl);
+      hashUrl && this.imagesbyGeoRef["delete"](hashUrl);
+      var reuseImage = this.imagesbysrc.get(imageIdByUrl);
+      if (reuseImage) {
+        this.imagesbysrc["delete"](imageIdByUrl);
+        this.imageLoadEventCallback(reuseImage, WMImageEventType.Deleted);
+        reuseImage.clear();
+      }
+    }
+    // Force return of new image
+    var newImage = new WMImage(src, function (img) {
+      _this.imageLoadEventCallback(img, WMImageEventType.Loaded);
+    });
+    newImage.setSource(src, loadOptions);
+    this.imagesbysrc.set(src, newImage);
+    this._imageLifeCounter += 1;
+    newImage.imageLife = this._imageLifeCounter;
+    return newImage;
   };
   return WMImageStore;
 }();
@@ -3981,9 +4131,9 @@ var WMJSDimension = /*#__PURE__*/function () {
     } else if (this._type === 'timevalues') {
       /* Filter all dates from the array which are lower than given start value */
       /* TODO: Maarten Plieger 2020-06-10: Make this also work for WMS times advertised as a comma separated list */
-      var _newValue2 = parseISO8601DateToDate(newStartValueTime.toISOString());
+      var _newValue = parseISO8601DateToDate(newStartValueTime.toISOString());
       var newArray = this._allDates.filter(function (x) {
-        return x >= _newValue2;
+        return x >= _newValue;
       });
       var newValues = '';
       for (var j = 0; j < newArray.length; j += 1) {
@@ -4263,36 +4413,37 @@ var WMJSDimension = /*#__PURE__*/function () {
       this.reInitializeValues(this.values);
     }
   };
-  _proto.getClosestValue = function getClosestValue(_newValue, evenWhenOutsideRange) {
+  _proto.getClosestValueForTime = function getClosestValueForTime(timeStamp) {
+    var timeToFind = new Date(timeStamp).toISOString().substring(0, 19) + "Z";
+    return this.getClosestValue(timeToFind);
+  };
+  _proto.getClosestValue = function getClosestValue(inputValue, evenWhenOutsideRange) {
     if (evenWhenOutsideRange === void 0) {
       evenWhenOutsideRange = false;
     }
     this.initialize();
     if (!this._initialized) {
-      return _newValue;
-    }
-    var newValue = _newValue && _newValue.indexOf('/') !== -1 ? _newValue.split('/')[0] : _newValue;
-    if (newValue === 'current' || newValue === 'default' || newValue === '') {
-      return this.defaultValue;
-    }
-    if (newValue === 'middle') {
-      var middleIndex = Math.ceil(this.size() / 2) - 1;
-      if (middleIndex < 0) {
-        middleIndex = 0;
-      }
-      return this.getValueForIndex(middleIndex);
-    }
-    if (newValue === 'latest') {
-      return this.getLastValue();
-    }
-    if (newValue === 'earliest') {
-      return this.getFirstValue();
+      return inputValue;
+    }
+    var newValue = (inputValue == null ? void 0 : inputValue.indexOf('/')) === -1 ? inputValue : inputValue.split('/')[0];
+    switch (newValue) {
+      case 'current':
+      case 'default':
+      case '':
+        return this.defaultValue;
+      case 'middle':
+        {
+          var middleIndex = Math.ceil(this.size() / 2) - 1;
+          return this.getValueForIndex(middleIndex > 0 ? middleIndex : 0);
+        }
+      case 'earliest':
+        return this.getFirstValue();
+      case 'latest':
+        return this.getLastValue();
     }
-    var index = -1;
     var value = WMDateOutSideRange;
     try {
-      index = this.getIndexForValue(newValue);
-      value = this.getValueForIndex(index);
+      value = this.getValueForIndex(this.getIndexForValue(newValue) || -1);
     } catch (e) {
       if (typeof e.message === 'number') {
         if (e.message === '0') {
@@ -7321,15 +7472,18 @@ var privateWmsFlattenLayerTree = function privateWmsFlattenLayerTree(layerTree)
   var flatLayerObject = recurseLayerTree(layerTree.children);
   return sortArrayOfObjectsByKey(flatLayerObject, 'title');
 };
-var privateGetWMSUrl = function privateGetWMSUrl(service, additionalParams) {
+var privateGetOGCCapabilitiesUrl = function privateGetOGCCapabilitiesUrl(url, service, additionalParams) {
+  if (url === void 0) {
+    url = '';
+  }
   if (service === void 0) {
-    service = '';
+    service = 'WMS';
   }
   if (additionalParams === void 0) {
     additionalParams = {};
   }
-  return getUriAddParam(service, Object.assign({
-    service: 'WMS',
+  return getUriAddParam(url, Object.assign({
+    service: service,
     request: 'GetCapabilities'
   }, additionalParams));
 };
@@ -7372,7 +7526,7 @@ var privateWmsGetCapabilities = /*#__PURE__*/function () {
           addParams = forceReload ? {
             random: Math.random()
           } : {};
-          url = privateGetWMSUrl(serviceUrl.indexOf('?') === -1 ? serviceUrl + "?" : serviceUrl, addParams);
+          url = privateGetOGCCapabilitiesUrl(serviceUrl.indexOf('?') === -1 ? serviceUrl + "?" : serviceUrl, 'WMS', addParams);
           return _context.abrupt("return", WMXMLParser(url, headers));
         case 13:
         case "end":
@@ -7384,6 +7538,67 @@ var privateWmsGetCapabilities = /*#__PURE__*/function () {
     return _ref2.apply(this, arguments);
   };
 }();
+var privateWmtsGetCapabilities = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(serviceUrl, headers, forceReload) {
+    var addParams, url, fetchHeaders, _iterator, _step, header;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (headers === void 0) {
+            headers = [];
+          }
+          if (forceReload === void 0) {
+            forceReload = false;
+          }
+          if (isDefined(serviceUrl)) {
+            _context2.next = 4;
+            break;
+          }
+          throw new Error(consoleErrorMessages.noServiceDefined);
+        case 4:
+          if (!(serviceUrl.length === 0)) {
+            _context2.next = 6;
+            break;
+          }
+          throw new Error(consoleErrorMessages.serviceUrlEmpty);
+        case 6:
+          if (!(!serviceUrl.startsWith('http://') && !serviceUrl.startsWith('https:') && !serviceUrl.startsWith('//'))) {
+            _context2.next = 8;
+            break;
+          }
+          throw new Error(consoleErrorMessages.serviceUrlEmpty);
+        case 8:
+          addParams = forceReload ? {
+            random: Math.random()
+          } : {};
+          url = privateGetOGCCapabilitiesUrl(serviceUrl.indexOf('?') === -1 ? serviceUrl + "?" : serviceUrl, 'WMTS', addParams);
+          fetchHeaders = new Headers();
+          if (headers && headers.length > 0) {
+            for (_iterator = _createForOfIteratorHelperLoose(headers); !(_step = _iterator()).done;) {
+              header = _step.value;
+              fetchHeaders.append(header.name, header.value);
+            }
+          }
+          return _context2.abrupt("return", fetch(url, {
+            headers: fetchHeaders
+          }).then(function (response) {
+            return response.text();
+          }));
+        case 13:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function privateWmtsGetCapabilities(_x4, _x5, _x6) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * privateWmsGetCapabilityElement
+ * @param jsonData
+ * @returns
+ */
 var privateWmsGetCapabilityElement = function privateWmsGetCapabilityElement(jsonData) {
   var capabilityObject;
   try {
@@ -10947,7 +11162,8 @@ var privateWebMapUtils = {
   privateGetWMSServiceInfo: privateGetWMSServiceInfo,
   privateWmsGetLayerTree: privateWmsGetLayerTree,
   privateWmsFlattenLayerTree: privateWmsFlattenLayerTree,
+  privateWmtsGetCapabilities: privateWmtsGetCapabilities,
   QUERYWMS_GETCAPABILITIES: QUERYWMS_GETCAPABILITIES
 };
 
-export { DateInterval, DebugType, EVENT_GETCAPABILITIES_READY, EVENT_GETCAPABILITIES_START, LayerType, ParseISOTimeRangeDuration, URLDecode, URLEncode, WEBMAP_NAMESPACE, WMBBOX, WMDateOutSideRange, WMDateTooEarlyString, WMDateTooLateString, WMEmptyLayerName, WMEmptyLayerTitle, WMImage, WMImageEventType, WMImageStore, WMJSDimension, WMJSMAP_LONLAT_EPSGCODE, WMJSMap, WMJScheckURL, WMLayer, WMListener, WMProj4Defs, WMProjection, WMSJSMAP_MINIMUM_MAP_HEIGHT, WMSJSMAP_MINIMUM_MAP_WIDTH, WMSVersion, WMXMLStringToJson, bgImageStoreLength, buildMapLayerDims, buildWMSGetMapRequest, clearImageCacheForAllMaps, debugLogger, detectLeftButton, detectRightButton, drawScaleBar, drawTextBG, generateLayerId, generateMapId, generateTimesliderId, getBBOXandProjString, getErrorsToDisplay, getGeoCoordFromLatLong, getGeoCoordFromPixelCoord, getLatLongFromPixelCoord, getLayerIndex, getLegendGraphicURLForLayer, getPixelCoordFromGeoCoord, getPixelCoordFromLatLong, getScaleBarProperties, getUriWithParam, getWMJSDimensionForLayerAndDimension, getWMJSMapById, getWMJSMapIds, getWMJSTimeDimensionForLayerId, getWMLayerById, getWMSGetFeatureInfoRequestURL, getWMSRequests, getWMSServiceId, handleDateUtilsISOString, invalidateWMSGetCapabilities, isDefined, isProjectionSupported, legendImageStore, legendImageStoreLength, mapImageStoreLength, mockGetCapabilities, parseISO8601DateToDate, parseISO8601IntervalToDateInterval, privateWebMapUtils, queryWMSGetCapabilities, queryWMSLayer, queryWMSLayers, queryWMSLayersTree, queryWMSServiceInfo, registerWMJSMap, registerWMLayer, roundWithTimeStep, setWMSGetCapabilitiesFetcher, tilesettings, toArray, unRegisterAllWMJSLayersAndMaps, unRegisterWMJSLayer, unRegisterWMJSMap, index as webmapTestSettings, webmapTranslations, utils as webmapUtils, wmServiceListener, wmsQueryClient };
+export { DateInterval, DebugType, EVENT_GETCAPABILITIES_READY, EVENT_GETCAPABILITIES_START, LayerType, ParseISOTimeRangeDuration, URLDecode, URLEncode, WEBMAP_NAMESPACE, WMBBOX, WMDateOutSideRange, WMDateTooEarlyString, WMDateTooLateString, WMEmptyLayerName, WMEmptyLayerTitle, WMImage, WMImageEventType, WMImageStore, WMInvalidDateValues, WMJSDimension, WMJSMAP_LONLAT_EPSGCODE, WMJSMap, WMJScheckURL, WMLayer, WMListener, WMProj4Defs, WMProjection, WMSJSMAP_MINIMUM_MAP_HEIGHT, WMSJSMAP_MINIMUM_MAP_WIDTH, WMSVersion, WMXMLStringToJson, bgImageStoreLength, buildMapLayerDims, buildWMSGetMapRequest, clearImageCacheForAllMaps, debugLogger, detectLeftButton, detectRightButton, drawScaleBar, drawTextBG, generateLayerId, generateMapId, generateTimesliderId, getBBOXandProjString, getErrorsToDisplay, getGeoCoordFromLatLong, getGeoCoordFromPixelCoord, getLatLongFromPixelCoord, getLayerIndex, getLegendGraphicURLForLayer, getPixelCoordFromGeoCoord, getPixelCoordFromLatLong, getScaleBarProperties, getUriWithParam, getWMJSDimensionForLayerAndDimension, getWMJSMapById, getWMJSMapIds, getWMJSTimeDimensionForLayerId, getWMLayerById, getWMSGetFeatureInfoRequestURL, getWMSRequests, getWMSServiceId, handleDateUtilsISOString, invalidateWMSGetCapabilities, isDefined, isProjectionSupported, legendImageStore, legendImageStoreLength, mapImageStoreLength, mockGetCapabilities, parseISO8601DateToDate, parseISO8601IntervalToDateInterval, privateWebMapUtils, queryWMSGetCapabilities, queryWMSLayer, queryWMSLayers, queryWMSLayersTree, queryWMSServiceInfo, registerWMJSMap, registerWMLayer, roundWithTimeStep, setWMSGetCapabilitiesFetcher, tilesettings, toArray, unRegisterAllWMJSLayersAndMaps, unRegisterWMJSLayer, unRegisterWMJSMap, index as webmapTestSettings, webmapTranslations, utils as webmapUtils, wmServiceListener, wmsQueryClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/webmap",
-  "version": "10.0.0",
+  "version": "10.1.0",
   "description": "GeoWeb webmap library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {

package/src/index.d.ts

@@ -9,6 +9,7 @@ declare const privateWebMapUtils: {
     privateGetWMSServiceInfo: (getCapabilitiesJson: import("./lib").GetCapabilitiesJson, serviceUrl: string) => import("./lib").WMSServiceInfo;
     privateWmsGetLayerTree: (jsonData: import("./lib").GetCapabilitiesJson) => import("./lib").LayerTree;
     privateWmsFlattenLayerTree: (layerTree: import("./lib").LayerTree) => import("./lib").LayerProps[];
+    privateWmtsGetCapabilities: (serviceUrl: string, headers?: import("./lib").Header[], forceReload?: boolean) => Promise<string>;
     QUERYWMS_GETCAPABILITIES: string;
 };
 export { privateWebMapUtils };

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

@@ -253,13 +253,13 @@ interface IWMJSMap {
      * @param f
      * @param keep
      */
-    addListener(name: string, f: (param?: unknown) => void, keep?: boolean): boolean;
+    addListener<T>(name: string, f: (param: T) => void | boolean, keep?: boolean): boolean;
     /**
      * Remove something from the event listener
      * @param name
      * @param f
      */
-    removeListener(name: string, f: (param?: unknown) => void): void;
+    removeListener<T>(name: string, f: (param: T) => void): void;
     /**
      * Get a direct handle to the event listener system
      */

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

@@ -3,6 +3,7 @@ export declare const WMEmptyLayerTitle = "empty layer";
 export declare const WMDateOutSideRange = "outside range";
 export declare const WMDateTooEarlyString = "date too early";
 export declare const WMDateTooLateString = "date too late";
+export declare const WMInvalidDateValues: Set<string>;
 export declare const WMSJSMAP_MINIMUM_MAP_WIDTH = 4;
 export declare const WMSJSMAP_MINIMUM_MAP_HEIGHT = 4;
 export declare const WMSVersion: {

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

@@ -3,6 +3,10 @@ export interface WMImageOptions {
     headers: Headers[];
     fakeMaxAge?: number;
 }
+export interface WMGeoReference {
+    extent: number[];
+    resolution: number;
+}
 /**
  * Returns the current time in ms
  * @returns the current time in ms
@@ -27,6 +31,10 @@ export default class WMImage {
     _loadStartTime: number;
     _loadDuration?: number;
     _fakeMaxAge?: number | null;
+    _resolveList: ((i: WMImage) => void)[];
+    geoReference: WMGeoReference | null;
+    hashUrl: string | undefined;
+    setGeoReference(geoReference: WMGeoReference): void;
     /**
      *
      * @param src Optionally set the source URL to load
@@ -73,14 +81,16 @@ export default class WMImage {
      * Check if the image has an error
      */
     hasError(): boolean;
+    private _resolveAll;
     /**
      * Start loading the image
      */
+    loadAwait(): Promise<WMImage>;
     load(): void;
     forceReload(randomize?: boolean): void;
     private _getImageWithHeaders;
-    private _load;
-    private _loadEvent;
+    _load(): void;
+    _loadEvent(hasError: boolean): void;
     getLoadDuration(): number | undefined;
     /**
      * Get the width of the current image

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

@@ -1,4 +1,4 @@
-import WMImage, { WMImageOptions } from './WMImage';
+import WMImage, { WMGeoReference, WMImageOptions } from './WMImage';
 export declare enum WMImageEventType {
     Loaded = 0,
     Deleted = 1
@@ -16,6 +16,7 @@ export default class WMImageStore {
         id: string;
     };
     emptyImage: WMImage;
+    imagesbyGeoRef: Map<string, WMImage[]>;
     /**
      * Constructs a new WMImageStore with given amount of image cache.
      * @param {*} maxNumberOfImages
@@ -24,7 +25,7 @@ export default class WMImageStore {
     constructor(maxNumberOfImages: number, options: {
         id: string;
     });
-    load(imageUrl: string): void;
+    load(imageUrl: string): Promise<WMImage>;
     imageLoadEventCallback(_img: WMImage, imageEventType: WMImageEventType): void;
     /**
      * Check if we have similar images with the same source in the pipeline
@@ -35,6 +36,17 @@ export default class WMImageStore {
     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;
+    getGeoReferencedImage(src: string, geoReference: WMGeoReference): WMImage;
     /**
      * Get an WMImage object for given URL
      * @param {*} src The url for the image

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

@@ -69,7 +69,8 @@ export default class WMJSDimension implements Dimension {
     setClosestValue(newValue?: string | null, evenWhenOutsideRange?: boolean): void;
     addTimeRangeDurationToValue(value: string): string;
     setTimeRangeDuration(duration: string): void;
-    getClosestValue(_newValue: string, evenWhenOutsideRange?: boolean): string;
+    getClosestValueForTime(timeStamp: number): string;
+    getClosestValue(inputValue: string, evenWhenOutsideRange?: boolean): string;
     /**
      * Get dimension value for specified index
      */

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

@@ -0,0 +1,6 @@
+/**
+ * Makes hashed georeferenced url without width, height and bbox
+ * @param url
+ * @returns
+ */
+export declare const makeHashUrlForGeoReferencedImage: (url: string) => string | undefined;

package/src/lib/components/makeHashUrlForGeoReferencedImage.spec.d.ts

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

package/src/lib/utils/getCapabilities/utils.d.ts

@@ -6,8 +6,14 @@ import { Capability, GetCapabilitiesJson, Header, LayerProps, LayerTree, WMSLaye
  * @returns Flat array of layers as LayerProps[]
  */
 export declare const privateWmsFlattenLayerTree: (layerTree: LayerTree) => LayerProps[];
-export declare const privateGetWMSUrl: (service?: string, additionalParams?: {}) => string;
+export declare const privateGetOGCCapabilitiesUrl: (url?: string, service?: string, additionalParams?: {}) => string;
 export declare const privateWmsGetCapabilities: (serviceUrl: string, headers?: Header[], forceReload?: boolean) => Promise<GetCapabilitiesJson>;
+export declare const privateWmtsGetCapabilities: (serviceUrl: string, headers?: Header[], forceReload?: boolean) => Promise<string>;
+/**
+ * privateWmsGetCapabilityElement
+ * @param jsonData
+ * @returns
+ */
 export declare const privateWmsGetCapabilityElement: (jsonData: GetCapabilitiesJson) => Capability;
 export declare const privateCheckException: (jsonData: GetCapabilitiesJson) => string | undefined;
 export declare const privateWmsGetRootLayerFromGetCapabilities: (jsonData: GetCapabilitiesJson) => WMSLayerFromGetCapabilities;