@itwin/map-layers-formats 4.6.0-dev.18 → 4.6.0-dev.19

package/lib/esm/OgcApiFeatures/OgcApiFeaturesFormat.js

@@ -0,0 +1,91 @@
+import { appendQueryParams, ImageryMapLayerFormat, MapLayerSourceStatus, setBasicAuthorization } from "@itwin/core-frontend";
+import { OgcApiFeaturesProvider } from "./OgcApiFeaturesProvider";
+/** @internal */
+class OgcApiFeaturesMapLayerFormat extends ImageryMapLayerFormat {
+    static createImageryProvider(settings) { return new OgcApiFeaturesProvider(settings); }
+    static async validate(args) {
+        const { source } = args;
+        const { userName, password } = source;
+        let status = MapLayerSourceStatus.InvalidUrl;
+        try {
+            let headers;
+            if (userName && password) {
+                headers = new Headers();
+                setBasicAuthorization(headers, userName, password);
+            }
+            const opts = {
+                method: "GET",
+                headers,
+            };
+            let url = appendQueryParams(source.url, source.savedQueryParams);
+            url = appendQueryParams(url, source.unsavedQueryParams);
+            let response = await fetch(url, opts);
+            let json = await response.json();
+            if (!json) {
+                return { status };
+            }
+            const createCollectionsList = (data) => {
+                let array;
+                for (const collection of data.collections) {
+                    if (collection.itemType === "feature") {
+                        const subLayerProps = {
+                            id: collection.id,
+                            name: collection.id,
+                            title: collection.title,
+                            visible: true,
+                            parent: undefined,
+                            children: undefined,
+                        };
+                        if (array)
+                            array.push(subLayerProps);
+                        else
+                            array = [subLayerProps];
+                    }
+                }
+                return array;
+            };
+            let subLayers;
+            if (Array.isArray(json.collections)) {
+                subLayers = createCollectionsList(json);
+                status = MapLayerSourceStatus.Valid;
+            }
+            else if (json.itemType === "feature" || json.type === "FeatureCollection") {
+                // We expect one of the following URL:
+                // http://server/collections/<collectionName>
+                // http://server/collections/<collectionName>/items
+                subLayers = [{
+                        id: json.id,
+                        name: json.id,
+                        title: json.title,
+                        visible: true,
+                        parent: undefined,
+                        children: undefined,
+                    }];
+                status = MapLayerSourceStatus.Valid;
+            }
+            else if (Array.isArray(json.links)) {
+                // This might be the main landing page
+                const collectionsLink = json.links.find((link) => link.rel.includes("data") && link.type === "application/json");
+                let collectionsUrl = appendQueryParams(collectionsLink.href, source.savedQueryParams);
+                collectionsUrl = appendQueryParams(collectionsUrl, source.unsavedQueryParams);
+                response = await fetch(collectionsUrl, opts);
+                json = await response.json();
+                if (Array.isArray(json.collections)) {
+                    subLayers = createCollectionsList(json);
+                    status = MapLayerSourceStatus.Valid;
+                }
+            }
+            return { status, subLayers };
+        }
+        catch (err) {
+            status = MapLayerSourceStatus.InvalidUrl;
+            if (err?.status === 401) {
+                status = ((userName && password) ? MapLayerSourceStatus.InvalidCredentials : MapLayerSourceStatus.RequireAuth);
+            }
+            return { status };
+        }
+    }
+}
+OgcApiFeaturesMapLayerFormat.formatId = "OgcApiFeatures";
+export { OgcApiFeaturesMapLayerFormat };
+//# sourceMappingURL=OgcApiFeaturesFormat.js.map

