@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/datasource/shared/datasources/websocket-datasource.mjs

@@ -0,0 +1,56 @@
+import { FeatureDataSource } from './feature-datasource';
+export class WebSocketDataSource extends FeatureDataSource {
+    ws;
+    createOlSource() {
+        this.createWebSocket();
+        this.options.format = this.getSourceFormatFromOptions(this.options);
+        return super.createOlSource();
+    }
+    createWebSocket() {
+        this.ws = new WebSocket(this.options.url);
+        this.ws.onmessage = this.onMessage.bind(this);
+        if (this.options.onclose) {
+            this.ws.onclose = this.onClose.bind(this);
+        }
+        if (this.options.onerror) {
+            this.ws.onerror = this.onError.bind(this);
+        }
+        if (this.options.onopen) {
+            this.ws.onopen = this.onOpen.bind(this);
+        }
+    }
+    onMessage(event) {
+        const featureAdded = this.options.format.readFeature(event.data);
+        switch (this.options.onmessage) {
+            case 'update': {
+                // ol don't add if same ID
+                const featureToRemove = this.ol.getFeatureById(featureAdded.getId());
+                if (featureToRemove) {
+                    this.ol.removeFeature(featureToRemove);
+                }
+                this.ol.addFeature(featureAdded);
+                break;
+            }
+            case 'delete':
+                this.ol.clear(true);
+                this.ol.addFeature(featureAdded);
+                break;
+            case 'add':
+            default:
+                this.ol.addFeature(featureAdded);
+        }
+    }
+    onClose() {
+        // thrown message to user
+    }
+    onError() {
+        // thrown message to user
+    }
+    onOpen() {
+        // thrown message to user ?
+    }
+    onUnwatch() {
+        this.ws.close();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datasource/shared/datasources/wfs-datasource.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ZzLWRhdGFzb3VyY2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvZGF0YXNvdXJjZS9zaGFyZWQvZGF0YXNvdXJjZXMvd2ZzLWRhdGFzb3VyY2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IE9nY0ZpbHRlcnNPcHRpb25zIH0gZnJvbSAnLi4vLi4vLi4vZmlsdGVyJztcbmltcG9ydCB0eXBlIHsgRmVhdHVyZURhdGFTb3VyY2VPcHRpb25zIH0gZnJvbSAnLi9mZWF0dXJlLWRhdGFzb3VyY2UuaW50ZXJmYWNlJztcblxuZXhwb3J0IGludGVyZmFjZSBXRlNEYXRhU291cmNlT3B0aW9ucyBleHRlbmRzIEZlYXR1cmVEYXRhU291cmNlT3B0aW9ucyB7XG4gIC8vIHR5cGU/OiAnd2ZzJztcbiAgcGFyYW1zOiBXRlNEYXRhU291cmNlT3B0aW9uc1BhcmFtczsgLy8gVXNlZCBieSB1c2VyXG4gIHBhcmFtc1dGUz86IFdGU0RhdGFTb3VyY2VPcHRpb25zUGFyYW1zOyAvLyBVc2VkIGJ5IGNvZGVcbiAgdXJsV2ZzPzogc3RyaW5nOyAvLyBVc2VkIGJ5IGNvZGVcbiAgb2djRmlsdGVycz86IE9nY0ZpbHRlcnNPcHRpb25zO1xufVxuXG4vLyBUT0RPOiBBcmUgdGhvc2UgV0ZTIHByb3RvY29sIHBhcmFtcyBvciBzb21ldGhpbmcgZWxzZT8gVGhpcyBpcyBub3QgY2xlYXJcbmV4cG9ydCBpbnRlcmZhY2UgV0ZTRGF0YVNvdXJjZU9wdGlvbnNQYXJhbXMge1xuICB2ZXJzaW9uPzogc3RyaW5nO1xuICBmZWF0dXJlVHlwZXM6IHN0cmluZztcbiAgZmllbGROYW1lR2VvbWV0cnk6IHN0cmluZztcbiAgbWF4RmVhdHVyZXM/OiBudW1iZXI7XG4gIG91dHB1dEZvcm1hdDogc3RyaW5nO1xuICBvdXRwdXRGb3JtYXREb3dubG9hZD86IHN0cmluZztcbiAgc3JzTmFtZT86IHN0cmluZztcbiAgeG1sRmlsdGVyPzogc3RyaW5nO1xufVxuIl19

package/esm2022/lib/datasource/shared/datasources/wfs-datasource.mjs

@@ -0,0 +1,137 @@
+import * as OlLoadingStrategy from 'ol/loadingstrategy';
+import * as OlProj from 'ol/proj';
+import olProjection from 'ol/proj/Projection';
+import olSourceVector from 'ol/source/Vector';
+import { catchError, map } from 'rxjs';
+import { OgcFilterWriter } from '../../../filter/shared/ogc-filter';
+import { DataSource } from './datasource';
+import { buildUrl, checkWfsParams, defaultFieldNameGeometry, defaultMaxFeatures, getFormatFromOptions } from './wms-wfs.utils';
+export class WFSDataSource extends DataSource {
+    options;
+    wfsService;
+    authInterceptor;
+    set ogcFilters(value) {
+        this.options.ogcFilters = value;
+    }
+    get ogcFilters() {
+        return this.options.ogcFilters;
+    }
+    get saveableOptions() {
+        const baseOptions = super.saveableOptions;
+        return {
+            ...baseOptions,
+            params: this.options.params
+        };
+    }
+    constructor(options, wfsService, authInterceptor) {
+        super(checkWfsParams(options, 'wfs'));
+        this.options = options;
+        this.wfsService = wfsService;
+        this.authInterceptor = authInterceptor;
+        const ogcFilters = this.options
+            .ogcFilters;
+        const fieldNameGeometry = this.options.paramsWFS.fieldNameGeometry || defaultFieldNameGeometry;
+        const ogcFilterWriter = new OgcFilterWriter();
+        this.options.ogcFilters =
+            ogcFilterWriter.defineOgcFiltersDefaultOptions(ogcFilters, fieldNameGeometry);
+        if (this.options.ogcFilters.enabled &&
+            this.options.ogcFilters.editable &&
+            (options.sourceFields || []).filter((sf) => !sf.values).length > 0) {
+            this.wfsService.getSourceFieldsFromWFS(this.options);
+        }
+        if (ogcFilters?.pushButtons) {
+            ogcFilters.pushButtons.selectorType = 'pushButton';
+        }
+        if (ogcFilters?.checkboxes) {
+            ogcFilters.checkboxes.selectorType = 'checkbox';
+        }
+        if (ogcFilters?.radioButtons) {
+            ogcFilters.radioButtons.selectorType = 'radioButton';
+        }
+        if (ogcFilters?.select) {
+            ogcFilters.select.selectorType = 'select';
+        }
+        if (ogcFilters?.autocomplete) {
+            ogcFilters.autocomplete.selectorType = 'autocomplete';
+        }
+        this.setOgcFilters(this.options.ogcFilters, true);
+    }
+    createOlSource() {
+        const vectorSource = new olSourceVector({
+            format: getFormatFromOptions(this.options),
+            strategy: OlLoadingStrategy.bbox
+        });
+        return vectorSource;
+    }
+    setOgcFilters(ogcFilters, triggerEvent = false) {
+        this.ogcFilters = ogcFilters;
+        if (triggerEvent) {
+            this.ol.notify('ogcFilters', this.ogcFilters);
+        }
+    }
+    onUnwatch() {
+        // empty
+    }
+    fetchFeatures({ extent, projection, httpClient }) {
+        const paramsWFS = this.options.paramsWFS;
+        const wfsProj = paramsWFS.srsName
+            ? new olProjection({ code: paramsWFS.srsName })
+            : projection;
+        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);
+        // Exportation want to fetch without extent/bbox restrictions
+        if (!extent && url.includes('bbox')) {
+            const [baseUrl, params] = url.split('?');
+            const paramSegments = params.split('&');
+            const paramsWithoutBbox = paramSegments.filter((segment) => !segment.includes('bbox'));
+            url = `${baseUrl}?${paramsWithoutBbox.join('&')}`;
+        }
+        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, '&');
+                return this._fetchFeatures(wfsProj, alteredUrl, {
+                    extent: currentExtent,
+                    projection,
+                    httpClient
+                }).pipe(map((res) => {
+                    startIndex += nbOfFeature;
+                    return res;
+                }));
+            }
+        }
+        else {
+            return this._fetchFeatures(wfsProj, url, {
+                extent: currentExtent,
+                projection,
+                httpClient
+            });
+        }
+    }
+    _fetchFeatures(featureProjection, url, { extent, projection, httpClient }) {
+        return httpClient.get(url, { responseType: 'text' }).pipe(map((response) => {
+            return this._parseXmlFeatures(response, projection, featureProjection);
+        }), catchError((e) => {
+            if (extent)
+                this.ol.removeLoadedExtent(extent);
+            throw e;
+        }));
+    }
+    _parseXmlFeatures(xml, dataProjection, featureProjection) {
+        const features = this.ol.getFormat().readFeatures(xml, {
+            dataProjection,
+            featureProjection
+        });
+        return features;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wfs-datasource.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/datasource/shared/datasources/wfs-datasource.ts"],"names":[],"mappings":"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","sourcesContent":["import type { HttpClient } from '@angular/common/http';\n\nimport { AuthInterceptor } from '@igo2/auth';\n\nimport OlFeature from 'ol/Feature';\nimport { Extent } from 'ol/extent';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\nimport * as OlLoadingStrategy from 'ol/loadingstrategy';\nimport * as OlProj from 'ol/proj';\nimport olProjection from 'ol/proj/Projection';\nimport olSourceVector from 'ol/source/Vector';\n\nimport { Observable, catchError, map } from 'rxjs';\n\nimport { OgcFilterWriter } from '../../../filter/shared/ogc-filter';\nimport {\n  OgcFilterableDataSourceOptions,\n  OgcFiltersOptions\n} from '../../../filter/shared/ogc-filter.interface';\nimport { DataSource } from './datasource';\nimport { WFSDataSourceOptions } from './wfs-datasource.interface';\nimport { WFSService } from './wfs.service';\nimport {\n  buildUrl,\n  checkWfsParams,\n  defaultFieldNameGeometry,\n  defaultMaxFeatures,\n  getFormatFromOptions\n} from './wms-wfs.utils';\n\ninterface FetchFeatureOptions {\n  extent: Extent;\n  projection: olProjection;\n  httpClient: HttpClient;\n}\n\nexport class WFSDataSource extends DataSource {\n  declare public ol: olSourceVector;\n\n  set ogcFilters(value: OgcFiltersOptions) {\n    (this.options as OgcFilterableDataSourceOptions).ogcFilters = value;\n  }\n  get ogcFilters(): OgcFiltersOptions {\n    return (this.options as OgcFilterableDataSourceOptions).ogcFilters;\n  }\n\n  get saveableOptions(): Partial<WFSDataSourceOptions> {\n    const baseOptions = super.saveableOptions;\n    return {\n      ...baseOptions,\n      params: this.options.params\n    };\n  }\n\n  constructor(\n    public options: WFSDataSourceOptions,\n    protected wfsService: WFSService,\n    private authInterceptor?: AuthInterceptor\n  ) {\n    super(checkWfsParams(options, 'wfs'));\n\n    const ogcFilters = (this.options as OgcFilterableDataSourceOptions)\n      .ogcFilters;\n    const fieldNameGeometry =\n      this.options.paramsWFS.fieldNameGeometry || defaultFieldNameGeometry;\n    const ogcFilterWriter = new OgcFilterWriter();\n    (this.options as OgcFilterableDataSourceOptions).ogcFilters =\n      ogcFilterWriter.defineOgcFiltersDefaultOptions(\n        ogcFilters,\n        fieldNameGeometry\n      );\n    if (\n      (this.options as OgcFilterableDataSourceOptions).ogcFilters.enabled &&\n      (this.options as OgcFilterableDataSourceOptions).ogcFilters.editable &&\n      (options.sourceFields || []).filter((sf) => !sf.values).length > 0\n    ) {\n      this.wfsService.getSourceFieldsFromWFS(this.options);\n    }\n\n    if (ogcFilters?.pushButtons) {\n      ogcFilters.pushButtons.selectorType = 'pushButton';\n    }\n    if (ogcFilters?.checkboxes) {\n      ogcFilters.checkboxes.selectorType = 'checkbox';\n    }\n    if (ogcFilters?.radioButtons) {\n      ogcFilters.radioButtons.selectorType = 'radioButton';\n    }\n    if (ogcFilters?.select) {\n      ogcFilters.select.selectorType = 'select';\n    }\n    if (ogcFilters?.autocomplete) {\n      ogcFilters.autocomplete.selectorType = 'autocomplete';\n    }\n\n    this.setOgcFilters(\n      (this.options as OgcFilterableDataSourceOptions).ogcFilters,\n      true\n    );\n  }\n\n  protected createOlSource(): olSourceVector {\n    const vectorSource = new olSourceVector({\n      format: getFormatFromOptions(this.options),\n      strategy: OlLoadingStrategy.bbox\n    });\n    return vectorSource;\n  }\n\n  setOgcFilters(ogcFilters: OgcFiltersOptions, triggerEvent = false) {\n    this.ogcFilters = ogcFilters;\n    if (triggerEvent) {\n      this.ol.notify('ogcFilters', this.ogcFilters);\n    }\n  }\n\n  public onUnwatch() {\n    // empty\n  }\n\n  fetchFeatures({\n    extent,\n    projection,\n    httpClient\n  }: FetchFeatureOptions): Observable<OlFeature<OlGeometry>[]> {\n    const paramsWFS = this.options.paramsWFS;\n    const wfsProj = paramsWFS.srsName\n      ? new olProjection({ code: paramsWFS.srsName })\n      : projection;\n\n    const currentExtent = extent\n      ? OlProj.transformExtent(extent, projection, wfsProj)\n      : undefined;\n    const ogcFilters = this.ogcFilters;\n\n    paramsWFS.srsName = paramsWFS.srsName || projection.getCode();\n    let url = buildUrl(this.options, currentExtent, wfsProj, ogcFilters);\n\n    // Exportation want to fetch without extent/bbox restrictions\n    if (!extent && url.includes('bbox')) {\n      const [baseUrl, params] = url.split('?');\n      const paramSegments = params.split('&');\n      const paramsWithoutBbox = paramSegments.filter(\n        (segment) => !segment.includes('bbox')\n      );\n      url = `${baseUrl}?${paramsWithoutBbox.join('&')}`;\n    }\n\n    let startIndex = 0;\n    if (\n      paramsWFS.version === '2.0.0' &&\n      paramsWFS.maxFeatures > defaultMaxFeatures\n    ) {\n      const nbOfFeature = 1000;\n      while (startIndex < paramsWFS.maxFeatures) {\n        let alteredUrl = url.replace(\n          'count=' + paramsWFS.maxFeatures,\n          'count=' + nbOfFeature\n        );\n        alteredUrl = alteredUrl.replace('startIndex=0', '0');\n        alteredUrl += '&startIndex=' + startIndex;\n        alteredUrl.replace(/&&/g, '&');\n\n        return this._fetchFeatures(wfsProj, alteredUrl, {\n          extent: currentExtent,\n          projection,\n          httpClient\n        }).pipe(\n          map((res) => {\n            startIndex += nbOfFeature;\n            return res;\n          })\n        );\n      }\n    } else {\n      return this._fetchFeatures(wfsProj, url, {\n        extent: currentExtent,\n        projection,\n        httpClient\n      });\n    }\n  }\n\n  private _fetchFeatures(\n    featureProjection: olProjection,\n    url: string,\n    { extent, projection, httpClient }: FetchFeatureOptions\n  ): Observable<OlFeature<OlGeometry>[]> {\n    return httpClient.get(url, { responseType: 'text' }).pipe(\n      map((response) => {\n        return this._parseXmlFeatures(response, projection, featureProjection);\n      }),\n      catchError((e) => {\n        if (extent) this.ol.removeLoadedExtent(extent);\n        throw e;\n      })\n    );\n  }\n\n  private _parseXmlFeatures(\n    xml: string,\n    dataProjection: olProjection,\n    featureProjection: olProjection\n  ): OlFeature<OlGeometry>[] {\n    const features = this.ol.getFormat().readFeatures(xml, {\n      dataProjection,\n      featureProjection\n    }) as OlFeature<OlGeometry>[];\n    return features;\n  }\n}\n"]}

package/esm2022/lib/datasource/shared/datasources/wfs.service.mjs

@@ -0,0 +1,170 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable, combineLatest, of } from 'rxjs';
+import { concatMap } from 'rxjs/operators';
+import { DataService } from './data.service';
+import { defaultEpsg, defaultMaxFeatures, formatWFSQueryString, getFormatFromOptions, gmlRegex } from './wms-wfs.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class WFSService extends DataService {
+    http;
+    constructor(http) {
+        super();
+        this.http = http;
+    }
+    getData() {
+        console.log('This is defining a data service.');
+        return 'This is defining a data service.';
+    }
+    getSourceFieldsFromWFS(dataSourceOptions) {
+        if (!dataSourceOptions.sourceFields ||
+            dataSourceOptions.sourceFields.length === 0) {
+            dataSourceOptions.sourceFields = [];
+            this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe((getfeatureSourceField) => {
+                dataSourceOptions.sourceFields = getfeatureSourceField;
+            });
+        }
+        else {
+            this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe((getfeatureSourceField) => {
+                dataSourceOptions.sourceFields.forEach((sourcefield) => {
+                    if (sourcefield.alias === undefined) {
+                        sourcefield.alias = sourcefield.name; // to allow only a list of sourcefield with names
+                    }
+                    if (sourcefield.values === undefined ||
+                        sourcefield.values.length === 0) {
+                        sourcefield.values = getfeatureSourceField.find((sf) => sf.name === sourcefield.name).values;
+                    }
+                });
+            });
+        }
+    }
+    wfsGetFeature(dataSourceOptions, nb = defaultMaxFeatures, epsgCode = defaultEpsg, propertyName, startIndex = 0, forceDefaultOutputFormat = false) {
+        const queryStringValues = formatWFSQueryString(dataSourceOptions, nb, epsgCode, propertyName, startIndex, forceDefaultOutputFormat);
+        const baseUrl = queryStringValues.find((f) => f.name === 'getfeature').value;
+        const outputFormat = dataSourceOptions.paramsWFS.outputFormat;
+        if (forceDefaultOutputFormat ||
+            gmlRegex.test(outputFormat) ||
+            !outputFormat) {
+            return this.http.get(baseUrl, { responseType: 'text' });
+        }
+        else {
+            return this.http.get(baseUrl);
+        }
+    }
+    defineFieldAndValuefromWFS(dataSourceOptions) {
+        return new Observable((d) => {
+            const sourceFields = [];
+            let fieldList;
+            let fieldListWoGeom;
+            let fieldListWoGeomStr;
+            let effectiveOlFormats;
+            const olFormats = getFormatFromOptions(dataSourceOptions);
+            const gmlDataSourceOptions = JSON.parse(JSON.stringify(dataSourceOptions));
+            delete gmlDataSourceOptions.paramsWFS.outputFormat;
+            delete gmlDataSourceOptions.formatOptions;
+            effectiveOlFormats = getFormatFromOptions(gmlDataSourceOptions);
+            let sourceFieldsToRetrieveValues = dataSourceOptions.sourceFields
+                ?.filter((f) => !f.values)
+                .map((f) => f.name);
+            // Validate if the service manage no outputformat (wfs 1.0.0 and GML is the default return)
+            this.wfsGetFeature(dataSourceOptions, 1, undefined, undefined, 0, true)
+                .pipe(concatMap((res) => String(res).toLowerCase().includes('exception')
+                ? of(false)
+                : of(true)), concatMap((allowGml) => {
+                // If the service return GML (return no exception)
+                return this.wfsGetFeature(dataSourceOptions, 1).pipe(concatMap((firstFeature) => {
+                    const features = olFormats.readFeatures(firstFeature);
+                    fieldList = features[0].getKeys();
+                    if (dataSourceOptions.sourceFields ||
+                        dataSourceOptions.sourceFields.length === 0) {
+                        sourceFieldsToRetrieveValues = fieldList;
+                    }
+                    fieldListWoGeom = fieldList.filter((field) => sourceFieldsToRetrieveValues.includes(field) &&
+                        field !== features[0].getGeometryName() &&
+                        !field.match(/boundedby/gi));
+                    fieldListWoGeomStr = fieldListWoGeom.join(',');
+                    const processingArray = [];
+                    let startIndex = 0;
+                    // If the service do not allow gml return, dice the call in multiple
+                    // calls by increment of chunkSize with the original outputFormat
+                    if (!allowGml &&
+                        dataSourceOptions.paramsWFS.version === '2.0.0' &&
+                        dataSourceOptions.paramsWFS.maxFeatures > defaultMaxFeatures) {
+                        const chunkSize = 1000;
+                        while (startIndex < dataSourceOptions.paramsWFS.maxFeatures) {
+                            processingArray.push(this.wfsGetFeature(dataSourceOptions, chunkSize, dataSourceOptions.paramsWFS.srsName, fieldListWoGeomStr, startIndex));
+                            startIndex += chunkSize;
+                        }
+                        effectiveOlFormats = olFormats;
+                    }
+                    else {
+                        processingArray.push(this.wfsGetFeature(dataSourceOptions, dataSourceOptions.paramsWFS.maxFeatures ||
+                            defaultMaxFeatures, dataSourceOptions.paramsWFS.srsName, fieldListWoGeomStr, 0, true));
+                    }
+                    return combineLatest(processingArray);
+                }));
+            }))
+                .subscribe((results) => {
+                let mfeatures = [];
+                results.map((result) => {
+                    const loopFeatures = effectiveOlFormats.readFeatures(result);
+                    mfeatures = mfeatures.concat(loopFeatures);
+                });
+                this.built_properties_value(mfeatures).forEach((element) => {
+                    sourceFields.push(element);
+                });
+                d.next(sourceFields);
+                d.complete();
+            });
+        });
+    }
+    built_properties_value(features) {
+        if (features.length === 0) {
+            return [];
+        }
+        const kv = Object.assign({}, features[0].getProperties());
+        delete kv[features[0].getGeometryName()];
+        delete kv.boundedBy;
+        const sourceFields = [];
+        for (const property in kv) {
+            // eslint-disable-next-line no-prototype-builtins
+            if (kv.hasOwnProperty(property)) {
+                const fieldType = typeof features[0].get(property) === 'object'
+                    ? undefined
+                    : typeof features[0].get(property);
+                sourceFields.push({
+                    name: property,
+                    alias: property,
+                    type: fieldType,
+                    values: [kv[property]]
+                });
+            }
+        }
+        features.every((element) => {
+            const featureProperties = element.getProperties();
+            for (const key in featureProperties) {
+                // eslint-disable-next-line no-prototype-builtins
+                if (featureProperties.hasOwnProperty(key) && key in kv) {
+                    sourceFields
+                        .filter((f) => f.name === key)
+                        .forEach((v) => {
+                        if (v.values.indexOf(featureProperties[key]) === -1) {
+                            v.values.push(featureProperties[key]);
+                        }
+                    });
+                }
+            }
+            return true;
+        });
+        return sourceFields;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WFSService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WFSService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WFSService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wfs.service.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/datasource/shared/datasources/wfs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\n\nimport olFeature from 'ol/Feature';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\n\nimport { Observable, combineLatest, of } from 'rxjs';\nimport { concatMap } from 'rxjs/operators';\n\nimport { DataService } from './data.service';\nimport { WFSDataSourceOptions } from './wfs-datasource.interface';\nimport { WMSDataSourceOptions } from './wms-datasource.interface';\nimport {\n  defaultEpsg,\n  defaultMaxFeatures,\n  formatWFSQueryString,\n  getFormatFromOptions,\n  gmlRegex\n} from './wms-wfs.utils';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class WFSService extends DataService {\n  constructor(private http: HttpClient) {\n    super();\n  }\n\n  getData() {\n    console.log('This is defining a data service.');\n    return 'This is defining a data service.';\n  }\n\n  public getSourceFieldsFromWFS(\n    dataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions\n  ) {\n    if (\n      !dataSourceOptions.sourceFields ||\n      dataSourceOptions.sourceFields.length === 0\n    ) {\n      dataSourceOptions.sourceFields = [];\n      this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe(\n        (getfeatureSourceField) => {\n          dataSourceOptions.sourceFields = getfeatureSourceField;\n        }\n      );\n    } else {\n      this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe(\n        (getfeatureSourceField) => {\n          dataSourceOptions.sourceFields.forEach((sourcefield) => {\n            if (sourcefield.alias === undefined) {\n              sourcefield.alias = sourcefield.name; // to allow only a list of sourcefield with names\n            }\n            if (\n              sourcefield.values === undefined ||\n              sourcefield.values.length === 0\n            ) {\n              sourcefield.values = getfeatureSourceField.find(\n                (sf) => sf.name === sourcefield.name\n              ).values;\n            }\n          });\n        }\n      );\n    }\n  }\n\n  private wfsGetFeature(\n    dataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions,\n    nb: number = defaultMaxFeatures,\n    epsgCode: string = defaultEpsg,\n    propertyName?: string,\n    startIndex = 0,\n    forceDefaultOutputFormat = false\n  ): Observable<any> {\n    const queryStringValues = formatWFSQueryString(\n      dataSourceOptions,\n      nb,\n      epsgCode,\n      propertyName,\n      startIndex,\n      forceDefaultOutputFormat\n    );\n    const baseUrl = queryStringValues.find(\n      (f) => f.name === 'getfeature'\n    ).value;\n    const outputFormat = dataSourceOptions.paramsWFS.outputFormat;\n    if (\n      forceDefaultOutputFormat ||\n      gmlRegex.test(outputFormat) ||\n      !outputFormat\n    ) {\n      return this.http.get(baseUrl, { responseType: 'text' });\n    } else {\n      return this.http.get(baseUrl);\n    }\n  }\n\n  defineFieldAndValuefromWFS(\n    dataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions\n  ): Observable<any> {\n    return new Observable((d) => {\n      const sourceFields = [];\n      let fieldList;\n      let fieldListWoGeom;\n      let fieldListWoGeomStr;\n      let effectiveOlFormats;\n\n      const olFormats = getFormatFromOptions(dataSourceOptions);\n      const gmlDataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions =\n        JSON.parse(JSON.stringify(dataSourceOptions));\n      delete gmlDataSourceOptions.paramsWFS.outputFormat;\n      delete (gmlDataSourceOptions as WFSDataSourceOptions).formatOptions;\n\n      effectiveOlFormats = getFormatFromOptions(gmlDataSourceOptions);\n      let sourceFieldsToRetrieveValues = dataSourceOptions.sourceFields\n        ?.filter((f) => !f.values)\n        .map((f) => f.name);\n\n      // Validate if the service manage no outputformat (wfs 1.0.0 and GML is the default return)\n      this.wfsGetFeature(dataSourceOptions, 1, undefined, undefined, 0, true)\n        .pipe(\n          concatMap((res) =>\n            String(res).toLowerCase().includes('exception')\n              ? of(false)\n              : of(true)\n          ),\n          concatMap((allowGml) => {\n            // If the service return GML (return no exception)\n            return this.wfsGetFeature(dataSourceOptions, 1).pipe(\n              concatMap((firstFeature) => {\n                const features = olFormats.readFeatures(firstFeature);\n                fieldList = features[0].getKeys();\n                if (\n                  dataSourceOptions.sourceFields ||\n                  dataSourceOptions.sourceFields.length === 0\n                ) {\n                  sourceFieldsToRetrieveValues = fieldList;\n                }\n                fieldListWoGeom = fieldList.filter(\n                  (field) =>\n                    sourceFieldsToRetrieveValues.includes(field) &&\n                    field !== features[0].getGeometryName() &&\n                    !field.match(/boundedby/gi)\n                );\n                fieldListWoGeomStr = fieldListWoGeom.join(',');\n                const processingArray = [];\n                let startIndex = 0;\n                // If the service do not allow gml return, dice the call in multiple\n                // calls by increment of chunkSize with the original outputFormat\n                if (\n                  !allowGml &&\n                  dataSourceOptions.paramsWFS.version === '2.0.0' &&\n                  dataSourceOptions.paramsWFS.maxFeatures > defaultMaxFeatures\n                ) {\n                  const chunkSize = 1000;\n                  while (startIndex < dataSourceOptions.paramsWFS.maxFeatures) {\n                    processingArray.push(\n                      this.wfsGetFeature(\n                        dataSourceOptions,\n                        chunkSize,\n                        dataSourceOptions.paramsWFS.srsName,\n                        fieldListWoGeomStr,\n                        startIndex\n                      )\n                    );\n                    startIndex += chunkSize;\n                  }\n                  effectiveOlFormats = olFormats;\n                } else {\n                  processingArray.push(\n                    this.wfsGetFeature(\n                      dataSourceOptions,\n                      dataSourceOptions.paramsWFS.maxFeatures ||\n                        defaultMaxFeatures,\n                      dataSourceOptions.paramsWFS.srsName,\n                      fieldListWoGeomStr,\n                      0,\n                      true\n                    )\n                  );\n                }\n                return combineLatest(processingArray);\n              })\n            );\n          })\n        )\n        .subscribe((results) => {\n          let mfeatures: olFeature<OlGeometry>[] = [];\n          results.map((result) => {\n            const loopFeatures = effectiveOlFormats.readFeatures(result);\n            mfeatures = mfeatures.concat(loopFeatures);\n          });\n          this.built_properties_value(mfeatures).forEach((element) => {\n            sourceFields.push(element);\n          });\n          d.next(sourceFields);\n          d.complete();\n        });\n    });\n  }\n\n  private built_properties_value(features: olFeature<OlGeometry>[]): string[] {\n    if (features.length === 0) {\n      return [];\n    }\n    const kv = Object.assign({}, features[0].getProperties());\n    delete kv[features[0].getGeometryName()];\n    delete kv.boundedBy;\n    const sourceFields = [];\n    for (const property in kv) {\n      // eslint-disable-next-line no-prototype-builtins\n      if (kv.hasOwnProperty(property)) {\n        const fieldType =\n          typeof features[0].get(property) === 'object'\n            ? undefined\n            : typeof features[0].get(property);\n        sourceFields.push({\n          name: property,\n          alias: property,\n          type: fieldType,\n          values: [kv[property]]\n        });\n      }\n    }\n    features.every((element) => {\n      const featureProperties = element.getProperties();\n      for (const key in featureProperties) {\n        // eslint-disable-next-line no-prototype-builtins\n        if (featureProperties.hasOwnProperty(key) && key in kv) {\n          sourceFields\n            .filter((f) => f.name === key)\n            .forEach((v) => {\n              if (v.values.indexOf(featureProperties[key]) === -1) {\n                v.values.push(featureProperties[key]);\n              }\n            });\n        }\n      }\n      return true;\n    });\n    return sourceFields;\n  }\n}\n"]}

package/esm2022/lib/datasource/shared/datasources/wms-datasource.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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