@igo2/geo 19.0.0-next.7 → 19.0.0-next.9

package/fesm2022/igo2-geo.mjs

@@ -3036,7 +3036,8 @@ const jsonRegex = new RegExp(/(.*)?json(.*)?/gi);
  * @param ogcFilters  OgcFiltersOptions
  * @returns A string representing the datasource options, based on filter and views
  */
-function buildUrl(options, extent, proj, ogcFilters, randomParam) {
+function buildUrl(options, extent, proj, randomParam) {
+    const ogcFilters = options.ogcFilters;
     const paramsWFS = options.paramsWFS;
     const queryStringValues = formatWFSQueryString(options, undefined, options.paramsWFS.srsName);
     let igoFilters;
@@ -3367,9 +3368,8 @@ class WFSDataSource extends DataSource {
         const currentExtent = extent
             ? olproj.transformExtent(extent, projection, wfsProj)
             : undefined;
-        const ogcFilters = this.ogcFilters;
         paramsWFS.srsName = paramsWFS.srsName || projection.getCode();
-        let url = buildUrl(this.options, currentExtent, wfsProj, ogcFilters);
+        let url = buildUrl(this.options, currentExtent, wfsProj);
         // Exportation want to fetch without extent/bbox restrictions
         if (!extent && url.includes('bbox')) {
             const [baseUrl, params] = url.split('?');
@@ -5649,10 +5649,8 @@ class VectorLayer extends Layer {
     geoDBService;
     layerDBService;
     type = 'vector';
-    previousLoadExtent;
-    previousLoadResolution;
-    previousOgcFilters;
-    xhrAccumulator = [];
+    lastRequest;
+    ongoingRequests = [];
     watcher;
     trackFeatureListenerId;
     get browsable() {
@@ -5742,12 +5740,12 @@ class VectorLayer extends Layer {
             if (wfsOptions?.type === 'wfs' &&
                 (wfsOptions.params || wfsOptions.paramsWFS)) {
                 loader = (extent, resolution, proj, success, failure) => {
-                    this.customWFSLoader(vectorSource, wfsOptions, this.authInterceptor, extent, resolution, proj, success, failure);
+                    this.customWFSLoader(vectorSource, wfsOptions, extent, resolution, proj, success, failure);
                 };
             }
             else {
-                loader = (extent, resolution, proj, success, failure) => {
-                    this.customLoader(vectorSource, url, extent, resolution, proj, success, failure);
+                loader = (extent, _resolution, proj, success, failure) => {
+                    this.customLoader(vectorSource, url, extent, proj, success, failure);
                 };
             }
             if (loader) {
@@ -5755,7 +5753,7 @@ class VectorLayer extends Layer {
             }
         }
         else if (this.options.idbInfo?.storeToIdb && this.geoDBService) {
-            const idbLoader = (extent, resolution, proj, success, failure) => {
+            const idbLoader = (extent, _resolution, proj, success, failure) => {
                 this.customIDBLoader(vectorSource, olOptions.id, extent, proj, success, failure);
             };
             if (idbLoader) {
@@ -5893,7 +5891,7 @@ class VectorLayer extends Layer {
             this.watcher.unsubscribe();
         }
         else {
-            this.watcher.subscribe(() => void 1);
+            this.watcher.subscribe(() => void 0);
         }
         super.init(map);
     }
@@ -5935,7 +5933,6 @@ class VectorLayer extends Layer {
      * @internal
      * @param vectorSource the vector source to be created
      * @param options olOptions from source
-     * @param interceptor the interceptor of the data
      * @param extent the extent of the requested data
      * @param resolution the current resolution
      * @param proj the projection to retrieve the data
@@ -5943,45 +5940,57 @@ class VectorLayer extends Layer {
      * @param failure failure callback
      * @param randomParam random parameter to ensure cache is not causing problems in retrieving new data
      */
-    customWFSLoader(vectorSource, options, interceptor, extent, resolution, proj, success, failure, randomParam) {
-        {
-            const paramsWFS = options.paramsWFS;
-            const wfsProj = paramsWFS.srsName
-                ? new olProjection({ code: paramsWFS.srsName })
-                : proj;
-            const currentExtent = olproj.transformExtent(extent, proj, wfsProj);
-            const ogcFilters = options.ogcFilters;
-            if ((this.previousLoadExtent &&
-                this.previousLoadExtent !== currentExtent) ||
-                (this.previousLoadResolution &&
-                    this.previousLoadResolution !== resolution) ||
-                (this.previousOgcFilters && this.previousOgcFilters !== ogcFilters)) {
-                vectorSource.removeLoadedExtent(this.previousLoadExtent);
-                for (const xhr of this.xhrAccumulator) {
-                    xhr.abort();
-                }
-            }
-            this.previousLoadExtent = currentExtent;
-            this.previousLoadResolution = resolution;
-            this.previousOgcFilters = ogcFilters;
-            paramsWFS.srsName = paramsWFS.srsName || proj.getCode();
-            const url = buildUrl(options, currentExtent, wfsProj, ogcFilters, randomParam);
-            let startIndex = 0;
-            if (paramsWFS.version === '2.0.0' &&
-                paramsWFS.maxFeatures > defaultMaxFeatures) {
-                const nbOfFeature = 1000;
-                while (startIndex < paramsWFS.maxFeatures) {
-                    let alteredUrl = url.replace('count=' + paramsWFS.maxFeatures, 'count=' + nbOfFeature);
-                    alteredUrl = alteredUrl.replace('startIndex=0', '0');
-                    alteredUrl += '&startIndex=' + startIndex;
-                    alteredUrl.replace(/&&/g, '&');
-                    this.getFeatures(vectorSource, currentExtent, wfsProj, proj, alteredUrl, success, failure);
-                    startIndex += nbOfFeature;
-                }
-            }
-            else {
-                this.getFeatures(vectorSource, currentExtent, wfsProj, proj, url, success, failure);
-            }
+    customWFSLoader(vectorSource, options, extent, resolution, proj, success, failure, randomParam) {
+        const paramsWFS = options.paramsWFS;
+        const wfsProj = this.getProjection(proj, paramsWFS);
+        const currentExtent = olproj.transformExtent(extent, proj, wfsProj);
+        if (this.lastRequest &&
+            (this.lastRequest.extent !== currentExtent ||
+                this.lastRequest.resolution !== resolution)) {
+            this.abortRequests(vectorSource);
+        }
+        const url = buildUrl(options, currentExtent, wfsProj, randomParam);
+        const request = {
+            xhr: undefined,
+            extent,
+            resolution
+        };
+        const readOptions = {
+            dataProjection: wfsProj,
+            featureProjection: proj
+        };
+        if (paramsWFS.version === '2.0.0' &&
+            paramsWFS.maxFeatures > defaultMaxFeatures) {
+            this.batchGetFeatures(url, request, vectorSource, paramsWFS, readOptions, success, failure);
+        }
+        else {
+            this.getFeatures(url, request, vectorSource, readOptions, success, failure);
+        }
+    }
+    abortRequests(vectorSource) {
+        vectorSource.removeLoadedExtent(this.lastRequest.extent);
+        for (const request of this.ongoingRequests) {
+            request.xhr?.abort();
+            this.removeRequest(request);
+        }
+    }
+    getProjection(proj, params) {
+        const newProj = params.srsName
+            ? new olProjection({ code: params.srsName })
+            : proj;
+        params.srsName = newProj.getCode();
+        return newProj;
+    }
+    batchGetFeatures(url, request, vectorSource, paramsWFS, readOptions, success, failure) {
+        const nbOfFeature = 1000;
+        let startIndex = 0;
+        while (startIndex < paramsWFS.maxFeatures) {
+            let alteredUrl = url.replace('count=' + paramsWFS.maxFeatures, 'count=' + nbOfFeature);
+            alteredUrl = alteredUrl.replace('startIndex=0', '0');
+            alteredUrl += '&startIndex=' + startIndex;
+            alteredUrl.replace(/&&/g, '&');
+            this.getFeatures(alteredUrl, request, vectorSource, readOptions, success, failure);
+            startIndex += nbOfFeature;
         }
     }
     /**
@@ -5995,7 +6004,7 @@ class VectorLayer extends Layer {
      * @param success success callback
      * @param failure failure callback
      */
-    getFeatures(vectorSource, extent, dataProjection, featureProjection, url, success, failure) {
+    getFeatures(url, request, vectorSource, readOptions, success, failure) {
         const xhr = new XMLHttpRequest();
         const alteredUrlWithKeyAuth = this.authInterceptor.alterUrlWithKeyAuth(url);
         let modifiedUrl = url;
@@ -6007,7 +6016,8 @@ class VectorLayer extends Layer {
             this.authInterceptor.interceptXhr(xhr, modifiedUrl);
         }
         const onError = () => {
-            vectorSource.removeLoadedExtent(extent);
+            vectorSource.removeLoadedExtent(request.extent);
+            this.removeRequest(request);
             failure();
         };
         xhr.onerror = onError;
@@ -6015,10 +6025,7 @@ class VectorLayer extends Layer {
             if (xhr.status === 200 && xhr.responseText.length > 0) {
                 const features = vectorSource
                     .getFormat()
-                    .readFeatures(xhr.responseText, {
-                    dataProjection,
-                    featureProjection
-                });
+                    .readFeatures(xhr.responseText, readOptions);
                 if (features) {
                     vectorSource.addFeatures(features);
                     success(features);
@@ -6026,24 +6033,35 @@ class VectorLayer extends Layer {
                 else {
                     success([]);
                 }
+                this.removeRequest(request);
             }
             else {
                 onError();
             }
         };
-        this.xhrAccumulator.push(xhr);
+        request.xhr = xhr;
+        this.lastRequest = request;
+        this.ongoingRequests.push(request);
         xhr.send();
     }
+    removeRequest(request) {
+        if (request === this.lastRequest) {
+            this.lastRequest = undefined;
+        }
+        const index = this.ongoingRequests.indexOf(request);
+        if (index > -1) {
+            this.ongoingRequests.splice(index, 1);
+        }
+    }
     /**
      * Custom loader for vector layer.
      * @internal
      * @param vectorSource the vector source to be created
      * @param url the url string or function to retrieve the data
      * @param extent the extent of the requested data
-     * @param resolution the current resolution
      * @param projection the projection to retrieve the data
      */
-    customLoader(vectorSource, url, extent, resolution, projection, success, failure) {
+    customLoader(vectorSource, url, extent, projection, success, failure) {
         const xhr = new XMLHttpRequest();
         let modifiedUrl = url;
         if (typeof url !== 'function') {
@@ -21203,15 +21221,7 @@ class OptionsApiService extends OptionsService {
         const request = this.http.get(this.urlApi, {
             params
         });
-        return request.pipe(map((res) => {
-            if (!res || !res.sourceOptions) {
-                return {};
-            }
-            if (res.layerOptions) {
-                res.sourceOptions._layerOptionsFromSource = res.layerOptions;
-            }
-            return res.sourceOptions;
-        }));
+        return request.pipe(map((res) => this.handleSourceOptions(res)));
     }
     getArcgisRestOptions(baseOptions, detailedContextUri) {
         if (!this.urlApi) {
@@ -21230,15 +21240,20 @@ class OptionsApiService extends OptionsService {
         const request = this.http.get(this.urlApi, {
             params
         });
-        return request.pipe(map((res) => {
-            if (!res || !res.sourceOptions) {
-                return {};
-            }
-            if (res.layerOptions) {
-                res.sourceOptions._layerOptionsFromSource = res.layerOptions;
-            }
-            return res.sourceOptions;
-        }));
+        return request.pipe(map((res) => this.handleSourceOptions(res)));
+    }
+    handleSourceOptions(res) {
+        if (!res || !res.sourceOptions) {
+            return {};
+        }
+        if (res.layerOptions) {
+            res.sourceOptions._layerOptionsFromSource = res.layerOptions;
+        }
+        else {
+            const { sourceOptions: _1, layerOptions: _2, ...restOptions } = res;
+            res.sourceOptions._layerOptionsFromSource = restOptions;
+        }
+        return res.sourceOptions;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: OptionsApiService, deps: [{ token: i1.HttpClient }, { token: 'options' }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: OptionsApiService, providedIn: 'root' });
@@ -37556,7 +37571,7 @@ class EditionWorkspaceService {
     refreshMap(layer, map) {
         const wfsOlLayer = layer.dataSource.ol;
         const loader = (extent, resolution, proj, success, failure) => {
-            layer.customWFSLoader(layer.ol.getSource(), layer.options.sourceOptions, this.authInterceptor, extent, resolution, proj, success, failure, true);
+            layer.customWFSLoader(layer.ol.getSource(), layer.options.sourceOptions, extent, resolution, proj, success, failure, true);
         };
         wfsOlLayer.setLoader(loader);
         wfsOlLayer.refresh();