package/lib/esm/OgcApiFeatures/OgcApiFeaturesFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OgcApiFeaturesFormat.js","sourceRoot":"","sources":["../../../src/OgcApiFeatures/OgcApiFeaturesFormat.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\nimport { ImageMapLayerSettings, MapSubLayerProps } from \"@itwin/core-common\";\r\nimport { appendQueryParams, ImageryMapLayerFormat, MapLayerImageryProvider, MapLayerSourceStatus, MapLayerSourceValidation, setBasicAuthorization, ValidateSourceArgs } from \"@itwin/core-frontend\";\r\nimport { OgcApiFeaturesProvider } from \"./OgcApiFeaturesProvider\";\r\n\r\n/** @internal */\r\nexport class OgcApiFeaturesMapLayerFormat extends ImageryMapLayerFormat {\r\n  public static override formatId = \"OgcApiFeatures\";\r\n  public static override createImageryProvider(settings: ImageMapLayerSettings): MapLayerImageryProvider | undefined { return new OgcApiFeaturesProvider(settings); }\r\n\r\n  public static override async validate(args: ValidateSourceArgs): Promise<MapLayerSourceValidation> {\r\n\r\n    const {source} = args;\r\n    const { userName, password } = source;\r\n    let status = MapLayerSourceStatus.InvalidUrl;\r\n    try {\r\n\r\n      let headers: Headers | undefined;\r\n      if (userName && password) {\r\n        headers = new Headers();\r\n        setBasicAuthorization(headers, userName, password);\r\n      }\r\n      const opts: RequestInit = {\r\n        method: \"GET\",\r\n        headers,\r\n      };\r\n\r\n      let url = appendQueryParams(source.url, source.savedQueryParams);\r\n      url = appendQueryParams(url, source.unsavedQueryParams);\r\n      let response = await fetch(url, opts);\r\n      let json = await response.json();\r\n      if (!json) {\r\n        return { status };\r\n      }\r\n\r\n      const createCollectionsList = (data: any) => {\r\n        let array: MapSubLayerProps[] | undefined;\r\n        for (const collection of data.collections) {\r\n          if (collection.itemType === \"feature\") {\r\n            const subLayerProps = {\r\n              id: collection.id,\r\n              name: collection.id,\r\n              title: collection.title,\r\n              visible: true,\r\n              parent: undefined,\r\n              children: undefined,\r\n            };\r\n            if (array)\r\n              array.push(subLayerProps);\r\n            else\r\n              array = [subLayerProps];\r\n          }\r\n        }\r\n        return array;\r\n      };\r\n\r\n      let subLayers: MapSubLayerProps[] | undefined;\r\n      if (Array.isArray(json.collections)) {\r\n        subLayers = createCollectionsList(json);\r\n        status = MapLayerSourceStatus.Valid;\r\n      } else if (json.itemType === \"feature\" || json.type === \"FeatureCollection\") {\r\n        // We expect one of the following URL:\r\n        // http://server/collections/<collectionName>\r\n        // http://server/collections/<collectionName>/items\r\n        subLayers = [{\r\n          id: json.id,\r\n          name: json.id,\r\n          title: json.title,\r\n          visible: true,\r\n          parent: undefined,\r\n          children: undefined,\r\n        }];\r\n        status = MapLayerSourceStatus.Valid;\r\n      } else if (Array.isArray(json.links)) {\r\n        // This might be the main landing page\r\n        const collectionsLink = json.links.find((link: any)=> link.rel.includes(\"data\") && link.type === \"application/json\");\r\n        let collectionsUrl = appendQueryParams(collectionsLink.href, source.savedQueryParams);\r\n        collectionsUrl = appendQueryParams(collectionsUrl, source.unsavedQueryParams);\r\n        response = await fetch(collectionsUrl, opts);\r\n        json = await response.json();\r\n        if (Array.isArray(json.collections)) {\r\n          subLayers = createCollectionsList(json);\r\n          status = MapLayerSourceStatus.Valid;\r\n        }\r\n\r\n      }\r\n\r\n      return { status, subLayers };\r\n\r\n    } catch (err: any) {\r\n      status = MapLayerSourceStatus.InvalidUrl;\r\n      if (err?.status === 401) {\r\n        status = ((userName && password) ? MapLayerSourceStatus.InvalidCredentials : MapLayerSourceStatus.RequireAuth);\r\n      }\r\n      return { status};\r\n    }\r\n  }\r\n}\r\n"]}

package/lib/esm/OgcApiFeatures/OgcApiFeaturesProvider.d.ts

