ol 7.1.1-pr.14101.2 → 7.2.0

package/renderer/canvas/VectorLayer.js

@@ -63,7 +63,7 @@ class CanvasVectorLayerRenderer extends CanvasLayerRenderer {
     this.animatingOrInteracting_;
 
     /**
-     * @type {ImageData}
+     * @type {ImageData|null}
      */
     this.hitDetectionImageData_ = null;
 
@@ -334,100 +334,95 @@ class CanvasVectorLayerRenderer extends CanvasLayerRenderer {
   /**
    * Asynchronous layer level hit detection.
    * @param {import("../../pixel.js").Pixel} pixel Pixel.
-   * @return {Promise<Array<import("../../Feature").default>>} Promise that resolves with an array of features.
+   * @return {Promise<Array<import("../../Feature").default>>} Promise
+   * that resolves with an array of features.
    */
   getFeatures(pixel) {
-    return new Promise(
-      /**
-       * @param {function(Array<import("../../Feature").default|import("../../render/Feature").default>): void} resolve Resolver function.
-       * @this {CanvasVectorLayerRenderer}
-       */
-      function (resolve) {
-        if (!this.hitDetectionImageData_ && !this.animatingOrInteracting_) {
-          const size = [this.context.canvas.width, this.context.canvas.height];
-          apply(this.pixelTransform, size);
-          const center = this.renderedCenter_;
-          const resolution = this.renderedResolution_;
-          const rotation = this.renderedRotation_;
-          const projection = this.renderedProjection_;
-          const extent = this.wrappedRenderedExtent_;
-          const layer = this.getLayer();
-          const transforms = [];
-          const width = size[0] * HIT_DETECT_RESOLUTION;
-          const height = size[1] * HIT_DETECT_RESOLUTION;
-          transforms.push(
-            this.getRenderTransform(
-              center,
-              resolution,
-              rotation,
-              HIT_DETECT_RESOLUTION,
-              width,
-              height,
-              0
-            ).slice()
-          );
-          const source = layer.getSource();
-          const projectionExtent = projection.getExtent();
-          if (
-            source.getWrapX() &&
-            projection.canWrapX() &&
-            !containsExtent(projectionExtent, extent)
-          ) {
-            let startX = extent[0];
-            const worldWidth = getWidth(projectionExtent);
-            let world = 0;
-            let offsetX;
-            while (startX < projectionExtent[0]) {
-              --world;
-              offsetX = worldWidth * world;
-              transforms.push(
-                this.getRenderTransform(
-                  center,
-                  resolution,
-                  rotation,
-                  HIT_DETECT_RESOLUTION,
-                  width,
-                  height,
-                  offsetX
-                ).slice()
-              );
-              startX += worldWidth;
-            }
-            world = 0;
-            startX = extent[2];
-            while (startX > projectionExtent[2]) {
-              ++world;
-              offsetX = worldWidth * world;
-              transforms.push(
-                this.getRenderTransform(
-                  center,
-                  resolution,
-                  rotation,
-                  HIT_DETECT_RESOLUTION,
-                  width,
-                  height,
-                  offsetX
-                ).slice()
-              );
-              startX -= worldWidth;
-            }
-          }
-
-          this.hitDetectionImageData_ = createHitDetectionImageData(
-            size,
-            transforms,
-            this.renderedFeatures_,
-            layer.getStyleFunction(),
-            extent,
+    return new Promise((resolve) => {
+      if (!this.hitDetectionImageData_ && !this.animatingOrInteracting_) {
+        const size = [this.context.canvas.width, this.context.canvas.height];
+        apply(this.pixelTransform, size);
+        const center = this.renderedCenter_;
+        const resolution = this.renderedResolution_;
+        const rotation = this.renderedRotation_;
+        const projection = this.renderedProjection_;
+        const extent = this.wrappedRenderedExtent_;
+        const layer = this.getLayer();
+        const transforms = [];
+        const width = size[0] * HIT_DETECT_RESOLUTION;
+        const height = size[1] * HIT_DETECT_RESOLUTION;
+        transforms.push(
+          this.getRenderTransform(
+            center,
             resolution,
-            rotation
-          );
+            rotation,
+            HIT_DETECT_RESOLUTION,
+            width,
+            height,
+            0
+          ).slice()
+        );
+        const source = layer.getSource();
+        const projectionExtent = projection.getExtent();
+        if (
+          source.getWrapX() &&
+          projection.canWrapX() &&
+          !containsExtent(projectionExtent, extent)
+        ) {
+          let startX = extent[0];
+          const worldWidth = getWidth(projectionExtent);
+          let world = 0;
+          let offsetX;
+          while (startX < projectionExtent[0]) {
+            --world;
+            offsetX = worldWidth * world;
+            transforms.push(
+              this.getRenderTransform(
+                center,
+                resolution,
+                rotation,
+                HIT_DETECT_RESOLUTION,
+                width,
+                height,
+                offsetX
+              ).slice()
+            );
+            startX += worldWidth;
+          }
+          world = 0;
+          startX = extent[2];
+          while (startX > projectionExtent[2]) {
+            ++world;
+            offsetX = worldWidth * world;
+            transforms.push(
+              this.getRenderTransform(
+                center,
+                resolution,
+                rotation,
+                HIT_DETECT_RESOLUTION,
+                width,
+                height,
+                offsetX
+              ).slice()
+            );
+            startX -= worldWidth;
+          }
         }
-        resolve(
-          hitDetect(pixel, this.renderedFeatures_, this.hitDetectionImageData_)
+
+        this.hitDetectionImageData_ = createHitDetectionImageData(
+          size,
+          transforms,
+          this.renderedFeatures_,
+          layer.getStyleFunction(),
+          extent,
+          resolution,
+          rotation
         );
-      }.bind(this)
-    );
+      }
+      resolve(
+        hitDetect(pixel, this.renderedFeatures_, this.hitDetectionImageData_)
+      );
+    });
   }
 
   /**
@@ -679,9 +674,8 @@ class CanvasVectorLayerRenderer extends CanvasLayerRenderer {
     const render =
       /**
        * @param {import("../../Feature.js").default} feature Feature.
-       * @this {CanvasVectorLayerRenderer}
        */
-      function (feature) {
+      (feature) => {
         let styles;
         const styleFunction =
           feature.getStyleFunction() || vectorLayer.getStyleFunction();
@@ -699,7 +693,7 @@ class CanvasVectorLayerRenderer extends CanvasLayerRenderer {
           );
           ready = ready && !dirty;
         }
-      }.bind(this);
+      };
 
     const userExtent = toUserExtent(extent, projection);
     /** @type {Array<import("../../Feature.js").default>} */

package/renderer/canvas/VectorTileLayer.js

@@ -434,97 +434,97 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
   /**
    * Asynchronous layer level hit detection.
    * @param {import("../../pixel.js").Pixel} pixel Pixel.
-   * @return {Promise<Array<import("../../Feature").default>>} Promise that resolves with an array of features.
+   * @return {Promise<Array<import("../../Feature.js").FeatureLike>>} Promise that resolves with an array of features.
    */
   getFeatures(pixel) {
-    return new Promise(
-      function (resolve, reject) {
-        const layer =
-          /** @type {import("../../layer/VectorTile.js").default} */ (
-            this.getLayer()
+    return new Promise((resolve, reject) => {
+      const layer = this.getLayer();
+      const layerUid = getUid(layer);
+      const source = layer.getSource();
+      const projection = this.renderedProjection;
+      const projectionExtent = projection.getExtent();
+      const resolution = this.renderedResolution;
+      const tileGrid = source.getTileGridForProjection(projection);
+      const coordinate = applyTransform(
+        this.renderedPixelToCoordinateTransform_,
+        pixel.slice()
+      );
+      const tileCoord = tileGrid.getTileCoordForCoordAndResolution(
+        coordinate,
+        resolution
+      );
+      /** @type {import("../../VectorRenderTile.js").default|undefined} */
+      let tile;
+      for (let i = 0, ii = this.renderedTiles.length; i < ii; ++i) {
+        if (
+          tileCoord.toString() === this.renderedTiles[i].tileCoord.toString()
+        ) {
+          tile = /** @type {import("../../VectorRenderTile.js").default} */ (
+            this.renderedTiles[i]
           );
-        const layerUid = getUid(layer);
-        const source = layer.getSource();
-        const projection = this.renderedProjection;
-        const projectionExtent = projection.getExtent();
-        const resolution = this.renderedResolution;
-        const tileGrid = source.getTileGridForProjection(projection);
-        const coordinate = applyTransform(
-          this.renderedPixelToCoordinateTransform_,
-          pixel.slice()
-        );
-        const tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-          coordinate,
-          resolution
-        );
-        let tile;
-        for (let i = 0, ii = this.renderedTiles.length; i < ii; ++i) {
-          if (
-            tileCoord.toString() === this.renderedTiles[i].tileCoord.toString()
-          ) {
-            tile = this.renderedTiles[i];
-            if (tile.getState() === TileState.LOADED) {
-              const extent = tileGrid.getTileCoordExtent(tile.tileCoord);
-              if (
-                source.getWrapX() &&
-                projection.canWrapX() &&
-                !containsExtent(projectionExtent, extent)
-              ) {
-                wrapX(coordinate, projection);
-              }
-              break;
+          if (tile.getState() === TileState.LOADED) {
+            const extent = tileGrid.getTileCoordExtent(tile.tileCoord);
+            if (
+              source.getWrapX() &&
+              projection.canWrapX() &&
+              !containsExtent(projectionExtent, extent)
+            ) {
+              wrapX(coordinate, projection);
             }
-            tile = undefined;
+            break;
           }
+          tile = undefined;
         }
-        if (!tile || tile.loadingSourceTiles > 0) {
-          resolve([]);
-          return;
-        }
-        const extent = tileGrid.getTileCoordExtent(tile.wrappedTileCoord);
-        const corner = getTopLeft(extent);
-        const tilePixel = [
-          (coordinate[0] - corner[0]) / resolution,
-          (corner[1] - coordinate[1]) / resolution,
+      }
+      if (!tile || tile.loadingSourceTiles > 0) {
+        resolve([]);
+        return;
+      }
+      const extent = tileGrid.getTileCoordExtent(tile.wrappedTileCoord);
+      const corner = getTopLeft(extent);
+      const tilePixel = [
+        (coordinate[0] - corner[0]) / resolution,
+        (corner[1] - coordinate[1]) / resolution,
+      ];
+      /** @type {Array<import("../../Feature.js").FeatureLike>} */
+      const features = tile
+        .getSourceTiles()
+        .reduce(function (accumulator, sourceTile) {
+          return accumulator.concat(sourceTile.getFeatures());
+        }, []);
+      /** @type {ImageData|undefined} */
+      let hitDetectionImageData = tile.hitDetectionImageData[layerUid];
+      if (!hitDetectionImageData) {
+        const tileSize = toSize(
+          tileGrid.getTileSize(
+            tileGrid.getZForResolution(resolution, source.zDirection)
+          )
+        );
+        const rotation = this.renderedRotation_;
+        const transforms = [
+          this.getRenderTransform(
+            tileGrid.getTileCoordCenter(tile.wrappedTileCoord),
+            resolution,
+            0,
+            HIT_DETECT_RESOLUTION,
+            tileSize[0] * HIT_DETECT_RESOLUTION,
+            tileSize[1] * HIT_DETECT_RESOLUTION,
+            0
+          ),
         ];
-        const features = tile
-          .getSourceTiles()
-          .reduce(function (accumulator, sourceTile) {
-            return accumulator.concat(sourceTile.getFeatures());
-          }, []);
-        let hitDetectionImageData = tile.hitDetectionImageData[layerUid];
-        if (!hitDetectionImageData && !this.animatingOrInteracting_) {
-          const tileSize = toSize(
-            tileGrid.getTileSize(
-              tileGrid.getZForResolution(resolution, source.zDirection)
-            )
-          );
-          const rotation = this.renderedRotation_;
-          const transforms = [
-            this.getRenderTransform(
-              tileGrid.getTileCoordCenter(tile.wrappedTileCoord),
-              resolution,
-              0,
-              HIT_DETECT_RESOLUTION,
-              tileSize[0] * HIT_DETECT_RESOLUTION,
-              tileSize[1] * HIT_DETECT_RESOLUTION,
-              0
-            ),
-          ];
-          hitDetectionImageData = createHitDetectionImageData(
-            tileSize,
-            transforms,
-            features,
-            layer.getStyleFunction(),
-            tileGrid.getTileCoordExtent(tile.wrappedTileCoord),
-            tile.getReplayState(layer).renderedResolution,
-            rotation
-          );
-          tile.hitDetectionImageData[layerUid] = hitDetectionImageData;
-        }
-        resolve(hitDetect(tilePixel, features, hitDetectionImageData));
-      }.bind(this)
-    );
+        hitDetectionImageData = createHitDetectionImageData(
+          tileSize,
+          transforms,
+          features,
+          layer.getStyleFunction(),
+          tileGrid.getTileCoordExtent(tile.wrappedTileCoord),
+          tile.getReplayState(layer).renderedResolution,
+          rotation
+        );
+        tile.hitDetectionImageData[layerUid] = hitDetectionImageData;
+      }
+      resolve(hitDetect(tilePixel, features, hitDetectionImageData));
+    });
   }
 
   /**

package/renderer/webgl/PointsLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PointsLayer.d.ts","sourceRoot":"","sources":["PointsLayer.js"],"names":[],"mappings":";;;;;;;;;UA6Bc,MAAM;;;;;qBACG,OAAO,eAAe,EAAE,OAAO;YAAS,MAAM;UAAM,MAAM;;;;;;;;;;aAOnE,OAAO,eAAe,EAAE,OAAO;;;;;YACxB,MAAM;;;;;cACb,OAAO,YAAY,EAAE,QAAQ;;;;;;;;;;;;;;;;;;kBAW7B,MAAM;;;;oBACN,MAAM;;;;;;;;;;;;;;;;;;;;;AAzBpB;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EA4QjB;IA9PC,wBAAyB;IAEzB,kCAAuE;IACvE,qCAA0E;IAC1E,iCAGC;IAED;;OAEG;IACH,sBAAyC;IAEzC;;OAEG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,iBAAa;IAEb;;;OAGG;IACH,6BACqE;IAErE;;OAEG;IACH,yBAA+C;IAE/C;;OAEG;IACH,2BAAmD;IAEnD;;;OAGG;IACH,oBAAgB;IAYhB;;;;OAIG;IACH,YAFU,MAAM,OAAO,uBAAuB,EAAE,oBAAoB,CAAC,CAa3C;IAE1B;;;OAGG;IACH,wBAFU,MAAM,OAAO,uBAAuB,EAAE,oBAAoB,CAAC,CAuB3C;IAE1B,oCAAoE;IAEpE,kDAAoC;IAEpC;;;;;;OAMG;IACH,0BAAkD;IAElD;;;;OAIG;IACH,yBAAyC;IAEzC;;;OAGG;IACH,+BAA+C;IAE/C;;;OAGG;IACH,4BAA8C;IAE9C;;;;OAIG;IACH,+BAAiD;IAEjD;;;OAGG;IACH,yBAAqB;IAErB;;;;OAIG;IACH,4BAA4B;IAE5B;;OAEG;IACH,gBAAkC;IA6ClC;;;;OAIG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,sBAAsB;IAGtB,yDAyBC;IA6BH;;;OAGG;IACH,kCAQC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,mCAIC;IAED;;OAEG;IACH,kCAGC;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAmDtB;IA6CD;;;;OAIG;IACH,wBA8GC;IA0CD;;;;;;OAMG;IACH,+BALW,OAAO,cAAc,EAAE,UAAU,cACjC,MAAM,YACN,MAAM,cACN,MAAM,QAmChB;CAcF"}
+{"version":3,"file":"PointsLayer.d.ts","sourceRoot":"","sources":["PointsLayer.js"],"names":[],"mappings":";;;;;;;;;UA6Bc,MAAM;;;;;qBACG,OAAO,eAAe,EAAE,OAAO;YAAS,MAAM;UAAM,MAAM;;;;;;;;;;aAOnE,OAAO,eAAe,EAAE,OAAO;;;;;YACxB,MAAM;;;;;cACb,OAAO,YAAY,EAAE,QAAQ;;;;;;;;;;;;;;;;;;kBAW7B,MAAM;;;;oBACN,MAAM;;;;;;;;;;;;;;;;;;;;;AAzBpB;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EAyQjB;IA3PC,wBAAyB;IAEzB,kCAAuE;IACvE,qCAA0E;IAC1E,iCAGC;IAED;;OAEG;IACH,sBAAyC;IAEzC;;OAEG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,iBAAa;IAEb;;;OAGG;IACH,6BACqE;IAErE;;OAEG;IACH,yBAA+C;IAE/C;;OAEG;IACH,2BAAmD;IAEnD;;;OAGG;IACH,oBAAgB;IAYhB;;;;OAIG;IACH,YAFU,MAAM,OAAO,uBAAuB,EAAE,oBAAoB,CAAC,CAa3C;IAE1B;;;OAGG;IACH,wBAFU,MAAM,OAAO,uBAAuB,EAAE,oBAAoB,CAAC,CAuB3C;IAE1B,oCAAoE;IAEpE,kDAAoC;IAEpC;;;;;;OAMG;IACH,0BAAkD;IAElD;;;;OAIG;IACH,yBAAyC;IAEzC;;;OAGG;IACH,+BAA+C;IAE/C;;;OAGG;IACH,4BAA8C;IAE9C;;;;OAIG;IACH,+BAAiD;IAEjD;;;OAGG;IACH,yBAAqB;IAErB;;;;OAIG;IACH,4BAA4B;IAE5B;;OAEG;IACH,gBAAkC;IA4ClC;;;;OAIG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,sBAAsB;IAGtB,yDAyBC;IA2BH;;;OAGG;IACH,kCAQC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,mCAIC;IAED;;OAEG;IACH,kCAGC;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAmDtB;IA6CD;;;;OAIG;IACH,wBA8GC;IA0CD;;;;;;OAMG;IACH,+BALW,OAAO,cAAc,EAAE,UAAU,cACjC,MAAM,YACN,MAAM,cACN,MAAM,QAmChB;CAcF"}

package/renderer/webgl/PointsLayer.js

@@ -301,9 +301,8 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
       'message',
       /**
        * @param {*} event Event.
-       * @this {WebGLPointsLayerRenderer}
        */
-      function (event) {
+      (event) => {
         const received = event.data;
         if (received.type === WebGLWorkerMessageType.GENERATE_POINT_BUFFERS) {
           const projectionTransform = received.projectionTransform;
@@ -337,7 +336,7 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
 
           this.getLayer().changed();
         }
-      }.bind(this)
+      }
     );
 
     /**
@@ -381,16 +380,14 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
         this
       ),
     ];
-    source.forEachFeature(
-      function (feature) {
-        this.featureCache_[getUid(feature)] = {
-          feature: feature,
-          properties: feature.getProperties(),
-          geometry: feature.getGeometry(),
-        };
-        this.featureCount_++;
-      }.bind(this)
-    );
+    source.forEachFeature((feature) => {
+      this.featureCache_[getUid(feature)] = {
+        feature: feature,
+        properties: feature.getProperties(),
+        geometry: feature.getGeometry(),
+      };
+      this.featureCount_++;
+    });
   }
 
   afterHelperCreated() {

package/renderer/webgl/TileLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileLayer.d.ts","sourceRoot":"","sources":["TileLayer.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;kBAmIc,MAAM;;;;oBACN,MAAM;;;;;;;;;;;;;;;;;wBAQP,OAAO,0BAA0B,EAAE,OAAO;AAXvD;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;GAKG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EAyGjB;IAlGC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,kBAA6B;IAE7B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAEvB;;;OAGG;IACH,iBAAa;IAEb;;OAEG;IACH,sBAAyC;IAEzC;;OAEG;IACH,wBAA6C;IAE7C;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAuE;IAKvE;;;OAGG;IACH,0BAAgD;IAEhD;;;OAGG;IACH,yBAAqD;IAErD;;;OAGG;IACH,oBAAuB;IAEvB;;;OAGG;IACH,oBAA4B;IAG9B;;OAEG;IACH,eAFW,OAAO,QAgBjB;IAWD;;;;OAIG;IACH,wBASC;IA2BD;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,UACjC,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM;YACC,MAAM,GAAE,MAAM,WAAW,CAAC;gBACjC,MAAM,QAwGhB;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAqStB;IAED;;;OAGG;IACH,eAHW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,GAAC,UAAU,GAAC,YAAY,GAAC,QAAQ,CA4F7D;IAED;;;;;;;;;;OAUG;IACH,sBA+BC;IAED,mBAIC;CA6BF"}
+{"version":3,"file":"TileLayer.d.ts","sourceRoot":"","sources":["TileLayer.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;kBAmIc,MAAM;;;;oBACN,MAAM;;;;;;;;;;;;;;;;;wBAQP,OAAO,0BAA0B,EAAE,OAAO;AAXvD;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;GAKG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EAyGjB;IAlGC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,kBAA6B;IAE7B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAEvB;;;OAGG;IACH,iBAAa;IAEb;;OAEG;IACH,sBAAyC;IAEzC;;OAEG;IACH,wBAA6C;IAE7C;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAuE;IAKvE;;;OAGG;IACH,0BAAgD;IAEhD;;;OAGG;IACH,yBAAqD;IAErD;;;OAGG;IACH,oBAAuB;IAEvB;;;OAGG;IACH,oBAA4B;IAG9B;;OAEG;IACH,eAFW,OAAO,QAgBjB;IAWD;;;;OAIG;IACH,wBASC;IA2BD;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,UACjC,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM;YACC,MAAM,GAAE,MAAM,WAAW,CAAC;gBACjC,MAAM,QAwGhB;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAmStB;IAED;;;OAGG;IACH,eAHW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,GAAC,UAAU,GAAC,YAAY,GAAC,QAAQ,CA4F7D;IAED;;;;;;;;;;OAUG;IACH,sBA+BC;IAED,mBAIC;CA6BF"}

package/renderer/webgl/TileLayer.js

@@ -19,6 +19,7 @@ import {
   scale as scaleTransform,
   translate as translateTransform,
 } from '../../transform.js';
+import {ascending} from '../../array.js';
 import {
   boundingExtent,
   containsCoordinate,
@@ -35,7 +36,6 @@ import {
 } from '../../tilecoord.js';
 import {fromUserExtent} from '../../proj.js';
 import {getUid} from '../../util.js';
-import {numberSafeCompareFunction} from '../../array.js';
 import {toSize} from '../../size.js';
 
 export const Uniforms = {
@@ -562,9 +562,7 @@ class WebGLTileLayerRenderer extends WebGLLayerRenderer {
     this.helper.useProgram(this.program_, frameState);
     this.helper.prepareDraw(frameState, !blend);
 
-    const zs = Object.keys(tileTexturesByZ)
-      .map(Number)
-      .sort(numberSafeCompareFunction);
+    const zs = Object.keys(tileTexturesByZ).map(Number).sort(ascending);
 
     const centerX = viewState.center[0];
     const centerY = viewState.center[1];

package/reproj/DataTile.d.ts

@@ -1,7 +1,76 @@
 export default ReprojDataTile;
-export type FunctionType = (arg0: number, arg1: number, arg2: number, arg3: number) => import("../DataTile.js").default;
+export type TileGetter = (arg0: number, arg1: number, arg2: number, arg3: number) => import("../DataTile.js").default;
+export type Options = {
+    /**
+     * Source projection.
+     */
+    sourceProj: import("../proj/Projection.js").default;
+    /**
+     * Source tile grid.
+     */
+    sourceTileGrid: import("../tilegrid/TileGrid.js").default;
+    /**
+     * Target projection.
+     */
+    targetProj: import("../proj/Projection.js").default;
+    /**
+     * Target tile grid.
+     */
+    targetTileGrid: import("../tilegrid/TileGrid.js").default;
+    /**
+     * Coordinate of the tile.
+     */
+    tileCoord: import("../tilecoord.js").TileCoord;
+    /**
+     * Coordinate of the tile wrapped in X.
+     */
+    wrappedTileCoord?: import("../tilecoord.js").TileCoord | undefined;
+    /**
+     * Pixel ratio.
+     */
+    pixelRatio: number;
+    /**
+     * Gutter of the source tiles.
+     */
+    gutter: number;
+    /**
+     * Function returning source tiles (z, x, y, pixelRatio).
+     */
+    getTileFunction: TileGetter;
+    /**
+     * Use interpolated values when resampling.  By default,
+     * the nearest neighbor is used when resampling.
+     */
+    interpolate?: boolean | undefined;
+    /**
+     * Acceptable reprojection error (in px).
+     */
+    errorThreshold?: number | undefined;
+    /**
+     * A duration for tile opacity
+     * transitions in milliseconds. A duration of 0 disables the opacity transition.
+     */
+    transition?: number | undefined;
+};
 /**
- * @typedef {function(number, number, number, number) : import("../DataTile.js").default} FunctionType
+ * @typedef {function(number, number, number, number) : import("../DataTile.js").default} TileGetter
+ */
+/**
+ * @typedef {Object} Options
+ * @property {import("../proj/Projection.js").default} sourceProj Source projection.
+ * @property {import("../tilegrid/TileGrid.js").default} sourceTileGrid Source tile grid.
+ * @property {import("../proj/Projection.js").default} targetProj Target projection.
+ * @property {import("../tilegrid/TileGrid.js").default} targetTileGrid Target tile grid.
+ * @property {import("../tilecoord.js").TileCoord} tileCoord Coordinate of the tile.
+ * @property {import("../tilecoord.js").TileCoord} [wrappedTileCoord] Coordinate of the tile wrapped in X.
+ * @property {number} pixelRatio Pixel ratio.
+ * @property {number} gutter Gutter of the source tiles.
+ * @property {TileGetter} getTileFunction Function returning source tiles (z, x, y, pixelRatio).
+ * @property {boolean} [interpolate=false] Use interpolated values when resampling.  By default,
+ * the nearest neighbor is used when resampling.
+ * @property {number} [errorThreshold] Acceptable reprojection error (in px).
+ * @property {number} [transition=250] A duration for tile opacity
+ * transitions in milliseconds. A duration of 0 disables the opacity transition.
  */
 /**
  * @classdesc
@@ -11,20 +80,9 @@ export type FunctionType = (arg0: number, arg1: number, arg2: number, arg3: numb
  */
 declare class ReprojDataTile extends DataTile {
     /**
-     * @param {import("../proj/Projection.js").default} sourceProj Source projection.
-     * @param {import("../tilegrid/TileGrid.js").default} sourceTileGrid Source tile grid.
-     * @param {import("../proj/Projection.js").default} targetProj Target projection.
-     * @param {import("../tilegrid/TileGrid.js").default} targetTileGrid Target tile grid.
-     * @param {import("../tilecoord.js").TileCoord} tileCoord Coordinate of the tile.
-     * @param {import("../tilecoord.js").TileCoord} wrappedTileCoord Coordinate of the tile wrapped in X.
-     * @param {number} pixelRatio Pixel ratio.
-     * @param {number} gutter Gutter of the source tiles.
-     * @param {FunctionType} getTileFunction
-     *     Function returning source tiles (z, x, y, pixelRatio).
-     * @param {boolean} interpolate Use linear interpolation when resampling.
-     * @param {number} [errorThreshold] Acceptable reprojection error (in px).
-     */
-    constructor(sourceProj: import("../proj/Projection.js").default, sourceTileGrid: import("../tilegrid/TileGrid.js").default, targetProj: import("../proj/Projection.js").default, targetTileGrid: import("../tilegrid/TileGrid.js").default, tileCoord: import("../tilecoord.js").TileCoord, wrappedTileCoord: import("../tilecoord.js").TileCoord, pixelRatio: number, gutter: number, getTileFunction: FunctionType, interpolate: boolean, errorThreshold?: number | undefined);
+     * @param {Options} options Tile options.
+     */
+    constructor(options: Options);
     /**
      * @private
      * @type {number}
@@ -67,7 +125,7 @@ declare class ReprojDataTile extends DataTile {
     private wrappedTileCoord_;
     /**
      * @private
-     * @type {!Array<import("../Tile.js").default>}
+     * @type {!Array<DataTile>}
      */
     private sourceTiles_;
     /**

package/reproj/DataTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataTile.d.ts","sourceRoot":"","sources":["DataTile.js"],"names":[],"mappings":";kCAqBsB,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAI,OAAO,gBAAgB,EAAE,OAAO;AADxF;;GAEG;AAEH;;;;;GAKG;AACH;IACE;;;;;;;;;;;;;OAaG;IACH,wBAbW,OAAO,uBAAuB,EAAE,OAAO,kBACvC,OAAO,yBAAyB,EAAE,OAAO,cACzC,OAAO,uBAAuB,EAAE,OAAO,kBACvC,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,iBAAiB,EAAE,SAAS,oBACnC,OAAO,iBAAiB,EAAE,SAAS,cACnC,MAAM,UACN,MAAM,mBACN,YAAY,eAEZ,OAAO,uCAuMjB;IA7KC;;;OAGG;IACH,oBAA6B;IAE7B;;;OAGG;IACH,gBAAqB;IAErB;;;OAGG;IACH,oBAAuB;IAEvB;;;OAGG;IACH,qBAAwB;IAExB;;;OAGG;IACH,oBAA4B;IAE5B;;;OAGG;IACH,wBAAqC;IAErC;;;OAGG;IACH,wBAAqC;IAErC;;;OAGG;IACH,0BAAwE;IAExE;;;OAGG;IACH,qBAAsB;IAEtB;;;OAGG;IACH,6BAAgC;IAEhC;;;OAGG;IACH,iBAAiB;IAiDjB;;;OAGG;IACH,uBAOC;IA2EH;;OAEG;IACH,mBA6JC;IA0DD;;OAEG;IACH,yBAGC;CACF"}
+{"version":3,"file":"DataTile.d.ts","sourceRoot":"","sources":["DataTile.js"],"names":[],"mappings":";gCAoBsB,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAI,OAAO,gBAAgB,EAAE,OAAO;;;;;gBAK1E,OAAO,uBAAuB,EAAE,OAAO;;;;oBACvC,OAAO,yBAAyB,EAAE,OAAO;;;;gBACzC,OAAO,uBAAuB,EAAE,OAAO;;;;oBACvC,OAAO,yBAAyB,EAAE,OAAO;;;;eACzC,OAAO,iBAAiB,EAAE,SAAS;;;;;;;;gBAEnC,MAAM;;;;YACN,MAAM;;;;qBACN,UAAU;;;;;;;;;;;;;;;;AAdxB;;GAEG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA2LjB;IAjLC;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,gBAA6B;IAE7B;;;OAGG;IACH,oBAAuB;IAEvB;;;OAGG;IACH,qBAAwB;IAExB;;;OAGG;IACH,oBAA4B;IAE5B;;;OAGG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,0BAAsE;IAEtE;;;OAGG;IACH,qBAAsB;IAEtB;;;OAGG;IACH,6BAAgC;IAEhC;;;OAGG;IACH,iBAAiB;IAqDjB;;;OAGG;IACH,uBAOC;IA2EH;;OAEG;IACH,mBAoKC;IAyDD;;OAEG;IACH,yBAGC;CACF"}