@itwin/map-layers-formats 4.0.0-dev.48 → 4.0.0-dev.50

package/lib/esm/ArcGisFeature/ArcGisFeatureProvider.js

@@ -1,418 +1,418 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-import { ImageSource, ImageSourceFormat, ServerError } from "@itwin/core-common";
-import { base64StringToUint8Array, IModelStatus, Logger } from "@itwin/core-bentley";
-import { Matrix4d, Point3d, Range2d } from "@itwin/core-geometry";
-import { ArcGisErrorCode, ArcGISImageryProvider, ArcGisUtilities, MapCartoRectangle, MapLayerImageryProviderStatus } from "@itwin/core-frontend";
-import { ArcGisSymbologyRenderer } from "./ArcGisSymbologyRenderer";
-import { ArcGisFeatureQuery } from "./ArcGisFeatureQuery";
-import { ArcGisFeatureRenderer } from "./ArcGisFeatureRenderer";
-import { ArcGisFeaturePBF } from "./ArcGisFeaturePBF";
-import { ArcGisFeatureJSON } from "./ArcGisFeatureJSON";
-import { ArcGisFeatureResponse } from "./ArcGisFeatureResponse";
-const loggerCategory = "MapLayersFormats.ArcGISFeature";
-/**  Provide tiles from a ESRI ArcGIS Feature service
-* @internal
-*/
-export class ArcGisFeatureProvider extends ArcGISImageryProvider {
-    constructor(settings) {
-        super(settings, true);
-        // Debug flags, should always be commited to FALSE !
-        this._drawDebugInfo = false;
-        this._debugFeatureGeom = false;
-        this._supportsCoordinatesQuantization = false;
-        this._querySupported = false;
-        this._layerId = 0;
-        this._outSR = 102100;
-        this._maxDepthFromLod = 0;
-        this._minDepthFromLod = 0;
-    }
-    get minimumZoomLevel() { return this._minDepthFromLod; }
-    get maximumZoomLevel() { return this._maxDepthFromLod; }
-    async initialize() {
-        const metadata = await this.getServiceJson();
-        const json = metadata?.content;
-        if (json === undefined) {
-            Logger.logError(loggerCategory, "Could not get service JSON");
-            throw new ServerError(IModelStatus.ValidationFailed, "");
-        }
-        if (json?.error?.code === ArcGisErrorCode.TokenRequired || json?.error?.code === ArcGisErrorCode.InvalidToken) {
-            // Check again layer status, it might have change during await.
-            if (this.status === MapLayerImageryProviderStatus.Valid) {
-                this.setStatus(MapLayerImageryProviderStatus.RequireAuth);
-                return;
-            }
-        }
-        if (json.capabilities) {
-            this._querySupported = json.capabilities.indexOf("Query") >= 0;
-            if (!this._querySupported)
-                throw new ServerError(IModelStatus.ValidationFailed, "");
-        }
-        this.serviceJson = json;
-        let foundVisibleSubLayer = false;
-        if (this._settings.subLayers.length >= 0) {
-            // There is more than sub-layer for this layer, pick the first visible one.
-            for (const layer of this._settings.subLayers) {
-                if (layer.visible && typeof layer.id === "number") {
-                    this._layerId = layer.id;
-                    foundVisibleSubLayer = true;
-                    break;
-                }
-            }
-        }
-        if (!foundVisibleSubLayer && json !== undefined) {
-            // No suitable sublayer was specified on the layerSettings object, lets find a default one in the capabilities
-            // Check layer metadata
-            if (Array.isArray(this.serviceJson.layers) && this.serviceJson.layers.length >= 1) {
-                const hasDefaultVisibility = Object.keys(this.serviceJson.layers[0]).includes("defaultVisibility");
-                if (hasDefaultVisibility) {
-                    for (const layer of this.serviceJson.layers) {
-                        if (layer.defaultVisibility) {
-                            this._layerId = layer.id;
-                        }
-                    }
-                }
-                else {
-                    // On some older servers, the default visiblity is on the layer capabilities (i.e. not the service capabilities)
-                    for (const layer of this.serviceJson.layers) {
-                        const layerJson = await this.getLayerMetadata(layer.id);
-                        if (!layerJson) {
-                            continue;
-                        }
-                        if (layerJson.defaultVisibility) {
-                            this._layerId = layer.id;
-                            this._layerMetadata = layerJson;
-                            break;
-                        }
-                    }
-                }
-            }
-            else {
-                // There is no layer to publish? Something is off with this server..
-                throw new ServerError(IModelStatus.ValidationFailed, "");
-            }
-        }
-        // Make sure we cache layer info (i.e. rendering info)
-        if (!this._layerMetadata) {
-            this._layerMetadata = await this.getLayerMetadata(this._layerId);
-            if (!this._layerMetadata) {
-                Logger.logError(loggerCategory, "Could not layer metadata");
-                throw new ServerError(IModelStatus.ValidationFailed, "");
-            }
-        }
-        // Parse server version
-        let majorVersion;
-        if (this.serviceJson?.currentVersion) {
-            try {
-                majorVersion = Math.trunc(this.serviceJson?.currentVersion);
-            }
-            catch {
-            }
-        }
-        // Coordinates Quantization:  If supported, server will transform for us the coordinates in the Tile coordinate space (pixels, origin = upper left corner
-        // If not supported, transformation will be applied client side.
-        // Note: For some reasons, even though 'supportsCoordinatesQuantization' is set to 'true' on the layer metadata, server will give an error message for server version < 11
-        if (majorVersion && majorVersion >= 11 && this._layerMetadata.supportsCoordinatesQuantization) {
-            this._supportsCoordinatesQuantization = true;
-        }
-        // Check supported query formats: JSON and PBF are currently implemented by this provider
-        // Note: needs to be checked on the layer metadata, service metadata advertises a different set of formats
-        //       Also, since PBF format does not support floating points, there is no point using this format if supportsCoordinatesQuantization is not available.
-        if (this._layerMetadata.supportedQueryFormats) {
-            const formats = this._layerMetadata.supportedQueryFormats.split(", ");
-            if (formats.includes("PBF") && this._supportsCoordinatesQuantization) {
-                this._format = "PBF";
-            }
-            else if (formats.includes("JSON")) {
-                this._format = "JSON";
-            }
-        }
-        if (!this._format) {
-            Logger.logError(loggerCategory, "Could not get request format from service JSON");
-            throw new ServerError(IModelStatus.ValidationFailed, "");
-        }
-        // Read range using full extent from service metadata
-        if (json.fullExtent) {
-            if (json.fullExtent.spatialReference.latestWkid === 3857 || json.fullExtent.spatialReference.wkid === 102100) {
-                const range3857 = Range2d.createFrom({
-                    low: { x: json.fullExtent.xmin, y: json.fullExtent.ymin },
-                    high: { x: json.fullExtent.xmax, y: json.fullExtent.ymax }
-                });
-                const west = this.getEPSG4326Lon(range3857.xLow);
-                const south = this.getEPSG4326Lat(range3857.yLow);
-                const east = this.getEPSG4326Lon(range3857.xHigh);
-                const north = this.getEPSG4326Lat(range3857.yHigh);
-                this.cartoRange = MapCartoRectangle.fromDegrees(west, south, east, north);
-            }
-        }
-        // Check for minScale / max scale
-        const minScale = this._layerMetadata?.minScale || undefined; // undefined, 0 -> undefined
-        const maxScale = this._layerMetadata?.maxScale || undefined; // undefined, 0 -> undefined
-        const scales = ArcGisUtilities.getZoomLevelsScales(this.defaultMaximumZoomLevel, this.tileSize, minScale, maxScale, 1.0);
-        if (scales.minLod)
-            this._minDepthFromLod = scales.minLod;
-        // Some servers advertises a max LOD of 0, it should be interpreted as 'not defined' (otherwise a max lod of 0 would would mean never display anything)
-        this._maxDepthFromLod = (scales.maxLod ? scales.maxLod : this.defaultMaximumZoomLevel);
-        this._symbologyRenderer = new ArcGisSymbologyRenderer(this._layerMetadata?.geometryType, this._layerMetadata?.drawingInfo?.renderer);
-    }
-    async getLayerMetadata(layerId) {
-        let metadata;
-        try {
-            const url = new URL(this._settings.url);
-            url.pathname = `${url.pathname}/${layerId}`;
-            metadata = await ArcGisUtilities.getServiceJson(url.toString(), this._settings.formatId, this._settings.userName, this._settings.password, this._accessTokenRequired);
-        }
-        catch {
-        }
-        return metadata?.content;
-    }
-    get tileSize() { return 512; }
-    get format() { return this._format; }
-    // We don't use this method inside this provider (see constructFeatureUrl), but since this is an abstract method, we need to define something
-    async constructUrl(_row, _column, _zoomLevel) {
-        return "";
-    }
-    constructFeatureUrl(row, column, zoomLevel, format, geomOverride, outFields, tolerance, returnGeometry) {
-        const tileExtent = this.getEPSG3857Extent(row, column, zoomLevel);
-        const tileEnvelope = {
-            xmin: tileExtent.left, ymin: tileExtent.bottom,
-            xmax: tileExtent.right, ymax: tileExtent.top,
-            spatialReference: { wkid: 102100, latestWkid: 3857 },
-        };
-        // Actual spatial filter.
-        // By default, we request the tile extent.  If 'cartoPoint' is specified,
-        // we restrict the spatial to specific point. (i.e. GetFeatureInfo requests)
-        // If envelope is provided, it has the priority over 'cartoPoint'
-        let geometry;
-        if (geomOverride) {
-            geometry = geomOverride;
-        }
-        else {
-            geometry = { geom: tileEnvelope, type: "esriGeometryEnvelope" };
-        }
-        let quantizationParameters;
-        const toleranceWorld = (tileExtent.top - tileExtent.bottom) / this.tileSize;
-        if (this._supportsCoordinatesQuantization) {
-            quantizationParameters = {
-                mode: "view",
-                originPosition: "upperLeft",
-                tolerance: toleranceWorld,
-                extent: tileEnvelope,
-            };
-        }
-        const url = new ArcGisFeatureQuery(this._settings.url, this._layerId, format, this._outSR, { geometry,
-            geometryType: "esriGeometryEnvelope",
-            returnExceededLimitFeatures: false,
-            maxRecordCountFactor: 3,
-            resultType: "tile",
-            quantizationParameters,
-            outFields,
-            returnGeometry,
-            distance: (tolerance ? tolerance * toleranceWorld : undefined) });
-        let envelope;
-        if (geomOverride && geomOverride.type === "esriGeometryEnvelope") {
-            envelope = geomOverride.geom;
-        }
-        else {
-            envelope = tileEnvelope;
-        }
-        return { url: url.toString(), envelope };
-    }
-    // Makes an identify request to ESRI MapService , and return it as a list MapLayerFeatureInfo object
-    async getFeatureInfo(featureInfos, quadId, carto, _tree) {
-        if (!this._querySupported || this.format === undefined)
-            return;
-        const cartoPoint = {
-            x: this.getEPSG3857X(carto.longitudeDegrees),
-            y: this.getEPSG3857Y(carto.latitudeDegrees),
-            spatialReference: { wkid: 102100, latestWkid: 3857 },
-        };
-        const doFeatureInfoQuery = async (format, outFields, returnGeometry) => {
-            const infoUrl = this.constructFeatureUrl(quadId.row, quadId.column, quadId.level, format, { geom: cartoPoint, type: "esriGeometryPoint" }, outFields, 3 /* tolerance in pixel*/, returnGeometry);
-            if (!infoUrl || infoUrl.url.length === 0) {
-                Logger.logError(loggerCategory, `Could not construct feature info query URL`);
-                return undefined;
-            }
-            const response = this.fetch(new URL(infoUrl.url), { method: "GET" });
-            const featureResponse = new ArcGisFeatureResponse(format, response);
-            return featureResponse.getResponseData();
-        };
-        if (this._debugFeatureGeom) {
-            try {
-                let responseData = await doFeatureInfoQuery("PBF", "", true);
-                if (responseData) {
-                    Logger.logInfo(loggerCategory, JSON.stringify(responseData.data.toObject()));
-                }
-                responseData = await doFeatureInfoQuery("JSON", "", true);
-                if (responseData) {
-                    Logger.logInfo(loggerCategory, JSON.stringify(responseData.data));
-                }
-            }
-            catch (e) {
-                Logger.logInfo(loggerCategory, `Error occured with debug FeatureInfo: ${e}`);
-            }
-        }
-        try {
-            const responseData = await doFeatureInfoQuery(this.format, "*", false);
-            if (!responseData) {
-                Logger.logError(loggerCategory, `Could not get feature info data`);
-                return;
-            }
-            if (responseData.exceedTransferLimit) {
-                Logger.logError(loggerCategory, `Could not get feature info : transfert limit exeeded.`);
-                return;
-            }
-            const featureReader = this.format === "PBF" ? new ArcGisFeaturePBF(this._settings, this._layerMetadata) : new ArcGisFeatureJSON(this._settings, this._layerMetadata);
-            featureReader.readFeatureInfo(responseData, featureInfos);
-        }
-        catch (e) {
-            Logger.logError(loggerCategory, `Exception occured while loading feature info data : ${e}`);
-            return;
-        }
-        return;
-    }
-    async fetchTile(row, column, zoomLevel, refineEnvelope) {
-        if (!this.format) {
-            return undefined;
-        }
-        const geomOverride = (refineEnvelope ? { geom: refineEnvelope, type: "esriGeometryEnvelope" } : undefined);
-        const tileUrl = this.constructFeatureUrl(row, column, zoomLevel, this.format, geomOverride);
-        if (!tileUrl || tileUrl.url.length === 0) {
-            Logger.logError(loggerCategory, `Could not construct feature query URL for tile ${zoomLevel}/${row}/${column}`);
-            return undefined;
-        }
-        const response = this.fetch(new URL(tileUrl.url), { method: "GET" });
-        return new ArcGisFeatureResponse(this.format, response, tileUrl.envelope);
-    }
-    drawTileDebugInfo(row, column, zoomLevel, context) {
-        context.fillStyle = "cyan";
-        context.strokeRect(0, 0, this.tileSize, this.tileSize);
-        context.font = "30px Arial";
-        context.lineWidth = 5;
-        context.fillText(`${zoomLevel}-${row}-${column}`, 10, 50);
-    }
-    // Compute transform that provides coordinates in the canvas coordinate system (pixels, origin = top-left)
-    // from coordinate in world (i.e EPSG:3857)
-    computeTileWorld2CanvasTransform(row, column, zoomLevel) {
-        const tileExtentWorld3857 = this.getEPSG3857Extent(row, column, zoomLevel);
-        const worldTileWidth = tileExtentWorld3857.right - tileExtentWorld3857.left;
-        const canvasTileWidth = this.tileSize;
-        const world2CanvasRatio = canvasTileWidth / worldTileWidth;
-        const worldTileOrigin = Point3d.create(tileExtentWorld3857.left, tileExtentWorld3857.bottom);
-        const worldTileExtent = Point3d.create(tileExtentWorld3857.right, tileExtentWorld3857.top);
-        const canvasTileOriginOffset = worldTileOrigin.clone();
-        const canvasTileExtentOffset = worldTileExtent.clone();
-        canvasTileOriginOffset.scaleInPlace(world2CanvasRatio);
-        canvasTileExtentOffset.scaleInPlace(world2CanvasRatio);
-        const xTranslate = -1 * canvasTileOriginOffset.x;
-        // Canvas origin is uppler left corner, so we need to flip the y axsis
-        const yTranslate = canvasTileExtentOffset.y; // y-axis flip
-        const yWorld2CanvasRatio = -1 * world2CanvasRatio; // y-axis flip
-        const matrix = Matrix4d.createTranslationAndScaleXYZ(xTranslate, yTranslate, 0, world2CanvasRatio, yWorld2CanvasRatio, 1);
-        return matrix.asTransform;
-    }
-    async loadTile(row, column, zoomLevel) {
-        if ((this.status === MapLayerImageryProviderStatus.RequireAuth)) {
-            return undefined;
-        }
-        const canvas = document.createElement("canvas");
-        canvas.width = this.tileSize;
-        canvas.height = this.tileSize;
-        const ctx = canvas.getContext("2d");
-        if (ctx == null) {
-            Logger.logError(loggerCategory, "No canvas context available for loading tile.");
-            return undefined;
-        }
-        if (!this._symbologyRenderer) {
-            Logger.logError(loggerCategory, "No symbology renderer available for loading tile.");
-            return undefined;
-        }
-        try {
-            // Compute transform if CoordinatesQuantization is not supported by service
-            let transfo;
-            if (!this._supportsCoordinatesQuantization) {
-                transfo = this.computeTileWorld2CanvasTransform(row, column, zoomLevel);
-                if (!transfo) {
-                    Logger.logError(loggerCategory, `Could not compute data transformation for tile (${zoomLevel}/${row}/${column})`);
-                }
-            }
-            const renderer = new ArcGisFeatureRenderer(ctx, this._symbologyRenderer, transfo);
-            const featureReader = this.format === "PBF" ? new ArcGisFeaturePBF(this._settings, this._layerMetadata) : new ArcGisFeatureJSON(this._settings, this._layerMetadata);
-            const getSubEnvelopes = (envelope) => {
-                const dx = (envelope.xmax - envelope.xmin) * 0.5;
-                const dy = (envelope.xmax - envelope.xmin) * 0.5;
-                const subEnvelopes = [];
-                for (let posX = 0; posX < ArcGisFeatureProvider._nbSubTiles; posX++) {
-                    for (let posY = 0; posY < ArcGisFeatureProvider._nbSubTiles; posY++) {
-                        subEnvelopes.push({
-                            xmin: envelope.xmin + (dx * posX), ymin: envelope.ymin + (dy * posY),
-                            xmax: envelope.xmin + (dx * (posX + 1)), ymax: envelope.ymin + (dy * (posY + 1)),
-                            spatialReference: { wkid: 102100, latestWkid: 3857 },
-                        });
-                    }
-                }
-                return subEnvelopes;
-            };
-            // The strategy here is simple: we make a request for an area that represents the current tile (i.e envelope),
-            // the server will either return the requested data OR a 'exceedTransferLimit' message (too much data to transfers).
-            // In the latter case, we subdivide the previous request envelope in for 4 sub-envelopes,
-            // and repeat again until we get data.
-            const renderData = async (envelope) => {
-                let response;
-                let responseData;
-                try {
-                    response = await this.fetchTile(row, column, zoomLevel, envelope);
-                    if (!response) {
-                        Logger.logError(loggerCategory, `Error occurred while fetching tile (${zoomLevel}/${row}/${column})`);
-                        return;
-                    }
-                    responseData = await response.getResponseData();
-                    if (!responseData) {
-                        Logger.logError(loggerCategory, `Could not get response data for tile (${zoomLevel}/${row}/${column})`);
-                        return;
-                    }
-                }
-                catch (e) {
-                    Logger.logError(loggerCategory, `Exception occurred while loading tile (${zoomLevel}/${row}/${column}) : ${e}`);
-                    return;
-                }
-                if (responseData.exceedTransferLimit) {
-                    if (response.envelope) {
-                        const subEnvelopes = getSubEnvelopes(response.envelope);
-                        const renderPromises = [];
-                        for (const subEnvelope of subEnvelopes) {
-                            renderPromises.push(renderData(subEnvelope));
-                        }
-                        await Promise.all(renderPromises);
-                    }
-                    else {
-                        Logger.logError(loggerCategory, `Request exceeded transfer limit, could not refine request`);
-                    }
-                }
-                else {
-                    featureReader.readAndRender(responseData, renderer);
-                }
-            };
-            await renderData();
-            if (this._drawDebugInfo)
-                this.drawTileDebugInfo(row, column, zoomLevel, ctx);
-        }
-        catch (e) {
-            Logger.logError(loggerCategory, `Exception occurred while loading tile (${zoomLevel}/${row}/${column}) : ${e}`);
-        }
-        try {
-            const dataUrl = canvas.toDataURL("image/png");
-            const header = "data:image/png;base64,";
-            const dataUrl2 = dataUrl.substring(header.length);
-            return new ImageSource(base64StringToUint8Array(dataUrl2), ImageSourceFormat.Png);
-        }
-        catch (e) {
-            Logger.logError(loggerCategory, `Exception occurred while rendering tile (${zoomLevel}/${row}/${column}) : ${e}.`);
-        }
-        return undefined;
-    }
-}
-ArcGisFeatureProvider._nbSubTiles = 2;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { ImageSource, ImageSourceFormat, ServerError } from "@itwin/core-common";
+import { base64StringToUint8Array, IModelStatus, Logger } from "@itwin/core-bentley";
+import { Matrix4d, Point3d, Range2d } from "@itwin/core-geometry";
+import { ArcGisErrorCode, ArcGISImageryProvider, ArcGisUtilities, MapCartoRectangle, MapLayerImageryProviderStatus } from "@itwin/core-frontend";
+import { ArcGisSymbologyRenderer } from "./ArcGisSymbologyRenderer";
+import { ArcGisFeatureQuery } from "./ArcGisFeatureQuery";
+import { ArcGisFeatureRenderer } from "./ArcGisFeatureRenderer";
+import { ArcGisFeaturePBF } from "./ArcGisFeaturePBF";
+import { ArcGisFeatureJSON } from "./ArcGisFeatureJSON";
+import { ArcGisFeatureResponse } from "./ArcGisFeatureResponse";
+const loggerCategory = "MapLayersFormats.ArcGISFeature";
+/**  Provide tiles from a ESRI ArcGIS Feature service
+* @internal
+*/
+export class ArcGisFeatureProvider extends ArcGISImageryProvider {
+    constructor(settings) {
+        super(settings, true);
+        // Debug flags, should always be commited to FALSE !
+        this._drawDebugInfo = false;
+        this._debugFeatureGeom = false;
+        this._supportsCoordinatesQuantization = false;
+        this._querySupported = false;
+        this._layerId = 0;
+        this._outSR = 102100;
+        this._maxDepthFromLod = 0;
+        this._minDepthFromLod = 0;
+    }
+    get minimumZoomLevel() { return this._minDepthFromLod; }
+    get maximumZoomLevel() { return this._maxDepthFromLod; }
+    async initialize() {
+        const metadata = await this.getServiceJson();
+        const json = metadata?.content;
+        if (json === undefined) {
+            Logger.logError(loggerCategory, "Could not get service JSON");
+            throw new ServerError(IModelStatus.ValidationFailed, "");
+        }
+        if (json?.error?.code === ArcGisErrorCode.TokenRequired || json?.error?.code === ArcGisErrorCode.InvalidToken) {
+            // Check again layer status, it might have change during await.
+            if (this.status === MapLayerImageryProviderStatus.Valid) {
+                this.setStatus(MapLayerImageryProviderStatus.RequireAuth);
+                return;
+            }
+        }
+        if (json.capabilities) {
+            this._querySupported = json.capabilities.indexOf("Query") >= 0;
+            if (!this._querySupported)
+                throw new ServerError(IModelStatus.ValidationFailed, "");
+        }
+        this.serviceJson = json;
+        let foundVisibleSubLayer = false;
+        if (this._settings.subLayers.length >= 0) {
+            // There is more than sub-layer for this layer, pick the first visible one.
+            for (const layer of this._settings.subLayers) {
+                if (layer.visible && typeof layer.id === "number") {
+                    this._layerId = layer.id;
+                    foundVisibleSubLayer = true;
+                    break;
+                }
+            }
+        }
+        if (!foundVisibleSubLayer && json !== undefined) {
+            // No suitable sublayer was specified on the layerSettings object, lets find a default one in the capabilities
+            // Check layer metadata
+            if (Array.isArray(this.serviceJson.layers) && this.serviceJson.layers.length >= 1) {
+                const hasDefaultVisibility = Object.keys(this.serviceJson.layers[0]).includes("defaultVisibility");
+                if (hasDefaultVisibility) {
+                    for (const layer of this.serviceJson.layers) {
+                        if (layer.defaultVisibility) {
+                            this._layerId = layer.id;
+                        }
+                    }
+                }
+                else {
+                    // On some older servers, the default visiblity is on the layer capabilities (i.e. not the service capabilities)
+                    for (const layer of this.serviceJson.layers) {
+                        const layerJson = await this.getLayerMetadata(layer.id);
+                        if (!layerJson) {
+                            continue;
+                        }
+                        if (layerJson.defaultVisibility) {
+                            this._layerId = layer.id;
+                            this._layerMetadata = layerJson;
+                            break;
+                        }
+                    }
+                }
+            }
+            else {
+                // There is no layer to publish? Something is off with this server..
+                throw new ServerError(IModelStatus.ValidationFailed, "");
+            }
+        }
+        // Make sure we cache layer info (i.e. rendering info)
+        if (!this._layerMetadata) {
+            this._layerMetadata = await this.getLayerMetadata(this._layerId);
+            if (!this._layerMetadata) {
+                Logger.logError(loggerCategory, "Could not layer metadata");
+                throw new ServerError(IModelStatus.ValidationFailed, "");
+            }
+        }
+        // Parse server version
+        let majorVersion;
+        if (this.serviceJson?.currentVersion) {
+            try {
+                majorVersion = Math.trunc(this.serviceJson?.currentVersion);
+            }
+            catch {
+            }
+        }
+        // Coordinates Quantization:  If supported, server will transform for us the coordinates in the Tile coordinate space (pixels, origin = upper left corner
+        // If not supported, transformation will be applied client side.
+        // Note: For some reasons, even though 'supportsCoordinatesQuantization' is set to 'true' on the layer metadata, server will give an error message for server version < 11
+        if (majorVersion && majorVersion >= 11 && this._layerMetadata.supportsCoordinatesQuantization) {
+            this._supportsCoordinatesQuantization = true;
+        }
+        // Check supported query formats: JSON and PBF are currently implemented by this provider
+        // Note: needs to be checked on the layer metadata, service metadata advertises a different set of formats
+        //       Also, since PBF format does not support floating points, there is no point using this format if supportsCoordinatesQuantization is not available.
+        if (this._layerMetadata.supportedQueryFormats) {
+            const formats = this._layerMetadata.supportedQueryFormats.split(", ");
+            if (formats.includes("PBF") && this._supportsCoordinatesQuantization) {
+                this._format = "PBF";
+            }
+            else if (formats.includes("JSON")) {
+                this._format = "JSON";
+            }
+        }
+        if (!this._format) {
+            Logger.logError(loggerCategory, "Could not get request format from service JSON");
+            throw new ServerError(IModelStatus.ValidationFailed, "");
+        }
+        // Read range using full extent from service metadata
+        if (json.fullExtent) {
+            if (json.fullExtent.spatialReference.latestWkid === 3857 || json.fullExtent.spatialReference.wkid === 102100) {
+                const range3857 = Range2d.createFrom({
+                    low: { x: json.fullExtent.xmin, y: json.fullExtent.ymin },
+                    high: { x: json.fullExtent.xmax, y: json.fullExtent.ymax }
+                });
+                const west = this.getEPSG4326Lon(range3857.xLow);
+                const south = this.getEPSG4326Lat(range3857.yLow);
+                const east = this.getEPSG4326Lon(range3857.xHigh);
+                const north = this.getEPSG4326Lat(range3857.yHigh);
+                this.cartoRange = MapCartoRectangle.fromDegrees(west, south, east, north);
+            }
+        }
+        // Check for minScale / max scale
+        const minScale = this._layerMetadata?.minScale || undefined; // undefined, 0 -> undefined
+        const maxScale = this._layerMetadata?.maxScale || undefined; // undefined, 0 -> undefined
+        const scales = ArcGisUtilities.getZoomLevelsScales(this.defaultMaximumZoomLevel, this.tileSize, minScale, maxScale, 1.0);
+        if (scales.minLod)
+            this._minDepthFromLod = scales.minLod;
+        // Some servers advertises a max LOD of 0, it should be interpreted as 'not defined' (otherwise a max lod of 0 would would mean never display anything)
+        this._maxDepthFromLod = (scales.maxLod ? scales.maxLod : this.defaultMaximumZoomLevel);
+        this._symbologyRenderer = new ArcGisSymbologyRenderer(this._layerMetadata?.geometryType, this._layerMetadata?.drawingInfo?.renderer);
+    }
+    async getLayerMetadata(layerId) {
+        let metadata;
+        try {
+            const url = new URL(this._settings.url);
+            url.pathname = `${url.pathname}/${layerId}`;
+            metadata = await ArcGisUtilities.getServiceJson(url.toString(), this._settings.formatId, this._settings.userName, this._settings.password, this._accessTokenRequired);
+        }
+        catch {
+        }
+        return metadata?.content;
+    }
+    get tileSize() { return 512; }
+    get format() { return this._format; }
+    // We don't use this method inside this provider (see constructFeatureUrl), but since this is an abstract method, we need to define something
+    async constructUrl(_row, _column, _zoomLevel) {
+        return "";
+    }
+    constructFeatureUrl(row, column, zoomLevel, format, geomOverride, outFields, tolerance, returnGeometry) {
+        const tileExtent = this.getEPSG3857Extent(row, column, zoomLevel);
+        const tileEnvelope = {
+            xmin: tileExtent.left, ymin: tileExtent.bottom,
+            xmax: tileExtent.right, ymax: tileExtent.top,
+            spatialReference: { wkid: 102100, latestWkid: 3857 },
+        };
+        // Actual spatial filter.
+        // By default, we request the tile extent.  If 'cartoPoint' is specified,
+        // we restrict the spatial to specific point. (i.e. GetFeatureInfo requests)
+        // If envelope is provided, it has the priority over 'cartoPoint'
+        let geometry;
+        if (geomOverride) {
+            geometry = geomOverride;
+        }
+        else {
+            geometry = { geom: tileEnvelope, type: "esriGeometryEnvelope" };
+        }
+        let quantizationParameters;
+        const toleranceWorld = (tileExtent.top - tileExtent.bottom) / this.tileSize;
+        if (this._supportsCoordinatesQuantization) {
+            quantizationParameters = {
+                mode: "view",
+                originPosition: "upperLeft",
+                tolerance: toleranceWorld,
+                extent: tileEnvelope,
+            };
+        }
+        const url = new ArcGisFeatureQuery(this._settings.url, this._layerId, format, this._outSR, { geometry,
+            geometryType: "esriGeometryEnvelope",
+            returnExceededLimitFeatures: false,
+            maxRecordCountFactor: 3,
+            resultType: "tile",
+            quantizationParameters,
+            outFields,
+            returnGeometry,
+            distance: (tolerance ? tolerance * toleranceWorld : undefined) });
+        let envelope;
+        if (geomOverride && geomOverride.type === "esriGeometryEnvelope") {
+            envelope = geomOverride.geom;
+        }
+        else {
+            envelope = tileEnvelope;
+        }
+        return { url: url.toString(), envelope };
+    }
+    // Makes an identify request to ESRI MapService , and return it as a list MapLayerFeatureInfo object
+    async getFeatureInfo(featureInfos, quadId, carto, _tree) {
+        if (!this._querySupported || this.format === undefined)
+            return;
+        const cartoPoint = {
+            x: this.getEPSG3857X(carto.longitudeDegrees),
+            y: this.getEPSG3857Y(carto.latitudeDegrees),
+            spatialReference: { wkid: 102100, latestWkid: 3857 },
+        };
+        const doFeatureInfoQuery = async (format, outFields, returnGeometry) => {
+            const infoUrl = this.constructFeatureUrl(quadId.row, quadId.column, quadId.level, format, { geom: cartoPoint, type: "esriGeometryPoint" }, outFields, 3 /* tolerance in pixel*/, returnGeometry);
+            if (!infoUrl || infoUrl.url.length === 0) {
+                Logger.logError(loggerCategory, `Could not construct feature info query URL`);
+                return undefined;
+            }
+            const response = this.fetch(new URL(infoUrl.url), { method: "GET" });
+            const featureResponse = new ArcGisFeatureResponse(format, response);
+            return featureResponse.getResponseData();
+        };
+        if (this._debugFeatureGeom) {
+            try {
+                let responseData = await doFeatureInfoQuery("PBF", "", true);
+                if (responseData) {
+                    Logger.logInfo(loggerCategory, JSON.stringify(responseData.data.toObject()));
+                }
+                responseData = await doFeatureInfoQuery("JSON", "", true);
+                if (responseData) {
+                    Logger.logInfo(loggerCategory, JSON.stringify(responseData.data));
+                }
+            }
+            catch (e) {
+                Logger.logInfo(loggerCategory, `Error occured with debug FeatureInfo: ${e}`);
+            }
+        }
+        try {
+            const responseData = await doFeatureInfoQuery(this.format, "*", false);
+            if (!responseData) {
+                Logger.logError(loggerCategory, `Could not get feature info data`);
+                return;
+            }
+            if (responseData.exceedTransferLimit) {
+                Logger.logError(loggerCategory, `Could not get feature info : transfert limit exeeded.`);
+                return;
+            }
+            const featureReader = this.format === "PBF" ? new ArcGisFeaturePBF(this._settings, this._layerMetadata) : new ArcGisFeatureJSON(this._settings, this._layerMetadata);
+            featureReader.readFeatureInfo(responseData, featureInfos);
+        }
+        catch (e) {
+            Logger.logError(loggerCategory, `Exception occured while loading feature info data : ${e}`);
+            return;
+        }
+        return;
+    }
+    async fetchTile(row, column, zoomLevel, refineEnvelope) {
+        if (!this.format) {
+            return undefined;
+        }
+        const geomOverride = (refineEnvelope ? { geom: refineEnvelope, type: "esriGeometryEnvelope" } : undefined);
+        const tileUrl = this.constructFeatureUrl(row, column, zoomLevel, this.format, geomOverride);
+        if (!tileUrl || tileUrl.url.length === 0) {
+            Logger.logError(loggerCategory, `Could not construct feature query URL for tile ${zoomLevel}/${row}/${column}`);
+            return undefined;
+        }
+        const response = this.fetch(new URL(tileUrl.url), { method: "GET" });
+        return new ArcGisFeatureResponse(this.format, response, tileUrl.envelope);
+    }
+    drawTileDebugInfo(row, column, zoomLevel, context) {
+        context.fillStyle = "cyan";
+        context.strokeRect(0, 0, this.tileSize, this.tileSize);
+        context.font = "30px Arial";
+        context.lineWidth = 5;
+        context.fillText(`${zoomLevel}-${row}-${column}`, 10, 50);
+    }
+    // Compute transform that provides coordinates in the canvas coordinate system (pixels, origin = top-left)
+    // from coordinate in world (i.e EPSG:3857)
+    computeTileWorld2CanvasTransform(row, column, zoomLevel) {
+        const tileExtentWorld3857 = this.getEPSG3857Extent(row, column, zoomLevel);
+        const worldTileWidth = tileExtentWorld3857.right - tileExtentWorld3857.left;
+        const canvasTileWidth = this.tileSize;
+        const world2CanvasRatio = canvasTileWidth / worldTileWidth;
+        const worldTileOrigin = Point3d.create(tileExtentWorld3857.left, tileExtentWorld3857.bottom);
+        const worldTileExtent = Point3d.create(tileExtentWorld3857.right, tileExtentWorld3857.top);
+        const canvasTileOriginOffset = worldTileOrigin.clone();
+        const canvasTileExtentOffset = worldTileExtent.clone();
+        canvasTileOriginOffset.scaleInPlace(world2CanvasRatio);
+        canvasTileExtentOffset.scaleInPlace(world2CanvasRatio);
+        const xTranslate = -1 * canvasTileOriginOffset.x;
+        // Canvas origin is uppler left corner, so we need to flip the y axsis
+        const yTranslate = canvasTileExtentOffset.y; // y-axis flip
+        const yWorld2CanvasRatio = -1 * world2CanvasRatio; // y-axis flip
+        const matrix = Matrix4d.createTranslationAndScaleXYZ(xTranslate, yTranslate, 0, world2CanvasRatio, yWorld2CanvasRatio, 1);
+        return matrix.asTransform;
+    }
+    async loadTile(row, column, zoomLevel) {
+        if ((this.status === MapLayerImageryProviderStatus.RequireAuth)) {
+            return undefined;
+        }
+        const canvas = document.createElement("canvas");
+        canvas.width = this.tileSize;
+        canvas.height = this.tileSize;
+        const ctx = canvas.getContext("2d");
+        if (ctx == null) {
+            Logger.logError(loggerCategory, "No canvas context available for loading tile.");
+            return undefined;
+        }
+        if (!this._symbologyRenderer) {
+            Logger.logError(loggerCategory, "No symbology renderer available for loading tile.");
+            return undefined;
+        }
+        try {
+            // Compute transform if CoordinatesQuantization is not supported by service
+            let transfo;
+            if (!this._supportsCoordinatesQuantization) {
+                transfo = this.computeTileWorld2CanvasTransform(row, column, zoomLevel);
+                if (!transfo) {
+                    Logger.logError(loggerCategory, `Could not compute data transformation for tile (${zoomLevel}/${row}/${column})`);
+                }
+            }
+            const renderer = new ArcGisFeatureRenderer(ctx, this._symbologyRenderer, transfo);
+            const featureReader = this.format === "PBF" ? new ArcGisFeaturePBF(this._settings, this._layerMetadata) : new ArcGisFeatureJSON(this._settings, this._layerMetadata);
+            const getSubEnvelopes = (envelope) => {
+                const dx = (envelope.xmax - envelope.xmin) * 0.5;
+                const dy = (envelope.xmax - envelope.xmin) * 0.5;
+                const subEnvelopes = [];
+                for (let posX = 0; posX < ArcGisFeatureProvider._nbSubTiles; posX++) {
+                    for (let posY = 0; posY < ArcGisFeatureProvider._nbSubTiles; posY++) {
+                        subEnvelopes.push({
+                            xmin: envelope.xmin + (dx * posX), ymin: envelope.ymin + (dy * posY),
+                            xmax: envelope.xmin + (dx * (posX + 1)), ymax: envelope.ymin + (dy * (posY + 1)),
+                            spatialReference: { wkid: 102100, latestWkid: 3857 },
+                        });
+                    }
+                }
+                return subEnvelopes;
+            };
+            // The strategy here is simple: we make a request for an area that represents the current tile (i.e envelope),
+            // the server will either return the requested data OR a 'exceedTransferLimit' message (too much data to transfers).
+            // In the latter case, we subdivide the previous request envelope in for 4 sub-envelopes,
+            // and repeat again until we get data.
+            const renderData = async (envelope) => {
+                let response;
+                let responseData;
+                try {
+                    response = await this.fetchTile(row, column, zoomLevel, envelope);
+                    if (!response) {
+                        Logger.logError(loggerCategory, `Error occurred while fetching tile (${zoomLevel}/${row}/${column})`);
+                        return;
+                    }
+                    responseData = await response.getResponseData();
+                    if (!responseData) {
+                        Logger.logError(loggerCategory, `Could not get response data for tile (${zoomLevel}/${row}/${column})`);
+                        return;
+                    }
+                }
+                catch (e) {
+                    Logger.logError(loggerCategory, `Exception occurred while loading tile (${zoomLevel}/${row}/${column}) : ${e}`);
+                    return;
+                }
+                if (responseData.exceedTransferLimit) {
+                    if (response.envelope) {
+                        const subEnvelopes = getSubEnvelopes(response.envelope);
+                        const renderPromises = [];
+                        for (const subEnvelope of subEnvelopes) {
+                            renderPromises.push(renderData(subEnvelope));
+                        }
+                        await Promise.all(renderPromises);
+                    }
+                    else {
+                        Logger.logError(loggerCategory, `Request exceeded transfer limit, could not refine request`);
+                    }
+                }
+                else {
+                    featureReader.readAndRender(responseData, renderer);
+                }
+            };
+            await renderData();
+            if (this._drawDebugInfo)
+                this.drawTileDebugInfo(row, column, zoomLevel, ctx);
+        }
+        catch (e) {
+            Logger.logError(loggerCategory, `Exception occurred while loading tile (${zoomLevel}/${row}/${column}) : ${e}`);
+        }
+        try {
+            const dataUrl = canvas.toDataURL("image/png");
+            const header = "data:image/png;base64,";
+            const dataUrl2 = dataUrl.substring(header.length);
+            return new ImageSource(base64StringToUint8Array(dataUrl2), ImageSourceFormat.Png);
+        }
+        catch (e) {
+            Logger.logError(loggerCategory, `Exception occurred while rendering tile (${zoomLevel}/${row}/${column}) : ${e}.`);
+        }
+        return undefined;
+    }
+}
+ArcGisFeatureProvider._nbSubTiles = 2;
 //# sourceMappingURL=ArcGisFeatureProvider.js.map