ol 10.6.2-dev.1760985568257 → 10.6.2-dev.1761594660005

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "10.6.2-dev.1760985568257",
+  "version": "10.6.2-dev.1761594660005",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

package/renderer/canvas/VectorTileLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":";AA4DA;;;;;GAKG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,2BAA2B,EAAE,OAAO,WAC3C,OAAO,gBAAgB,EAAE,OAAO,EA2C1C;IAtCC,eAAe;IACf,qCAA2E;IAE3E;;;OAGG;IACH,+BAA2B;IAE3B;;;OAGG;IACH,4CAA+C;IAE/C;;;OAGG;IACH,0BAAsB;IAEtB;;;OAGG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,sBAAsC;IAEtC;;;OAGG;IACH,0BAA6B;IAY/B;;;;;;;;;;OAUG;IACH,wBAVW,OAAO,2BAA2B,EAAE,OAAO,cAC3C,OAAO,cAAc,EAAE,UAAU,KACjC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,cACN,OAAO,QAajB;IAoDD;;;;;OAKG;IACH,6BAqHC;IAyMD;;;OAGG;IACH,4BAHW,OAAO,iBAAiB,EAAE,MAAM,GAC/B,KAAK,CAAC,OAAO,kBAAkB,EAAE,WAAW,CAAC,CA4CxD;IAaD;;;;OAIG;IACH,gCAEC;IAED;;;;OAIG;IACH,4BAHW,OAAO,cAAc,EAAE,UAAU,cACjC,OAAO,sBAAsB,EAAE,KAAK,QAyC9C;IA6DD;;;;OAIG;IACH,6BAJW,OAAO,2BAA2B,EAAE,OAAO,cAC3C,OAAO,cAAc,EAAE,UAAU,GAChC,OAAO,oBAAoB,EAAE,SAAS,CAkCjD;IAqID;;;;;;;;OAQG;IACH,uBARW,OAAO,kBAAkB,EAAE,WAAW,oBACtC,MAAM,UACN,OAAO,sBAAsB,EAAE,OAAO,GAAC,KAAK,CAAC,OAAO,sBAAsB,EAAE,OAAO,CAAC,gBACpF,OAAO,qCAAqC,EAAE,OAAO,cACrD,OAAO,UACP,MAAM,GACL,OAAO,CAyClB;IAED;;;;OAIG;IACH,8BAcC;IAED;;;;OAIG;IACH,yBAwDC;CACF;oCA37BmC,gBAAgB"}
+{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":";AA6DA;;;;;GAKG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,2BAA2B,EAAE,OAAO,WAC3C,OAAO,gBAAgB,EAAE,OAAO,EA2C1C;IAtCC,eAAe;IACf,qCAA2E;IAE3E;;;OAGG;IACH,+BAA2B;IAE3B;;;OAGG;IACH,4CAA+C;IAE/C;;;OAGG;IACH,0BAAsB;IAEtB;;;OAGG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,sBAAsC;IAEtC;;;OAGG;IACH,0BAA6B;IAY/B;;;;;;;;;;OAUG;IACH,wBAVW,OAAO,2BAA2B,EAAE,OAAO,cAC3C,OAAO,cAAc,EAAE,UAAU,KACjC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,cACN,OAAO,QAajB;IAoDD;;;;;OAKG;IACH,6BA4IC;IAyMD;;;OAGG;IACH,4BAHW,OAAO,iBAAiB,EAAE,MAAM,GAC/B,KAAK,CAAC,OAAO,kBAAkB,EAAE,WAAW,CAAC,CA4CxD;IAaD;;;;OAIG;IACH,gCAEC;IAED;;;;OAIG;IACH,4BAHW,OAAO,cAAc,EAAE,UAAU,cACjC,OAAO,sBAAsB,EAAE,KAAK,QAyC9C;IA6DD;;;;OAIG;IACH,6BAJW,OAAO,2BAA2B,EAAE,OAAO,cAC3C,OAAO,cAAc,EAAE,UAAU,GAChC,OAAO,oBAAoB,EAAE,SAAS,CAkCjD;IAqID;;;;;;;;OAQG;IACH,uBARW,OAAO,kBAAkB,EAAE,WAAW,oBACtC,MAAM,UACN,OAAO,sBAAsB,EAAE,OAAO,GAAC,KAAK,CAAC,OAAO,sBAAsB,EAAE,OAAO,CAAC,gBACpF,OAAO,qCAAqC,EAAE,OAAO,cACrD,OAAO,UACP,MAAM,GACL,OAAO,CAyClB;IAED;;;;OAIG;IACH,8BAcC;IAED;;;;OAIG;IACH,yBAwDC;CACF;oCAl9BmC,gBAAgB"}

package/renderer/canvas/VectorTileLayer.js

@@ -14,6 +14,7 @@ import {
   getTopLeft,
   intersects,
 } from '../../extent.js';
+import {equivalent, getTransform, transformExtent} from '../../proj.js';
 import CanvasBuilderGroup from '../../render/canvas/BuilderGroup.js';
 import CanvasExecutorGroup, {
   DECLUTTER,
@@ -234,9 +235,22 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
       if (sourceTile.getState() != TileState.LOADED) {
         continue;
       }
+      const sourceProjection = source.getProjection();
       const sourceTileCoord = sourceTile.tileCoord;
-      const sourceTileExtent =
-        sourceTileGrid.getTileCoordExtent(sourceTileCoord);
+      let sourceTileExtent = sourceTileGrid.getTileCoordExtent(sourceTileCoord);
+      if (
+        projection &&
+        sourceProjection &&
+        !equivalent(projection, sourceProjection)
+      ) {
+        sourceTileExtent = transformExtent(
+          sourceTileExtent,
+          sourceProjection,
+          projection,
+          32,
+        );
+      }
+
       const sharedExtent = getIntersection(tileExtent, sourceTileExtent);
       const builderExtent = buffer(
         sharedExtent,
@@ -287,7 +301,17 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
         features.sort(renderOrder);
       }
       for (let i = 0, ii = features.length; i < ii; ++i) {
-        const feature = features[i];
+        let feature = features[i];
+        if (
+          projection &&
+          sourceTile.projection &&
+          !equivalent(projection, sourceTile.projection)
+        ) {
+          feature = feature.clone();
+          feature
+            .getGeometry()
+            .applyTransform(getTransform(sourceTile.projection, projection));
+        }
         if (
           !bufferedExtent ||
           intersects(bufferedExtent, feature.getGeometry().getExtent())

package/source/VectorTile.d.ts

@@ -35,7 +35,7 @@ export type Options<FeatureType extends import("../Feature.js").FeatureLike = im
      */
     overlaps?: boolean | undefined;
     /**
-     * Projection of the tile grid.
+     * Projection of the tile source.
      */
     projection?: import("../proj.js").ProjectionLike;
     /**
@@ -142,7 +142,7 @@ export type Options<FeatureType extends import("../Feature.js").FeatureLike = im
  * to `false` (e.g. for sources with polygons that represent administrative
  * boundaries or TopoJSON sources) allows the renderer to optimise fill and
  * stroke operations.
- * @property {import("../proj.js").ProjectionLike} [projection='EPSG:3857'] Projection of the tile grid.
+ * @property {import("../proj.js").ProjectionLike} [projection='EPSG:3857'] Projection of the tile source.
  * @property {import("./Source.js").State} [state] Source state.
  * @property {typeof import("../VectorTile.js").default} [tileClass] Class used to instantiate tiles.
  * Default is {@link module:ol/VectorTile~VectorTile}.

package/source/VectorTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorTile.d.ts","sourceRoot":"","sources":["VectorTile.js"],"names":[],"mappings":"AAubA;;;;;GAKG;AACH,oCAJoD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY,iDACvC,OAAO,kBAAkB,EAAE,OAAO,CAAC,WAAW,CAAC,OAC/C,MAAM,QAqBhB;;oBAxbmD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWpC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAZjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAEH;;;;;;;;;;;;;GAaG;AACH,yBAFoD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY;IAGhD;;OAEG;IACH,qBAFY,OAAO,CAAC,WAAW,CAAC,EAsE/B;IAlCC;;;OAGG;IACH,gBAAqD;IAErD;;;OAGG;IACH,iCAAkC;IAElC;;OAEG;IACH;;MAAsB;IAEtB;;;OAGG;IACH,kBAAwE;IAExE;;;OAGG;IACH,iCAA6D;IAE7D;;;OAGG;IACH,mBAAoB;IAGtB;;OAEG;IACH,eAFY,OAAO,CAIlB;IAED;;;;;OAKG;IACH,2BALW,MAAM,cACN,OAAO,oBAAoB,EAAE,OAAO,QACpC,gBAAgB,GACf,KAAK,CAAC,SAA+B,CAAC,CAgGjD;IAED;;OAEG;IACH,wBAFW,gBAAgB,QAqB1B;IAED;;;;;;;;OAQG;IACH,oBARW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACrC,gBAAgB,CA0C5B;IAsED;;OAEG;IACH,sBAFW,OAAO,QAKjB;CACF;iBA7agB,kBAAkB;qBAYd,yBAAyB;oBAG1B,cAAc;6BAhBL,wBAAwB"}
+{"version":3,"file":"VectorTile.d.ts","sourceRoot":"","sources":["VectorTile.js"],"names":[],"mappings":"AAgfA;;;;;GAKG;AACH,oCAJoD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY,iDACvC,OAAO,kBAAkB,EAAE,OAAO,CAAC,WAAW,CAAC,OAC/C,MAAM,QAqBhB;;oBA9emD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWpC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAZjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAEH;;;;;;;;;;;;;GAaG;AACH,yBAFoD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY;IAGhD;;OAEG;IACH,qBAFY,OAAO,CAAC,WAAW,CAAC,EAsE/B;IAlCC;;;OAGG;IACH,gBAAqD;IAErD;;;OAGG;IACH,iCAAkC;IAElC;;OAEG;IACH;;MAAsB;IAEtB;;;OAGG;IACH,kBAAwE;IAExE;;;OAGG;IACH,iCAA6D;IAE7D;;;OAGG;IACH,mBAAoB;IAGtB;;OAEG;IACH,eAFY,OAAO,CAIlB;IAED;;;;;OAKG;IACH,2BALW,MAAM,cACN,OAAO,oBAAoB,EAAE,OAAO,QACpC,gBAAgB,GACf,KAAK,CAAC,SAA+B,CAAC,CAmHjD;IAED;;OAEG;IACH,wBAFW,gBAAgB,QAqB1B;IAED;;;;;;;;OAQG;IACH,oBARW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACrC,gBAAgB,CA2E5B;IAwED;;OAEG;IACH,sBAFW,OAAO,QAKjB;CACF;iBAtegB,kBAAkB;qBAWd,yBAAyB;oBAO1B,cAAc;6BAnBL,wBAAwB"}

package/source/VectorTile.js

@@ -5,7 +5,6 @@
 import TileState from '../TileState.js';
 import VectorRenderTile from '../VectorRenderTile.js';
 import Tile from '../VectorTile.js';
-import {assert} from '../asserts.js';
 import EventType from '../events/EventType.js';
 import {
   buffer as bufferExtent,
@@ -14,11 +13,15 @@ import {
 } from '../extent.js';
 import {loadFeaturesXhr} from '../featureloader.js';
 import {isEmpty} from '../obj.js';
-import {equivalent} from '../proj.js';
+import {equivalent, transformExtent} from '../proj.js';
 import {toSize} from '../size.js';
 import TileGrid from '../tilegrid/TileGrid.js';
 import {DEFAULT_MAX_ZOOM} from '../tilegrid/common.js';
-import {createXYZ, extentFromProjection} from '../tilegrid.js';
+import {
+  createXYZ,
+  extentFromProjection,
+  getForProjection,
+} from '../tilegrid.js';
 import UrlTile from './UrlTile.js';
 
 /**
@@ -33,7 +36,7 @@ import UrlTile from './UrlTile.js';
  * to `false` (e.g. for sources with polygons that represent administrative
  * boundaries or TopoJSON sources) allows the renderer to optimise fill and
  * stroke operations.
- * @property {import("../proj.js").ProjectionLike} [projection='EPSG:3857'] Projection of the tile grid.
+ * @property {import("../proj.js").ProjectionLike} [projection='EPSG:3857'] Projection of the tile source.
  * @property {import("./Source.js").State} [state] Source state.
  * @property {typeof import("../VectorTile.js").default} [tileClass] Class used to instantiate tiles.
  * Default is {@link module:ol/VectorTile~VectorTile}.
@@ -193,18 +196,37 @@ class VectorTile extends UrlTile {
       tile.setState(TileState.LOADING);
       const urlTileCoord = tile.wrappedTileCoord;
       const tileGrid = this.getTileGridForProjection(projection);
-      const extent = tileGrid.getTileCoordExtent(urlTileCoord);
+      let extent = tileGrid.getTileCoordExtent(urlTileCoord);
       const z = urlTileCoord[0];
       const resolution = tileGrid.getResolution(z);
       // make extent 1 pixel smaller so we don't load tiles for < 0.5 pixel render space
       bufferExtent(extent, -resolution, extent);
+      const sourceProjection = this.projection;
+      if (
+        projection &&
+        this.projection &&
+        !equivalent(projection, sourceProjection)
+      ) {
+        extent = transformExtent(extent, projection, sourceProjection);
+      }
       const sourceTileGrid = this.tileGrid;
       const sourceExtent = sourceTileGrid.getExtent();
       if (sourceExtent) {
         getIntersection(extent, sourceExtent, extent);
       }
+      let sourceResolution = resolution;
+      if (
+        projection &&
+        sourceProjection &&
+        !equivalent(projection, sourceProjection)
+      ) {
+        sourceResolution =
+          resolution /
+          sourceProjection.getMetersPerUnit() /
+          projection.getMetersPerUnit();
+      }
       const sourceZ = sourceTileGrid.getZForResolution(
-        resolution,
+        sourceResolution,
         this.zDirection,
       );
 
@@ -263,7 +285,7 @@ class VectorTile extends UrlTile {
         if (sourceTileState === TileState.IDLE) {
           sourceTile.extent =
             sourceTileGrid.getTileCoordExtent(sourceTileCoord);
-          sourceTile.projection = projection;
+          sourceTile.projection = this.projection;
           sourceTile.resolution = sourceTileGrid.getResolution(
             sourceTileCoord[0],
           );
@@ -324,12 +346,22 @@ class VectorTile extends UrlTile {
       projection,
     );
     const sourceExtent = this.getTileGrid().getExtent();
+    const sourceProjection = this.projection;
     const tileGrid = this.getTileGridForProjection(projection);
     if (urlTileCoord && sourceExtent) {
       const tileExtent = tileGrid.getTileCoordExtent(urlTileCoord);
       // make extent 1 pixel smaller so we don't load tiles for < 0.5 pixel render space
       bufferExtent(tileExtent, -tileGrid.getResolution(z), tileExtent);
-      if (!intersects(sourceExtent, tileExtent)) {
+      if (
+        !intersects(
+          sourceExtent,
+          !projection ||
+            !sourceProjection ||
+            equivalent(projection, sourceProjection)
+            ? tileExtent
+            : transformExtent(tileExtent, projection, sourceProjection),
+        )
+      ) {
         urlTileCoord = null;
       }
     }
@@ -337,15 +369,38 @@ class VectorTile extends UrlTile {
     if (urlTileCoord !== null) {
       const sourceTileGrid = this.tileGrid;
       const resolution = tileGrid.getResolution(z);
-      const sourceZ = sourceTileGrid.getZForResolution(resolution, 1);
+      let sourceResolution = resolution;
+      if (
+        projection &&
+        sourceProjection &&
+        !equivalent(projection, sourceProjection)
+      ) {
+        sourceResolution =
+          resolution /
+          sourceProjection.getMetersPerUnit() /
+          projection.getMetersPerUnit();
+      }
+      const sourceZ = sourceTileGrid.getZForResolution(sourceResolution, 1);
       // make extent 1 pixel smaller so we don't load tiles for < 0.5 pixel render space
       const extent = tileGrid.getTileCoordExtent(urlTileCoord);
       bufferExtent(extent, -resolution, extent);
-      sourceTileGrid.forEachTileCoord(extent, sourceZ, (sourceTileCoord) => {
-        empty =
-          empty &&
-          !this.tileUrlFunction(sourceTileCoord, pixelRatio, projection);
-      });
+      sourceTileGrid.forEachTileCoord(
+        !projection ||
+          !sourceProjection ||
+          equivalent(projection, sourceProjection)
+          ? extent
+          : transformExtent(extent, projection, sourceProjection),
+        sourceZ,
+        (sourceTileCoord) => {
+          empty =
+            empty &&
+            !this.tileUrlFunction(
+              sourceTileCoord,
+              pixelRatio,
+              sourceProjection,
+            );
+        },
+      );
     }
     const newTile = new VectorRenderTile(
       tileCoord,
@@ -367,11 +422,13 @@ class VectorTile extends UrlTile {
     const code = projection.getCode();
     let tileGrid = this.tileGrids_[code];
     if (!tileGrid) {
-      const sourceProjection = this.getProjection();
-      assert(
-        sourceProjection === null || equivalent(sourceProjection, projection),
-        'A VectorTile source can only be rendered if it has a projection compatible with the view projection.',
-      );
+      const sourceProjection = this.projection;
+      if (
+        sourceProjection !== null &&
+        !equivalent(sourceProjection, projection)
+      ) {
+        return getForProjection(projection);
+      }
 
       // A tile grid that matches the tile size of the source tile grid is more
       // likely to have 1:1 relationships between source tiles and rendered tiles.

package/util.js

@@ -33,4 +33,4 @@ export function getUid(obj) {
  * OpenLayers version.
  * @type {string}
  */
-export const VERSION = '10.6.2-dev.1760985568257';
+export const VERSION = '10.6.2-dev.1761594660005';