@@ -0,0 +1,54 @@
+import { HitDetail, ImageryMapTileTree, MapFeatureInfoOptions, MapLayerFeatureInfo, MapLayerImageryProvider, QuadId } from "@itwin/core-frontend";
+import { EsriSymbol } from "../ArcGisFeature/EsriSymbology";
+import { Cartographic, ImageMapLayerSettings, ImageSource } from "@itwin/core-common";
+import { FeatureDefaultSymbology } from "../Feature/FeatureSymbology";
+import { RandomMapColor } from "../Feature/RandomMapColor";
+/**  Provide tiles from a ESRI ArcGIS Feature service
+* @internal
+*/
+export declare class DefaultOgcSymbology implements FeatureDefaultSymbology {
+    private static readonly _defaultPMSProps;
+    private _defaultPMS;
+    private static readonly _defaultSLSProps;
+    private _defaultSLS;
+    private static readonly _defaultSFSProps;
+    private _defaultSFS;
+    constructor(randomColor?: RandomMapColor);
+    initialize(): Promise<void>;
+    getSymbology(geometryType: string): EsriSymbol;
+}
+/** @internal */
+export declare class OgcApiFeaturesProvider extends MapLayerImageryProvider {
+    private readonly _drawDebugInfo;
+    private readonly _limitParamMaxValue;
+    private readonly _tiledModeMinLod;
+    private readonly _staticModeFetchTimeout;
+    private readonly _tileModeFetchTimeout;
+    private readonly _forceTileMode;
+    private _spatialIdx;
+    private _defaultSymbol;
+    private _renderer;
+    private _collectionUrl;
+    private _itemsUrl;
+    private readonly _itemsCrs;
+    private _queryables;
+    serviceJson: any;
+    private _staticData;
+    constructor(settings: ImageMapLayerSettings);
+    get supportsMapFeatureInfo(): boolean;
+    get minimumZoomLevel(): number;
+    get staticMode(): boolean;
+    initialize(): Promise<void>;
+    private fetchMetadata;
+    private fetchAllItems;
+    private fetchItems;
+    private indexStaticData;
+    get tileSize(): number;
+    constructUrl(_row: number, _column: number, _zoomLevel: number): Promise<string>;
+    drawTileDebugInfo(row: number, column: number, zoomLevel: number, context: CanvasRenderingContext2D): void;
+    computeTileWorld2CanvasTransform(row: number, column: number, zoomLevel: number): import("@itwin/core-geometry").Transform | undefined;
+    loadTile(row: number, column: number, zoomLevel: number): Promise<ImageSource | undefined>;
+    private createImageSourceFromDataURL;
+    getFeatureInfo(featureInfos: MapLayerFeatureInfo[], quadId: QuadId, carto: Cartographic, _tree: ImageryMapTileTree, hit: HitDetail, options?: MapFeatureInfoOptions): Promise<void>;
+}
+//# sourceMappingURL=OgcApiFeaturesProvider.d.ts.map

package/lib/esm/OgcApiFeatures/OgcApiFeaturesProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OgcApiFeaturesProvider.d.ts","sourceRoot":"","sources":["../../../src/OgcApiFeatures/OgcApiFeaturesProvider.ts"],"names":[],"mappings":"AAKA,OAAO,EAA2B,SAAS,EAAE,kBAAkB,EAAqB,qBAAqB,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,EAAe,MAAM,sBAAsB,CAAC;AAC3M,OAAO,EAAqF,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC/I,OAAO,EAAE,YAAY,EAAY,qBAAqB,EAAE,WAAW,EAA8C,MAAM,oBAAoB,CAAC;AAM5I,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAM3D;;EAEE;AACF,qBAAa,mBAAoB,YAAW,uBAAuB;IAEjE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAQtC;IACF,OAAO,CAAC,WAAW,CAAU;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAKtC;IACF,OAAO,CAAC,WAAW,CAAU;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAKtC;IACF,OAAO,CAAC,WAAW,CAA0D;gBAE1D,WAAW,CAAC,EAAE,cAAc;IA4BlC,UAAU;IAKhB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU;CAUtD;AACD,gBAAgB;AAChB,qBAAa,sBAAuB,SAAQ,uBAAuB;IAGjE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IAGxC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAM;IACvC,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAS;IACjD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,cAAc,CAAM;IAC5B,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkD;IAC5E,OAAO,CAAC,WAAW,CAAM;IAElB,WAAW,EAAE,GAAG,CAAC;IACxB,OAAO,CAAC,WAAW,CAAsC;gBAE7C,QAAQ,EAAE,qBAAqB;IAI3C,IAAoB,sBAAsB,YAAkB;IAC5D,IAAoB,gBAAgB,IAAI,MAAM,CAA6E;IAC3H,IAAW,UAAU,IAAI,OAAO,CAA6E;IAEvF,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAyHnC,aAAa;YAMb,aAAa;YAQb,UAAU;YAqCV,eAAe;IA+D7B,IAAoB,QAAQ,IAAI,MAAM,CAAgB;IAGzC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAItF,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,wBAAwB;IAUnG,gCAAgC,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IA2BhE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAkFhH,OAAO,CAAC,4BAA4B;IAad,cAAc,CAAC,YAAY,EAAE,mBAAmB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;CAuC1M"}

package/lib/esm/OgcApiFeatures/OgcApiFeaturesProvider.js

