ol 10.6.2-dev.1760977773143 → 10.6.2-dev.1761509477559

package/package.json

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

package/render/webgl/constants.d.ts

@@ -22,7 +22,7 @@ export type WebGLWorkerGenerateBuffersMessage = {
     /**
      * render instructions raw binary buffer.
      */
-    renderInstructions: ArrayBuffer;
+    renderInstructions: ArrayBufferLike;
     /**
      * Amount of hit detection + custom attributes count in the render instructions.
      */

package/render/webgl/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["constants.js"],"names":[],"mappings":"qCAKU,MAAM;;;;;;;;;;;;;;;;QAcF,MAAM;;;;UACN,sBAAsB;;;;wBACtB,WAAW"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["constants.js"],"names":[],"mappings":"qCAKU,MAAM;;;;;;;;;;;;;;;;QAcF,MAAM;;;;UACN,sBAAsB;;;;wBACtB,eAAe"}

package/render/webgl/constants.js

@@ -19,7 +19,7 @@ export const WebGLWorkerMessageType = {
  * Note that any addition properties present in the message *will* be sent back to the main thread.
  * @property {number} id Message id; will be used both in request and response as a means of identification
  * @property {WebGLWorkerMessageType} type Message type
- * @property {ArrayBuffer} renderInstructions render instructions raw binary buffer.
+ * @property {ArrayBufferLike} renderInstructions render instructions raw binary buffer.
  * @property {number} [customAttributesSize] Amount of hit detection + custom attributes count in the render instructions.
  * @property {ArrayBuffer} [indicesBuffer] Indices array raw binary buffer (sent by the worker).
  * @property {ArrayBuffer} [vertexAttributesBuffer] Vertex attributes array raw binary buffer (sent by the worker).

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/reproj/DataTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataTile.d.ts","sourceRoot":"","sources":["DataTile.js"],"names":[],"mappings":";yBAsBa,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAI,OAAO,gBAAgB,EAAE,OAAO;;;;;UAK1E,QAAQ;;;;YACR,MAAM;;;;;;gBAKN,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;;;;;;;;;;;;;;;;;;;;;;;;AApBxB;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAiOjB;IAvNC;;;OAGG;IACH,qBACiE;IAEjE;;;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;IAMjB;;;OAGG;IACH,oBAIwB;IAmDxB;;;OAGG;IACH,uBAQC;IAgGH;;OAEG;IACH,mBAuMC;IAqDD;;OAEG;IACH,yBAGC;CACF;qBA3jByD,gBAAgB"}
+{"version":3,"file":"DataTile.d.ts","sourceRoot":"","sources":["DataTile.js"],"names":[],"mappings":";yBAsBa,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAI,OAAO,gBAAgB,EAAE,OAAO;;;;;UAK1E,QAAQ;;;;YACR,MAAM;;;;;;gBAKN,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;;;;;;;;;;;;;;;;;;;;;;;;AApBxB;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAiOjB;IAvNC;;;OAGG;IACH,qBACiE;IAEjE;;;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;IAMjB;;;OAGG;IACH,oBAIwB;IAmDxB;;;OAGG;IACH,uBAQC;IAgGH;;OAEG;IACH,mBAyMC;IAqDD;;OAEG;IACH,yBAGC;CACF;qBA7jByD,gBAAgB"}

package/reproj/DataTile.js

@@ -339,7 +339,9 @@ class ReprojDataTile extends DataTile {
       const isFloat = tileData instanceof Float32Array;
       const pixelCount = pixelSize[0] * pixelSize[1];
       const DataType = isFloat ? Float32Array : Uint8ClampedArray;
-      const tileDataR = new DataType(tileData.buffer);
+      const tileDataR = new DataType(
+        /** @type {ArrayBuffer} */ (tileData.buffer),
+      );
       const bytesPerElement = DataType.BYTES_PER_ELEMENT;
       const bytesPerPixel = (bytesPerElement * tileDataR.length) / pixelCount;
       const bytesPerRow = tileDataR.byteLength / pixelSize[1];

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.1760977773143';
+export const VERSION = '10.6.2-dev.1761509477559';