@@ -0,0 +1,473 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { FeatureGraphicsRenderer, MapCartoRectangle, MapLayerImageryProvider } from "@itwin/core-frontend";
+import { EsriPMS, EsriSFS, EsriSLS } from "../ArcGisFeature/EsriSymbology";
+import { ColorDef, ImageSource, ImageSourceFormat, ServerError } from "@itwin/core-common";
+import { Matrix4d, Point3d, Range2d } from "@itwin/core-geometry";
+import { ArcGisSymbologyCanvasRenderer } from "../ArcGisFeature/ArcGisSymbologyRenderer";
+import { FeatureCanvasRenderer } from "../Feature/FeatureCanvasRenderer";
+import { base64StringToUint8Array, IModelStatus, Logger } from "@itwin/core-bentley";
+import { OgcApiFeaturesReader } from "./OgcApiFeaturesReader";
+import { RandomMapColor } from "../Feature/RandomMapColor";
+import { DefaultMarkerIcon } from "../Feature/DefaultMarkerIcon";
+const loggerCategory = "MapLayersFormats.OgcApiFeatures";
+const dataUrlHeaderToken = "base64,";
+/**  Provide tiles from a ESRI ArcGIS Feature service
+* @internal
+*/
+class DefaultOgcSymbology {
+    constructor(randomColor) {
+        this._defaultSFS = EsriSFS.fromJSON(DefaultOgcSymbology._defaultSFSProps);
+        const color = randomColor ? randomColor.getColorDef() : ColorDef.blue;
+        this._defaultPMS = EsriPMS.fromJSON({
+            ...DefaultMarkerIcon.getContent(color),
+            type: "esriPMS",
+            url: "",
+            width: 16,
+            height: 24,
+            xoffset: 0,
+            yoffset: -12,
+        });
+        const randomColors = color.colors;
+        const newSLSProps = {
+            ...DefaultOgcSymbology._defaultSLSProps,
+            color: [randomColors.r, randomColors.g, randomColors.b, 255],
+        };
+        this._defaultSLS = EsriSLS.fromJSON(newSLSProps);
+        this._defaultSFS = EsriSFS.fromJSON({
+            ...DefaultOgcSymbology._defaultSFSProps,
+            color: [randomColors.r, randomColors.g, randomColors.b, 255],
+            outline: {
+                ...DefaultOgcSymbology._defaultSLSProps,
+                color: [0, 0, 0, 255],
+            },
+        });
+    }
+    async initialize() {
+        // Marker image need to be loaded upfront;
+        await this._defaultPMS.loadImage();
+    }
+    getSymbology(geometryType) {
+        if (geometryType === "LineString" || geometryType === "MultiLineString")
+            return this._defaultSLS;
+        else if (geometryType === "Polygon" || geometryType === "MultiPolygon")
+            return this._defaultSFS;
+        else if (geometryType === "Point" || geometryType === "MultiPoint")
+            return this._defaultPMS;
+        throw new Error(`Could not get default symbology for geometry type ${geometryType}`);
+    }
+}
+DefaultOgcSymbology._defaultPMSProps = {
+    type: "esriPMS",
+    url: "",
+    width: 16,
+    height: 24,
+    // We want the anchor point to be the bottom of the push pin, so apply offset on the y-axis (anchor point is already in the center of the icon)
+    xoffset: 0,
+    yoffset: -12,
+};
+DefaultOgcSymbology._defaultSLSProps = {
+    type: "esriSLS",
+    color: [0, 0, 255, 255],
+    width: 1,
+    style: "esriSLSSolid",
+};
+DefaultOgcSymbology._defaultSFSProps = {
+    type: "esriSFS",
+    color: [0, 0, 255, 255],
+    style: "esriSFSSolid",
+    outline: DefaultOgcSymbology._defaultSLSProps,
+};
+export { DefaultOgcSymbology };
+/** @internal */
+export class OgcApiFeaturesProvider extends MapLayerImageryProvider {
+    constructor(settings) {
+        super(settings, true);
+        // Debug flags, should always be committed to FALSE !
+        this._drawDebugInfo = false;
+        /// ////////////////////////////
+        this._limitParamMaxValue = 10000; // This is documented in OGC Features specification; a single items request never returns more than 10 000 items
+        this._tiledModeMinLod = 14;
+        this._staticModeFetchTimeout = 10000;
+        this._tileModeFetchTimeout = 10000;
+        this._forceTileMode = false;
+        this._defaultSymbol = new DefaultOgcSymbology(new RandomMapColor());
+        this._collectionUrl = "";
+        this._itemsUrl = "";
+        this._itemsCrs = "http://www.opengis.net/def/crs/OGC/1.3/CRS84"; // Fixed fow now
+    }
+    get supportsMapFeatureInfo() { return true; }
+    get minimumZoomLevel() { return this.staticMode ? super.minimumZoomLevel : this._tiledModeMinLod; }
+    get staticMode() { return !!(this._spatialIdx && this._staticData && !this._forceTileMode); }
+    async initialize() {
+        this._collectionUrl = this._settings.url;
+        let layerId;
+        // OGC Feature service request can only serve data for a single feature
+        // so if multiple sub-layer ids are specified, we pick the first one.
+        if (this._settings.subLayers && this._settings.subLayers.length > 0) {
+            layerId = this._settings.subLayers[0].id;
+        }
+        const readCollectionsPage = (data) => {
+            const collection = data.collections.find((col) => col.id === layerId);
+            const collectionLinks = collection?.links;
+            if (!collectionLinks) {
+                const msg = `Missing layer id or matching collection could not be found`;
+                Logger.logError(loggerCategory, msg);
+                throw new Error(msg);
+            }
+            const collectionLink = collectionLinks.find((link) => link.rel.includes("collection") && link.type === "application/json");
+            this._collectionUrl = collectionLink.href;
+        };
+        const layerIdMismatch = () => {
+            const msg = `Collection metadata and sub-layers id mismatch`;
+            Logger.logError(loggerCategory, msg);
+            throw new Error(msg);
+        };
+        let collectionMetadata;
+        let json = await this.fetchMetadata(this._settings.url);
+        if (json?.type === "FeatureCollection") {
+            // We landed on the items page, we need to look for the collection metadata url
+            if (Array.isArray(json.links)) {
+                const collectionLink = json.links.find((link) => link.rel.includes("collection") && link.type === "application/json");
+                this._collectionUrl = collectionLink.href;
+            }
+        }
+        else if (json.itemType === "feature") {
+            // We landed on a specific collection page.
+            collectionMetadata = json;
+            // Check if the collection id matches at least one sub-layer
+            if (this._settings.subLayers && this._settings.subLayers.length > 0) {
+                const subLayer = this._settings.subLayers.find((s) => s.id === collectionMetadata.id);
+                if (subLayer)
+                    layerId = subLayer.id;
+            }
+            else {
+                // No sub-layers were specified, defaults to collection id.
+                layerId = collectionMetadata.id;
+            }
+        }
+        else if (Array.isArray(json.collections)) {
+            // We landed in the "Collections" page
+            // Find to find the specified layer id among the available collections
+            readCollectionsPage(json);
+        }
+        else if (Array.isArray(json.links)) {
+            // This might be the main landing page
+            // We need to find the the "Collections" page
+            const collectionsLink = json.links.find((link) => link.rel.includes("data") && link.type === "application/json");
+            if (!collectionsLink) {
+                Logger.logError(loggerCategory, "Could not find collections link");
+                throw new ServerError(IModelStatus.ValidationFailed, "");
+            }
+            json = await this.fetchMetadata(collectionsLink.href);
+            if (Array.isArray(json.collections)) {
+                readCollectionsPage(json);
+            }
+        }
+        // Read collection metadata
+        if (!collectionMetadata)
+            collectionMetadata = await this.fetchMetadata(this._collectionUrl);
+        if (layerId !== undefined && layerId !== collectionMetadata.id) {
+            layerIdMismatch();
+        }
+        // Read cartographic range
+        if (Array.isArray(collectionMetadata?.extent?.spatial?.bbox)
+            && collectionMetadata.extent.spatial.bbox.length > 0
+            && collectionMetadata.extent.spatial.crs === this._itemsCrs) {
+            const firstBbox = collectionMetadata.extent.spatial?.bbox[0];
+            this.cartoRange = MapCartoRectangle.fromDegrees(firstBbox[0], firstBbox[1], firstBbox[2], firstBbox[3]);
+        }
+        // Read important links
+        let queryablesHref;
+        let itemsHref;
+        if (Array.isArray(collectionMetadata?.links)) {
+            // Items links (Mandatory)
+            const itemsLink = collectionMetadata.links.find((link) => link.rel.includes("items") && link.type === "application/geo+json");
+            itemsHref = itemsLink.href;
+            // Queryables link (Optional)
+            const queryablesLink = collectionMetadata.links.find((link) => link.rel.includes("queryables") && link.type === "application/schema+json");
+            queryablesHref = queryablesLink.href;
+        }
+        if (itemsHref)
+            this._itemsUrl = itemsHref;
+        else {
+            const msg = "Unable to find items link on collection";
+            Logger.logError(loggerCategory, msg);
+            throw new Error(msg);
+        }
+        if (queryablesHref)
+            this._queryables = await this.fetchMetadata(queryablesHref);
+        if (!this._forceTileMode) {
+            const status = await this.fetchAllItems();
+            if (status) {
+                await this.indexStaticData();
+            }
+        }
+        await this._defaultSymbol.initialize(); // images must be loaded upfront
+    }
+    async fetchMetadata(url) {
+        const tmpUrl = this.appendCustomParams(url);
+        const response = await this.makeRequest(tmpUrl);
+        return response.json();
+    }
+    async fetchAllItems() {
+        const urlObj = new URL(this._itemsUrl);
+        urlObj.searchParams.append("limit", `${this._limitParamMaxValue}`);
+        const url = this.appendCustomParams(urlObj.toString());
+        this._staticData = await this.fetchItems(url, this._staticModeFetchTimeout);
+        return this._staticData ? true : false;
+    }
+    async fetchItems(url, timeout) {
+        let data;
+        let success = true;
+        try {
+            const fetchBegin = Date.now();
+            let tmpUrl = this.appendCustomParams(url);
+            let response = await this.makeTileRequest(tmpUrl, timeout);
+            let json = await response.json();
+            data = json;
+            // Follow "next" link if any
+            let nextLink = json.links?.find((link) => link.rel === "next");
+            while (nextLink && (Date.now() - fetchBegin) < timeout && success) {
+                tmpUrl = this.appendCustomParams(nextLink.href);
+                response = await this.makeTileRequest(tmpUrl, this._staticModeFetchTimeout);
+                json = await response.json();
+                if (json?.features)
+                    data.features = this._staticData?.features ? [...this._staticData.features, ...json.features] : json.features;
+                else
+                    success = false;
+                nextLink = json.links?.find((link) => link.rel === "next");
+            }
+            if (Date.now() - fetchBegin >= this._staticModeFetchTimeout) {
+                // We ran out of time, let switch to tile mode
+                success = false;
+            }
+        }
+        catch (e) {
+            success = false;
+            if (e instanceof DOMException && e.name === "AbortError") {
+                Logger.logInfo(loggerCategory, "Request to fetch all features time out, switching to tile mode.");
+            }
+            else {
+                Logger.logError(loggerCategory, "Unknown error occurred when fetching OgcApiFeatures data.");
+            }
+        }
+        return success ? data : undefined;
+    }
+    // Read features range and build in-memory spatial index
+    async indexStaticData() {
+        // UGLY  IMPORT:
+        // flatbush only provides ECM modules, and since mocha is not very good with ECM modules,
+        // we need to have this special import, until we replace mocha with something else.
+        const flatbush = (await import("flatbush")).default;
+        let success = true;
+        try {
+            const datasetRange = new Range2d();
+            const buildPositionRange = (coords, range) => range.extendXY(coords[0], coords[1]);
+            const buildPositionArrayRange = (coords, range) => coords.forEach((position) => buildPositionRange(position, range));
+            const buildDoublePositionRange = (coords, range) => coords.forEach((position) => buildPositionArrayRange(position, range));
+            const buildTriplePositionRange = (coords, range) => coords.forEach((position) => buildDoublePositionRange(position, range));
+            const readGeomRange = (geom, range) => {
+                if (geom.type === "Point")
+                    buildPositionRange(geom.coordinates, range);
+                else if (geom.type === "LineString" || geom.type === "MultiPoint")
+                    buildPositionArrayRange(geom.coordinates, range);
+                else if (geom.type === "Polygon" || geom.type === "MultiLineString")
+                    buildDoublePositionRange(geom.coordinates, range);
+                else if (geom.type === "MultiPolygon")
+                    buildTriplePositionRange(geom.coordinates, range);
+            };
+            if (this._staticData && Array.isArray(this._staticData.features)) {
+                this._spatialIdx = new flatbush(this._staticData.features.length);
+                this._staticData.features.forEach((feature) => {
+                    try {
+                        if (feature.geometry.type === "LineString"
+                            || feature.geometry.type === "MultiLineString"
+                            || feature.geometry.type === "Point"
+                            || feature.geometry.type === "MultiPoint"
+                            || feature.geometry.type === "Polygon"
+                            || feature.geometry.type === "MultiPolygon") {
+                            readGeomRange(feature.geometry, datasetRange);
+                            this._spatialIdx?.add(datasetRange.xLow, datasetRange.yLow, datasetRange.xHigh, datasetRange.yHigh);
+                            datasetRange.setNull();
+                        }
+                        else if (feature.geometry.type === "GeometryCollection") {
+                            feature.geometry.geometries.forEach((geom) => {
+                                readGeomRange(geom, datasetRange);
+                                this._spatialIdx?.add(datasetRange.xLow, datasetRange.yLow, datasetRange.xHigh, datasetRange.yHigh);
+                            });
+                            datasetRange.setNull();
+                        }
+                    }
+                    catch (e) {
+                        Logger.logInfo(loggerCategory, `Unknown error occurred indexing feature: ${e.message}`);
+                        success = false;
+                    }
+                });
+                if (success) {
+                    this._spatialIdx.finish();
+                }
+            }
+        }
+        catch (_e) {
+            Logger.logError(loggerCategory, "Unknown error occurred when index static data");
+            success = false;
+        }
+        return success;
+    }
+    get tileSize() { return 512; }
+    // 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 "";
+    }
+    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
+    computeTileWorld2CanvasTransform(row, column, zoomLevel) {
+        const tileExtentWorld4326 = this.getEPSG4326Extent(row, column, zoomLevel);
+        const worldTileWidth = tileExtentWorld4326.longitudeRight - tileExtentWorld4326.longitudeLeft;
+        const worldTileHeight = tileExtentWorld4326.latitudeTop - tileExtentWorld4326.latitudeBottom;
+        const canvasTileWidth = this.tileSize;
+        const canvasTileHeight = this.tileSize;
+        const world2CanvasRatioX = canvasTileWidth / worldTileWidth;
+        const world2CanvasRatioY = canvasTileHeight / worldTileHeight;
+        const worldTileOrigin = Point3d.create(tileExtentWorld4326.longitudeLeft, tileExtentWorld4326.latitudeBottom);
+        const worldTileExtent = Point3d.create(tileExtentWorld4326.longitudeRight, tileExtentWorld4326.latitudeTop);
+        const canvasTileOriginOffset = worldTileOrigin.clone();
+        const canvasTileExtentOffset = worldTileExtent.clone();
+        canvasTileOriginOffset.x *= world2CanvasRatioX;
+        canvasTileOriginOffset.y *= world2CanvasRatioY;
+        canvasTileExtentOffset.x *= world2CanvasRatioX;
+        canvasTileExtentOffset.y *= world2CanvasRatioY;
+        const xTranslate = -1 * canvasTileOriginOffset.x;
+        // Canvas origin is upper left corner, so we need to flip the y axis
+        const yTranslate = canvasTileExtentOffset.y; // y-axis flip
+        const yWorld2CanvasRatio = -1 * world2CanvasRatioY; // y-axis flip
+        const matrix = Matrix4d.createTranslationAndScaleXYZ(xTranslate, yTranslate, 0, world2CanvasRatioX, yWorld2CanvasRatio, 1);
+        return matrix.asTransform;
+    }
+    async loadTile(row, column, zoomLevel) {
+        const extent4326 = this.getEPSG4326Extent(row, column, zoomLevel);
+        let data;
+        if (this.staticMode) {
+            // Static data mode
+            const filteredData = { type: "FeatureCollection", features: [] };
+            this._spatialIdx?.search(extent4326.longitudeLeft, extent4326.latitudeBottom, extent4326.longitudeRight, extent4326.latitudeTop, (index) => {
+                filteredData.features.push(this._staticData.features[index]);
+                return true;
+            });
+            data = filteredData;
+        }
+        else {
+            // Tiled data mode
+            const extent4326Str = this.getEPSG4326TileExtentString(row, column, zoomLevel, false);
+            const urlObj = new URL(this._itemsUrl);
+            urlObj.searchParams.append("bbox", `${extent4326Str}`);
+            urlObj.searchParams.append("bbox-crs", this._itemsCrs);
+            urlObj.searchParams.append("limit", `${this._limitParamMaxValue}`);
+            const url = this.appendCustomParams(urlObj.toString());
+            try {
+                data = await this.fetchItems(url, this._tileModeFetchTimeout);
+            }
+            catch (_e) {
+            }
+            if (!data) {
+                Logger.logError(loggerCategory, "Could not fetch OgcApiFeatures data.");
+            }
+        }
+        if (!data || !Array.isArray(data.features) || data.features.length === 0) {
+            Logger.logInfo(loggerCategory, `No data to render for tile (${zoomLevel}/${row}/${column}).`);
+        }
+        // Rendering starts here
+        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;
+        }
+        try {
+            // Compute transform if CoordinatesQuantization is not supported by service
+            const transfo = this.computeTileWorld2CanvasTransform(row, column, zoomLevel);
+            if (!transfo) {
+                Logger.logError(loggerCategory, `Could not compute data transformation for tile (${zoomLevel}/${row}/${column})`);
+            }
+            // Create the renderer
+            // Instead of passing a Transform oject to the render, it should be possible
+            // instead to set the Transform directly on the Canvas, when I tried the display was incorrect, floating point issue?
+            // const transfoRow = transfo!.toRows();
+            // ctx.setTransform(transfoRow[0][0], transfoRow[1][0], transfoRow[0][1], transfoRow[1][1], transfoRow[0][3], transfoRow[1][3]);
+            const symbRenderer = ArcGisSymbologyCanvasRenderer.create(this._renderer, this._defaultSymbol);
+            const renderer = new FeatureCanvasRenderer(ctx, symbRenderer, transfo);
+            const featureReader = new OgcApiFeaturesReader();
+            await featureReader.readAndRender(data, renderer);
+            if (this._drawDebugInfo)
+                this.drawTileDebugInfo(row, column, zoomLevel, ctx);
+        }
+        catch (e) {
+            Logger.logError(loggerCategory, `Exception occurred while loading tile (${zoomLevel}/${row}/${column}) : ${e}`);
+        }
+        try {
+            return this.createImageSourceFromDataURL(canvas.toDataURL("image/png"), ImageSourceFormat.Png);
+        }
+        catch (e) {
+            Logger.logError(loggerCategory, `Exception occurred while rendering tile (${zoomLevel}/${row}/${column}) : ${e}.`);
+        }
+        return undefined;
+    }
+    createImageSourceFromDataURL(dataUrl, format) {
+        if (!dataUrl)
+            return undefined;
+        const dataStartPos = dataUrl.indexOf(dataUrlHeaderToken) + dataUrlHeaderToken.length;
+        if (dataStartPos < 0)
+            return undefined;
+        const base64Png = dataUrl.substring(dataStartPos);
+        return new ImageSource(base64StringToUint8Array(base64Png), format);
+    }
+    async getFeatureInfo(featureInfos, quadId, carto, _tree, hit, options) {
+        const tileExtent = this.getEPSG4326Extent(quadId.row, quadId.column, quadId.level);
+        const tilePixelSizeX = (tileExtent.longitudeRight - tileExtent.longitudeLeft) / this.tileSize;
+        const tilePixelSizeY = (tileExtent.latitudeTop - tileExtent.latitudeBottom) / this.tileSize;
+        const tolerancePixel = options?.tolerance ?? 7;
+        const toleranceWorldX = tilePixelSizeX * tolerancePixel;
+        const toleranceWorldY = tilePixelSizeY * tolerancePixel;
+        // Note: We used to pass a single point as the query 'geometry' and leverage the 'distance' parameter, turns
+        // out that approach was a lot slower on some server compared to using a single envelope.
+        const bbox = {
+            longitudeLeft: carto.longitudeDegrees - toleranceWorldX, latitudeBottom: carto.latitudeDegrees - toleranceWorldY,
+            longitudeRight: carto.longitudeDegrees + toleranceWorldX, latitudeTop: carto.latitudeDegrees + toleranceWorldY,
+        };
+        const bboxStr = this.getEPSG4326ExtentString(bbox, false);
+        const urlObj = new URL(this._itemsUrl);
+        urlObj.searchParams.append("bbox", `${bboxStr}`);
+        urlObj.searchParams.append("bbox-crs", this._itemsCrs);
+        urlObj.searchParams.append("limit", `${this._limitParamMaxValue}`);
+        const url = this.appendCustomParams(urlObj.toString());
+        let data;
+        try {
+            data = await this.fetchItems(url, this._tileModeFetchTimeout);
+        }
+        catch (_e) {
+        }
+        if (!data) {
+            Logger.logError(loggerCategory, "Could not fetch OgcApiFeatures data.");
+        }
+        const featureReader = new OgcApiFeaturesReader();
+        await featureReader.readFeatureInfo({
+            collection: data,
+            layerSettings: this._settings,
+            queryables: this._queryables,
+            geomRenderer: new FeatureGraphicsRenderer({ viewport: hit.viewport, crs: "wgs84" })
+        }, featureInfos);
+    }
+}
+//# sourceMappingURL=OgcApiFeaturesProvider.js.map