@igo2/geo 1.15.4 → 16.0.0-rc.1

package/esm2022/lib/layer/shared/layers/vector-layer.mjs

@@ -0,0 +1,562 @@
+import olLayerVector from 'ol/layer/Vector';
+import { unByKey } from 'ol/Observable';
+import { easeOut } from 'ol/easing';
+import { asArray as ColorAsArray } from 'ol/color';
+import { getVectorContext } from 'ol/render';
+import olProjection from 'ol/proj/Projection';
+import * as olproj from 'ol/proj';
+import * as olformat from 'ol/format';
+import { FeatureDataSource } from '../../../datasource/shared/datasources/feature-datasource';
+import { VectorWatcher } from '../../utils';
+import { getResolutionFromScale } from '../../../map/shared';
+import { Layer } from './layer';
+import { buildUrl, defaultMaxFeatures } from '../../../datasource/shared/datasources/wms-wfs.utils';
+import { catchError, concatMap, debounceTime, delay, first } from 'rxjs/operators';
+import { fromEvent, of, zip } from 'rxjs';
+import { InsertSourceInsertDBEnum } from '../../../offline/geoDB/geoDB.enums';
+import { olStyleToBasicIgoStyle } from '../../../style/shared/vector/conversion.utils';
+import { ObjectUtils } from '@igo2/utils';
+export class VectorLayer extends Layer {
+    messageService;
+    authInterceptor;
+    geoNetworkService;
+    geoDBService;
+    layerDBService;
+    watcher;
+    trackFeatureListenerId;
+    get browsable() {
+        return this.options.browsable !== false;
+    }
+    get exportable() {
+        return this.options.exportable !== false;
+    }
+    constructor(options, messageService, authInterceptor, geoNetworkService, geoDBService, layerDBService) {
+        super(options, messageService, authInterceptor, geoDBService, layerDBService);
+        this.messageService = messageService;
+        this.authInterceptor = authInterceptor;
+        this.geoNetworkService = geoNetworkService;
+        this.geoDBService = geoDBService;
+        this.layerDBService = layerDBService;
+        this.watcher = new VectorWatcher(this);
+        this.status$ = this.watcher.status$;
+    }
+    createOlLayer() {
+        const initialOpacityValue = this.options.opacity || 1;
+        const initialVisibleValue = this.options.visible !== false;
+        const initialMinResValue = this.options.minResolution ||
+            getResolutionFromScale(Number(this.options.minScaleDenom));
+        const initialMaxResValue = this.options.maxResolution ||
+            getResolutionFromScale(Number(this.options.maxScaleDenom));
+        const so = this.options.sourceOptions;
+        if (this.dataSource instanceof FeatureDataSource) {
+            if (so?.preload?.bypassResolution || so?.preload?.bypassVisible) {
+                this.options.opacity = 0;
+                if (so.preload.bypassResolution &&
+                    (this.options.minResolution || this.options.maxResolution)) {
+                    this.options.minResolution = 0;
+                    this.options.maxResolution = Infinity;
+                }
+                if (so.preload.bypassVisible && !initialVisibleValue) {
+                    this.options.visible = true;
+                }
+            }
+        }
+        const olOptions = Object.assign({}, this.options, {
+            source: this.options.source.ol
+        });
+        if (this.options.animation) {
+            this.dataSource.ol.on('addfeature', function (e) {
+                this.flash(e.feature);
+            }.bind(this));
+        }
+        if (this.options.idbInfo?.storeToIdb && this.geoDBService) {
+            if (this.options.idbInfo.firstLoad) {
+                this.maintainFeaturesInIdb();
+            }
+            this.dataSource.ol.once('featuresloadend', () => {
+                this.dataSource.ol.on('addfeature', () => this.maintainFeaturesInIdb());
+                this.dataSource.ol.on('changefeature', () => this.maintainFeaturesInIdb());
+                this.dataSource.ol.on('clear', () => this.maintainFeaturesInIdb());
+                this.dataSource.ol.on('removefeature', () => this.maintainFeaturesInIdb());
+            });
+        }
+        if (this.dataSource instanceof FeatureDataSource &&
+            (so?.preload?.bypassResolution || so?.preload?.bypassVisible)) {
+            this.dataSource.ol.once('featuresloadend', () => {
+                if (initialOpacityValue) {
+                    this.opacity = initialOpacityValue;
+                }
+                if (so.preload.bypassResolution) {
+                    this.minResolution = initialMinResValue;
+                    this.maxResolution = initialMaxResValue;
+                }
+                if (so.preload.bypassVisible) {
+                    this.visible = initialVisibleValue;
+                }
+            });
+        }
+        if (this.options.trackFeature) {
+            this.enableTrackFeature(this.options.trackFeature);
+        }
+        const vector = new olLayerVector(olOptions);
+        const vectorSource = vector.getSource();
+        const url = vectorSource.getUrl();
+        if (url) {
+            let loader;
+            const wfsOptions = olOptions.sourceOptions;
+            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);
+                };
+            }
+            else {
+                loader = (extent, resolution, proj, success, failure) => {
+                    this.customLoader(vectorSource, url, this.authInterceptor, extent, resolution, proj, success, failure);
+                };
+            }
+            if (loader) {
+                vectorSource.setLoader(loader);
+            }
+        }
+        else if (this.options.idbInfo?.storeToIdb && this.geoDBService) {
+            const idbLoader = (extent, resolution, proj, success, failure) => {
+                this.customIDBLoader(vectorSource, olOptions.id, extent, proj, success, failure);
+            };
+            if (idbLoader) {
+                vectorSource.setLoader(idbLoader);
+            }
+        }
+        if (this.options.idbInfo?.storeToIdb && this.geoDBService) {
+            vector.once('sourceready', () => {
+                if (this.options.idbInfo.firstLoad) {
+                    this.maintainOptionsInIdb();
+                }
+                fromEvent(vector, 'change')
+                    .pipe(debounceTime(750))
+                    .subscribe(() => this.maintainOptionsInIdb());
+                vector.on('change:zIndex', () => this.maintainOptionsInIdb());
+            });
+        }
+        return vector;
+    }
+    removeLayerFromIDB() {
+        if (this.geoDBService && this.layerDBService) {
+            zip(this.geoDBService.deleteByKey(this.id), this.layerDBService.deleteByKey(this.id)).subscribe();
+        }
+    }
+    maintainOptionsInIdb() {
+        this.options.igoStyle.igoStyleObject = olStyleToBasicIgoStyle(this.ol);
+        const layerData = ObjectUtils.removeUndefined({
+            layerId: this.id,
+            detailedContextUri: this.options.idbInfo.contextUri,
+            sourceOptions: {
+                id: this.id,
+                type: 'vector',
+                queryable: true
+            },
+            layerOptions: {
+                workspace: this.options.workspace,
+                zIndex: this.ol ? this.zIndex : 1000000,
+                id: this.id,
+                isIgoInternalLayer: this.isIgoInternalLayer,
+                title: this.title,
+                igoStyle: this.options.igoStyle,
+                idbInfo: Object.assign({}, this.options.idbInfo, { firstLoad: false })
+            },
+            insertEvent: `${this.title}-${this.id}-${new Date()}`
+        });
+        this.layerDBService.update(layerData);
+    }
+    maintainFeaturesInIdb() {
+        const dsFeatures = this.dataSource.ol.getFeatures();
+        const geojsonObject = JSON.parse(new olformat.GeoJSON().writeFeatures(dsFeatures, {
+            dataProjection: 'EPSG:4326',
+            featureProjection: this.dataSource.ol.getProjection() || 'EPSG:3857'
+        }));
+        this.geoDBService.update(this.id, this.id, geojsonObject, InsertSourceInsertDBEnum.User, `${this.title}-${this.id}-${new Date()}`);
+    }
+    flash(feature) {
+        const start = new Date().getTime();
+        const listenerKey = this.ol.on('postrender', animate.bind(this));
+        function animate(event) {
+            const vectorContext = getVectorContext(event);
+            const frameState = event.frameState;
+            const flashGeom = feature.getGeometry().clone();
+            const elapsed = frameState.time - start;
+            const elapsedRatio = elapsed / this.options.animation.duration;
+            const opacity = easeOut(1 - elapsedRatio);
+            const newColor = ColorAsArray(this.options.animation.color || 'red');
+            newColor[3] = opacity;
+            let style = this.ol
+                .getStyleFunction()
+                .call(this, feature)
+                .find((style2) => {
+                return style2.getImage();
+            });
+            if (!style) {
+                style = this.ol.getStyleFunction().call(this, feature)[0];
+            }
+            const styleClone = style.clone();
+            switch (feature.getGeometry().getType()) {
+                case 'Point':
+                    if (styleClone.getImage() !== null &&
+                        typeof styleClone.getImage().getRadius === 'function') {
+                        const radius = easeOut(elapsedRatio) * (styleClone.getImage().getRadius() * 3);
+                        styleClone.getImage().setRadius(radius);
+                        styleClone.getImage().setOpacity(opacity);
+                    }
+                    break;
+                case 'LineString':
+                    // TODO
+                    if (styleClone.getImage()) {
+                        styleClone.getImage().getStroke().setColor(newColor);
+                        styleClone
+                            .getImage()
+                            .getStroke()
+                            .setWidth(easeOut(elapsedRatio) *
+                            (styleClone.getImage().getStroke().getWidth() * 3));
+                    }
+                    if (styleClone.getStroke()) {
+                        styleClone.getStroke().setColor(newColor);
+                        styleClone
+                            .getStroke()
+                            .setWidth(easeOut(elapsedRatio) * (styleClone.getStroke().getWidth() * 3));
+                    }
+                    break;
+                case 'Polygon':
+                    // TODO
+                    if (styleClone.getImage()) {
+                        styleClone.getImage().getFill().setColor(newColor);
+                    }
+                    if (styleClone.getFill()) {
+                        styleClone.getFill().setColor(newColor);
+                    }
+                    break;
+            }
+            styleClone.setText('');
+            vectorContext.setStyle(styleClone);
+            vectorContext.drawGeometry(flashGeom);
+            if (elapsed > this.options.animation.duration) {
+                unByKey(listenerKey);
+                // remove last geometry
+                // there is a little flash before feature disappear, better solution ?
+                this.map.ol.render();
+                return;
+            }
+            // tell OpenLayers to continue postcompose animation
+            this.map.ol.render();
+        }
+    }
+    setMap(map) {
+        if (map === undefined) {
+            this.watcher.unsubscribe();
+        }
+        else {
+            this.watcher.subscribe(() => { });
+        }
+        super.setMap(map);
+    }
+    setExtent(extent) {
+        this.options.extent = extent;
+    }
+    onUnwatch() {
+        this.dataSource.onUnwatch();
+        this.stopAnimation();
+    }
+    stopAnimation() {
+        this.dataSource.ol.un('addfeature', function (e) {
+            if (this.visible) {
+                this.flash(e.feature);
+            }
+        }.bind(this));
+    }
+    enableTrackFeature(id) {
+        this.trackFeatureListenerId = this.dataSource.ol.on('addfeature', this.trackFeature.bind(this, id));
+    }
+    centerMapOnFeature(id) {
+        const feat = this.dataSource.ol.getFeatureById(id);
+        if (feat) {
+            this.map.ol
+                .getView()
+                .setCenter(feat.getGeometry().getCoordinates());
+        }
+    }
+    trackFeature(id, feat) {
+        if (feat.feature.getId() === id && this.visible) {
+            this.centerMapOnFeature(id);
+        }
+    }
+    disableTrackFeature(id) {
+        unByKey(this.trackFeatureListenerId);
+    }
+    /**
+     * Custom loader for a WFS datasource
+     * @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
+     * @param success success callback
+     * @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);
+            paramsWFS.srsName = paramsWFS.srsName || proj.getCode();
+            const url = buildUrl(options, currentExtent, wfsProj, options.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, interceptor, currentExtent, wfsProj, proj, alteredUrl, nbOfFeature, success, failure);
+                    startIndex += nbOfFeature;
+                }
+            }
+            else {
+                this.getFeatures(vectorSource, interceptor, currentExtent, wfsProj, proj, url, paramsWFS.maxFeatures, success, failure);
+            }
+        }
+    }
+    /**
+     * Custom loader to get feature from a WFS datasource
+     * @internal
+     * @param vectorSource the vector source to be created
+     * @param interceptor the interceptor of the data
+     * @param extent the extent of the requested data
+     * @param dataProjection the projection of the retrieved data
+     * @param featureProjection the projection of the created features
+     * @param url the url string to retrieve the data
+     * @param threshold the threshold to manage "more features" (TODO)
+     * @param success success callback
+     * @param failure failure callback
+     */
+    getFeatures(vectorSource, interceptor, extent, dataProjection, featureProjection, url, threshold, success, failure) {
+        const idAssociatedCall = this.dataSource
+            .mostRecentIdCallOGCFilter;
+        const xhr = new XMLHttpRequest();
+        const alteredUrlWithKeyAuth = interceptor.alterUrlWithKeyAuth(url);
+        let modifiedUrl = url;
+        if (alteredUrlWithKeyAuth) {
+            modifiedUrl = alteredUrlWithKeyAuth;
+        }
+        xhr.open('GET', modifiedUrl);
+        if (interceptor) {
+            interceptor.interceptXhr(xhr, modifiedUrl);
+        }
+        const onError = () => {
+            vectorSource.removeLoadedExtent(extent);
+            failure();
+        };
+        xhr.onerror = onError;
+        xhr.onload = () => {
+            if (xhr.status === 200 && xhr.responseText.length > 0) {
+                const features = vectorSource
+                    .getFormat()
+                    .readFeatures(xhr.responseText, {
+                    dataProjection,
+                    featureProjection
+                });
+                // TODO Manage "More feature"
+                /*if (features.length === 0 || features.length < threshold ) {
+                  console.log('No more data to download at this resolution');
+                }*/
+                // Avoids retrieving an older call that took longer to be process
+                if (idAssociatedCall ===
+                    this.dataSource.mostRecentIdCallOGCFilter) {
+                    vectorSource.addFeatures(features);
+                    success(features);
+                }
+                else {
+                    success([]);
+                }
+            }
+            else {
+                onError();
+            }
+        };
+        xhr.send();
+    }
+    /**
+     * 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 interceptor the interceptor of 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, interceptor, extent, resolution, projection, success, failure) {
+        const xhr = new XMLHttpRequest();
+        let modifiedUrl = url;
+        if (typeof url !== 'function') {
+            const alteredUrlWithKeyAuth = interceptor.alterUrlWithKeyAuth(url);
+            if (alteredUrlWithKeyAuth) {
+                modifiedUrl = alteredUrlWithKeyAuth;
+            }
+        }
+        else {
+            modifiedUrl = url(extent, resolution, projection);
+        }
+        if (this.geoNetworkService && typeof url !== 'function') {
+            const format = vectorSource.getFormat();
+            const type = format.getType();
+            let responseType = type;
+            const onError = () => {
+                vectorSource.removeLoadedExtent(extent);
+                failure();
+            };
+            const options = { responseType };
+            this.geoNetworkService.geoDBService
+                .get(url)
+                .pipe(delay(750))
+                .pipe(concatMap((r) => r
+                ? of(r)
+                : this.geoNetworkService.get(modifiedUrl, options).pipe(first(), catchError((res) => {
+                    onError();
+                    throw res;
+                }))))
+                .subscribe((content) => {
+                if (content) {
+                    const format = vectorSource.getFormat();
+                    const type = format.getType();
+                    let source;
+                    if (type === 'json' || type === 'text') {
+                        source = content;
+                    }
+                    else if (type === 'xml') {
+                        source = content;
+                        if (!source) {
+                            source = new DOMParser().parseFromString(content, 'application/xml');
+                        }
+                    }
+                    else if (type === 'arraybuffer') {
+                        source = content;
+                    }
+                    if (source) {
+                        const features = format.readFeatures(source, {
+                            extent,
+                            featureProjection: projection
+                        });
+                        vectorSource.addFeatures(features, format.readProjection(source));
+                        success(features);
+                    }
+                    else {
+                        onError();
+                    }
+                }
+            });
+        }
+        else {
+            xhr.open('GET', modifiedUrl);
+            const format = vectorSource.getFormat();
+            if (format.getType() === 'arraybuffer') {
+                xhr.responseType = 'arraybuffer';
+            }
+            if (interceptor) {
+                interceptor.interceptXhr(xhr, modifiedUrl);
+            }
+            const onError = () => {
+                vectorSource.removeLoadedExtent(extent);
+                failure();
+            };
+            xhr.onerror = onError;
+            xhr.onload = () => {
+                // status will be 0 for file:// urls
+                if (!xhr.status || (xhr.status >= 200 && xhr.status < 300)) {
+                    const type = format.getType();
+                    let source;
+                    if (type === 'json' || type === 'text') {
+                        source = xhr.responseText;
+                    }
+                    else if (type === 'xml') {
+                        source = xhr.responseXML;
+                        if (!source) {
+                            source = new DOMParser().parseFromString(xhr.responseText, 'application/xml');
+                        }
+                    }
+                    else if (type === 'arraybuffer') {
+                        source = xhr.response;
+                    }
+                    if (source) {
+                        const features = format.readFeatures(source, {
+                            extent,
+                            featureProjection: projection
+                        });
+                        vectorSource.addFeatures(features, format.readProjection(source));
+                        success(features);
+                    }
+                    else {
+                        onError();
+                    }
+                }
+                else {
+                    onError();
+                }
+            };
+            xhr.send();
+        }
+    }
+    /**
+     * Custom loader for vector layer.
+     * @internal
+     * @param vectorSource the vector source to be created
+     * @param layerID the url string or function to retrieve the data
+     * @param interceptor the interceptor of the data
+     * @param extent the extent of the requested data
+     * @param resolution the current resolution
+     * @param projection the projection to retrieve the data
+     */
+    customIDBLoader(vectorSource, layerID, extent, projection, success, failure) {
+        if (this.geoNetworkService) {
+            const onError = () => {
+                vectorSource.removeLoadedExtent(extent);
+                failure();
+            };
+            this.geoNetworkService.geoDBService.get(layerID).subscribe((content) => {
+                if (content) {
+                    const format = vectorSource.getFormat();
+                    const type = format.getType();
+                    let source;
+                    if (type === 'json' || type === 'text') {
+                        source = content;
+                    }
+                    else if (type === 'xml') {
+                        source = content;
+                        if (!source) {
+                            source = new DOMParser().parseFromString(content, 'application/xml');
+                        }
+                    }
+                    else if (type === 'arraybuffer') {
+                        source = content;
+                    }
+                    if (source) {
+                        const features = format.readFeatures(source, {
+                            extent,
+                            featureProjection: projection
+                        });
+                        vectorSource.addFeatures(features, format.readProjection(source));
+                        success(features);
+                    }
+                    else {
+                        onError();
+                    }
+                }
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vector-layer.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/layer/shared/layers/vector-layer.ts"],"names":[],"mappings":"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","sourcesContent":["import olLayerVector from 'ol/layer/Vector';\nimport olSourceVector from 'ol/source/Vector';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\nimport { unByKey } from 'ol/Observable';\nimport { easeOut } from 'ol/easing';\nimport { asArray as ColorAsArray } from 'ol/color';\nimport { getVectorContext } from 'ol/render';\nimport olFeature from 'ol/Feature';\nimport olProjection from 'ol/proj/Projection';\nimport * as olproj from 'ol/proj';\nimport * as olformat from 'ol/format';\n\nimport { FeatureDataSource } from '../../../datasource/shared/datasources/feature-datasource';\nimport { WFSDataSource } from '../../../datasource/shared/datasources/wfs-datasource';\nimport { ArcGISRestDataSource } from '../../../datasource/shared/datasources/arcgisrest-datasource';\nimport { WebSocketDataSource } from '../../../datasource/shared/datasources/websocket-datasource';\nimport { ClusterDataSource } from '../../../datasource/shared/datasources/cluster-datasource';\n\nimport { VectorWatcher } from '../../utils';\nimport { IgoMap, MapExtent, getResolutionFromScale } from '../../../map/shared';\nimport { Layer } from './layer';\nimport { VectorLayerOptions } from './vector-layer.interface';\nimport { AuthInterceptor } from '@igo2/auth';\nimport { MessageService } from '@igo2/core';\nimport { WFSDataSourceOptions } from '../../../datasource/shared/datasources/wfs-datasource.interface';\nimport {\n  buildUrl,\n  defaultMaxFeatures\n} from '../../../datasource/shared/datasources/wms-wfs.utils';\nimport { OgcFilterableDataSourceOptions } from '../../../filter/shared/ogc-filter.interface';\nimport {\n  GeoNetworkService,\n  SimpleGetOptions\n} from '../../../offline/shared/geo-network.service';\nimport {\n  catchError,\n  concatMap,\n  debounceTime,\n  delay,\n  first\n} from 'rxjs/operators';\nimport { GeoDBService } from '../../../offline/geoDB/geoDB.service';\nimport { fromEvent, of, zip } from 'rxjs';\nimport { InsertSourceInsertDBEnum } from '../../../offline/geoDB/geoDB.enums';\nimport { LayerDBService } from '../../../offline/layerDB/layerDB.service';\nimport { LayerDBData } from '../../../offline';\nimport BaseEvent from 'ol/events/Event';\nimport { olStyleToBasicIgoStyle } from '../../../style/shared/vector/conversion.utils';\nimport { FeatureDataSourceOptions } from '../../../datasource/shared/datasources/feature-datasource.interface';\nimport { ObjectUtils } from '@igo2/utils';\n\nexport class VectorLayer extends Layer {\n  public declare dataSource:\n    | FeatureDataSource\n    | WFSDataSource\n    | ArcGISRestDataSource\n    | WebSocketDataSource\n    | ClusterDataSource;\n  public declare options: VectorLayerOptions;\n  public declare ol: olLayerVector<olSourceVector<OlGeometry>>;\n  private watcher: VectorWatcher;\n  private trackFeatureListenerId;\n\n  get browsable(): boolean {\n    return this.options.browsable !== false;\n  }\n\n  get exportable(): boolean {\n    return this.options.exportable !== false;\n  }\n\n  constructor(\n    options: VectorLayerOptions,\n    public messageService?: MessageService,\n    public authInterceptor?: AuthInterceptor,\n    private geoNetworkService?: GeoNetworkService,\n    public geoDBService?: GeoDBService,\n    public layerDBService?: LayerDBService\n  ) {\n    super(\n      options,\n      messageService,\n      authInterceptor,\n      geoDBService,\n      layerDBService\n    );\n    this.watcher = new VectorWatcher(this);\n    this.status$ = this.watcher.status$;\n  }\n\n  protected createOlLayer(): olLayerVector<olSourceVector<OlGeometry>> {\n    const initialOpacityValue = this.options.opacity || 1;\n    const initialVisibleValue = this.options.visible !== false;\n    const initialMinResValue =\n      this.options.minResolution ||\n      getResolutionFromScale(Number(this.options.minScaleDenom));\n    const initialMaxResValue =\n      this.options.maxResolution ||\n      getResolutionFromScale(Number(this.options.maxScaleDenom));\n    const so = this.options.sourceOptions as FeatureDataSourceOptions;\n    if (this.dataSource instanceof FeatureDataSource) {\n      if (so?.preload?.bypassResolution || so?.preload?.bypassVisible) {\n        this.options.opacity = 0;\n        if (\n          so.preload.bypassResolution &&\n          (this.options.minResolution || this.options.maxResolution)\n        ) {\n          this.options.minResolution = 0;\n          this.options.maxResolution = Infinity;\n        }\n        if (so.preload.bypassVisible && !initialVisibleValue) {\n          this.options.visible = true;\n        }\n      }\n    }\n\n    const olOptions = Object.assign({}, this.options, {\n      source: this.options.source.ol as olSourceVector<OlGeometry>\n    });\n\n    if (this.options.animation) {\n      this.dataSource.ol.on(\n        'addfeature',\n        function (e) {\n          this.flash(e.feature);\n        }.bind(this)\n      );\n    }\n    if (this.options.idbInfo?.storeToIdb && this.geoDBService) {\n      if (this.options.idbInfo.firstLoad) {\n        this.maintainFeaturesInIdb();\n      }\n      this.dataSource.ol.once('featuresloadend', () => {\n        this.dataSource.ol.on('addfeature', () => this.maintainFeaturesInIdb());\n        this.dataSource.ol.on('changefeature', () =>\n          this.maintainFeaturesInIdb()\n        );\n        this.dataSource.ol.on('clear', () => this.maintainFeaturesInIdb());\n        this.dataSource.ol.on('removefeature', () =>\n          this.maintainFeaturesInIdb()\n        );\n      });\n    }\n\n    if (\n      this.dataSource instanceof FeatureDataSource &&\n      (so?.preload?.bypassResolution || so?.preload?.bypassVisible)\n    ) {\n      this.dataSource.ol.once('featuresloadend', () => {\n        if (initialOpacityValue) {\n          this.opacity = initialOpacityValue;\n        }\n        if (so.preload.bypassResolution) {\n          this.minResolution = initialMinResValue;\n          this.maxResolution = initialMaxResValue;\n        }\n        if (so.preload.bypassVisible) {\n          this.visible = initialVisibleValue;\n        }\n      });\n    }\n\n    if (this.options.trackFeature) {\n      this.enableTrackFeature(this.options.trackFeature);\n    }\n\n    const vector = new olLayerVector(olOptions);\n    const vectorSource = vector.getSource() as olSourceVector<OlGeometry>;\n    const url = vectorSource.getUrl();\n    if (url) {\n      let loader;\n      const wfsOptions = olOptions.sourceOptions as WFSDataSourceOptions;\n      if (\n        wfsOptions?.type === 'wfs' &&\n        (wfsOptions.params || wfsOptions.paramsWFS)\n      ) {\n        loader = (extent, resolution, proj, success, failure) => {\n          this.customWFSLoader(\n            vectorSource,\n            wfsOptions,\n            this.authInterceptor,\n            extent,\n            resolution,\n            proj,\n            success,\n            failure\n          );\n        };\n      } else {\n        loader = (extent, resolution, proj, success, failure) => {\n          this.customLoader(\n            vectorSource,\n            url,\n            this.authInterceptor,\n            extent,\n            resolution,\n            proj,\n            success,\n            failure\n          );\n        };\n      }\n      if (loader) {\n        vectorSource.setLoader(loader);\n      }\n    } else if (this.options.idbInfo?.storeToIdb && this.geoDBService) {\n      const idbLoader = (extent, resolution, proj, success, failure) => {\n        this.customIDBLoader(\n          vectorSource,\n          olOptions.id,\n          extent,\n          proj,\n          success,\n          failure\n        );\n      };\n      if (idbLoader) {\n        vectorSource.setLoader(idbLoader);\n      }\n    }\n\n    if (this.options.idbInfo?.storeToIdb && this.geoDBService) {\n      vector.once('sourceready', () => {\n        if (this.options.idbInfo.firstLoad) {\n          this.maintainOptionsInIdb();\n        }\n        fromEvent<BaseEvent>(vector, 'change')\n          .pipe(debounceTime(750))\n          .subscribe(() => this.maintainOptionsInIdb());\n        vector.on('change:zIndex', () => this.maintainOptionsInIdb());\n      });\n    }\n    return vector;\n  }\n\n  removeLayerFromIDB() {\n    if (this.geoDBService && this.layerDBService) {\n      zip(\n        this.geoDBService.deleteByKey(this.id),\n        this.layerDBService.deleteByKey(this.id)\n      ).subscribe();\n    }\n  }\n\n  private maintainOptionsInIdb() {\n    this.options.igoStyle.igoStyleObject = olStyleToBasicIgoStyle(this.ol);\n    const layerData: LayerDBData = ObjectUtils.removeUndefined({\n      layerId: this.id,\n      detailedContextUri: this.options.idbInfo.contextUri,\n      sourceOptions: {\n        id: this.id,\n        type: 'vector',\n        queryable: true\n      },\n      layerOptions: {\n        workspace: this.options.workspace,\n        zIndex: this.ol ? this.zIndex : 1000000,\n        id: this.id,\n        isIgoInternalLayer: this.isIgoInternalLayer,\n        title: this.title,\n        igoStyle: this.options.igoStyle,\n        idbInfo: Object.assign({}, this.options.idbInfo, { firstLoad: false })\n      },\n      insertEvent: `${this.title}-${this.id}-${new Date()}`\n    });\n    this.layerDBService.update(layerData);\n  }\n\n  private maintainFeaturesInIdb() {\n    const dsFeatures = this.dataSource.ol.getFeatures();\n    const geojsonObject = JSON.parse(\n      new olformat.GeoJSON().writeFeatures(dsFeatures, {\n        dataProjection: 'EPSG:4326',\n        featureProjection: this.dataSource.ol.getProjection() || 'EPSG:3857'\n      })\n    );\n    this.geoDBService.update(\n      this.id,\n      this.id,\n      geojsonObject,\n      InsertSourceInsertDBEnum.User,\n      `${this.title}-${this.id}-${new Date()}`\n    );\n  }\n\n  protected flash(feature) {\n    const start = new Date().getTime();\n    const listenerKey = this.ol.on('postrender', animate.bind(this));\n\n    function animate(event) {\n      const vectorContext = getVectorContext(event);\n      const frameState = event.frameState;\n      const flashGeom = feature.getGeometry().clone();\n      const elapsed = frameState.time - start;\n      const elapsedRatio = elapsed / this.options.animation.duration;\n      const opacity = easeOut(1 - elapsedRatio);\n      const newColor = ColorAsArray(this.options.animation.color || 'red');\n      newColor[3] = opacity;\n      let style = this.ol\n        .getStyleFunction()\n        .call(this, feature)\n        .find((style2) => {\n          return style2.getImage();\n        });\n      if (!style) {\n        style = this.ol.getStyleFunction().call(this, feature)[0];\n      }\n      const styleClone = style.clone();\n\n      switch (feature.getGeometry().getType()) {\n        case 'Point':\n          if (\n            styleClone.getImage() !== null &&\n            typeof styleClone.getImage().getRadius === 'function'\n          ) {\n            const radius =\n              easeOut(elapsedRatio) * (styleClone.getImage().getRadius() * 3);\n            styleClone.getImage().setRadius(radius);\n            styleClone.getImage().setOpacity(opacity);\n          }\n\n          break;\n        case 'LineString':\n          // TODO\n          if (styleClone.getImage()) {\n            styleClone.getImage().getStroke().setColor(newColor);\n            styleClone\n              .getImage()\n              .getStroke()\n              .setWidth(\n                easeOut(elapsedRatio) *\n                  (styleClone.getImage().getStroke().getWidth() * 3)\n              );\n          }\n          if (styleClone.getStroke()) {\n            styleClone.getStroke().setColor(newColor);\n            styleClone\n              .getStroke()\n              .setWidth(\n                easeOut(elapsedRatio) * (styleClone.getStroke().getWidth() * 3)\n              );\n          }\n          break;\n        case 'Polygon':\n          // TODO\n          if (styleClone.getImage()) {\n            styleClone.getImage().getFill().setColor(newColor);\n          }\n          if (styleClone.getFill()) {\n            styleClone.getFill().setColor(newColor);\n          }\n          break;\n      }\n\n      styleClone.setText('');\n      vectorContext.setStyle(styleClone);\n      vectorContext.drawGeometry(flashGeom);\n\n      if (elapsed > this.options.animation.duration) {\n        unByKey(listenerKey);\n        // remove last geometry\n        // there is a little flash before feature disappear, better solution ?\n        this.map.ol.render();\n        return;\n      }\n      // tell OpenLayers to continue postcompose animation\n      this.map.ol.render();\n    }\n  }\n\n  public setMap(map: IgoMap | undefined) {\n    if (map === undefined) {\n      this.watcher.unsubscribe();\n    } else {\n      this.watcher.subscribe(() => {});\n    }\n    super.setMap(map);\n  }\n\n  public setExtent(extent: MapExtent): void {\n    this.options.extent = extent;\n  }\n\n  public onUnwatch() {\n    this.dataSource.onUnwatch();\n    this.stopAnimation();\n  }\n\n  public stopAnimation() {\n    this.dataSource.ol.un(\n      'addfeature',\n      function (e) {\n        if (this.visible) {\n          this.flash(e.feature);\n        }\n      }.bind(this)\n    );\n  }\n\n  public enableTrackFeature(id: string | number) {\n    this.trackFeatureListenerId = this.dataSource.ol.on(\n      'addfeature',\n      this.trackFeature.bind(this, id)\n    );\n  }\n  public centerMapOnFeature(id: string | number) {\n    const feat = this.dataSource.ol.getFeatureById(id);\n    if (feat) {\n      this.map.ol\n        .getView()\n        .setCenter((feat.getGeometry() as any).getCoordinates());\n    }\n  }\n\n  public trackFeature(id, feat) {\n    if (feat.feature.getId() === id && this.visible) {\n      this.centerMapOnFeature(id);\n    }\n  }\n\n  public disableTrackFeature(id?: string | number) {\n    unByKey(this.trackFeatureListenerId);\n  }\n\n  /**\n   * Custom loader for a WFS datasource\n   * @internal\n   * @param vectorSource the vector source to be created\n   * @param options olOptions from source\n   * @param interceptor the interceptor of the data\n   * @param extent the extent of the requested data\n   * @param resolution the current resolution\n   * @param proj the projection to retrieve the data\n   * @param success success callback\n   * @param failure failure callback\n   * @param randomParam random parameter to ensure cache is not causing problems in retrieving new data\n   */\n  public customWFSLoader(\n    vectorSource,\n    options,\n    interceptor,\n    extent,\n    resolution,\n    proj,\n    success,\n    failure,\n    randomParam?: boolean\n  ) {\n    {\n      const paramsWFS = options.paramsWFS;\n      const wfsProj = paramsWFS.srsName\n        ? new olProjection({ code: paramsWFS.srsName })\n        : proj;\n      const currentExtent = olproj.transformExtent(extent, proj, wfsProj);\n      paramsWFS.srsName = paramsWFS.srsName || proj.getCode();\n      const url = buildUrl(\n        options,\n        currentExtent,\n        wfsProj,\n        (options as OgcFilterableDataSourceOptions).ogcFilters,\n        randomParam\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          this.getFeatures(\n            vectorSource,\n            interceptor,\n            currentExtent,\n            wfsProj,\n            proj,\n            alteredUrl,\n            nbOfFeature,\n            success,\n            failure\n          );\n          startIndex += nbOfFeature;\n        }\n      } else {\n        this.getFeatures(\n          vectorSource,\n          interceptor,\n          currentExtent,\n          wfsProj,\n          proj,\n          url,\n          paramsWFS.maxFeatures,\n          success,\n          failure\n        );\n      }\n    }\n  }\n\n  /**\n   * Custom loader to get feature from a WFS datasource\n   * @internal\n   * @param vectorSource the vector source to be created\n   * @param interceptor the interceptor of the data\n   * @param extent the extent of the requested data\n   * @param dataProjection the projection of the retrieved data\n   * @param featureProjection the projection of the created features\n   * @param url the url string to retrieve the data\n   * @param threshold the threshold to manage \"more features\" (TODO)\n   * @param success success callback\n   * @param failure failure callback\n   */\n  private getFeatures(\n    vectorSource: olSourceVector<OlGeometry>,\n    interceptor,\n    extent,\n    dataProjection,\n    featureProjection,\n    url: string,\n    threshold: number,\n    success,\n    failure\n  ) {\n    const idAssociatedCall = (this.dataSource as WFSDataSource)\n      .mostRecentIdCallOGCFilter;\n    const xhr = new XMLHttpRequest();\n    const alteredUrlWithKeyAuth = interceptor.alterUrlWithKeyAuth(url);\n    let modifiedUrl = url;\n    if (alteredUrlWithKeyAuth) {\n      modifiedUrl = alteredUrlWithKeyAuth;\n    }\n    xhr.open('GET', modifiedUrl);\n    if (interceptor) {\n      interceptor.interceptXhr(xhr, modifiedUrl);\n    }\n    const onError = () => {\n      vectorSource.removeLoadedExtent(extent);\n      failure();\n    };\n    xhr.onerror = onError;\n    xhr.onload = () => {\n      if (xhr.status === 200 && xhr.responseText.length > 0) {\n        const features = vectorSource\n          .getFormat()\n          .readFeatures(xhr.responseText, {\n            dataProjection,\n            featureProjection\n          }) as olFeature<OlGeometry>[];\n        // TODO Manage \"More feature\"\n        /*if (features.length === 0 || features.length < threshold ) {\n          console.log('No more data to download at this resolution');\n        }*/\n        // Avoids retrieving an older call that took longer to be process\n        if (\n          idAssociatedCall ===\n          (this.dataSource as WFSDataSource).mostRecentIdCallOGCFilter\n        ) {\n          vectorSource.addFeatures(features);\n          success(features);\n        } else {\n          success([]);\n        }\n      } else {\n        onError();\n      }\n    };\n    xhr.send();\n  }\n\n  /**\n   * Custom loader for vector layer.\n   * @internal\n   * @param vectorSource the vector source to be created\n   * @param url the url string or function to retrieve the data\n   * @param interceptor the interceptor of the data\n   * @param extent the extent of the requested data\n   * @param resolution the current resolution\n   * @param projection the projection to retrieve the data\n   */\n  private customLoader(\n    vectorSource,\n    url,\n    interceptor,\n    extent,\n    resolution,\n    projection,\n    success,\n    failure\n  ) {\n    const xhr = new XMLHttpRequest();\n    let modifiedUrl = url;\n    if (typeof url !== 'function') {\n      const alteredUrlWithKeyAuth = interceptor.alterUrlWithKeyAuth(url);\n      if (alteredUrlWithKeyAuth) {\n        modifiedUrl = alteredUrlWithKeyAuth;\n      }\n    } else {\n      modifiedUrl = url(extent, resolution, projection);\n    }\n\n    if (this.geoNetworkService && typeof url !== 'function') {\n      const format = vectorSource.getFormat();\n      const type = format.getType();\n\n      let responseType = type;\n      const onError = () => {\n        vectorSource.removeLoadedExtent(extent);\n        failure();\n      };\n\n      const options: SimpleGetOptions = { responseType };\n      this.geoNetworkService.geoDBService\n        .get(url)\n        .pipe(delay(750))\n        .pipe(\n          concatMap((r) =>\n            r\n              ? of(r)\n              : this.geoNetworkService.get(modifiedUrl, options).pipe(\n                  first(),\n                  catchError((res) => {\n                    onError();\n                    throw res;\n                  })\n                )\n          )\n        )\n        .subscribe((content) => {\n          if (content) {\n            const format = vectorSource.getFormat();\n            const type = format.getType();\n            let source;\n            if (type === 'json' || type === 'text') {\n              source = content;\n            } else if (type === 'xml') {\n              source = content;\n              if (!source) {\n                source = new DOMParser().parseFromString(\n                  content,\n                  'application/xml'\n                );\n              }\n            } else if (type === 'arraybuffer') {\n              source = content;\n            }\n            if (source) {\n              const features = format.readFeatures(source, {\n                extent,\n                featureProjection: projection\n              });\n              vectorSource.addFeatures(features, format.readProjection(source));\n              success(features);\n            } else {\n              onError();\n            }\n          }\n        });\n    } else {\n      xhr.open('GET', modifiedUrl);\n      const format = vectorSource.getFormat();\n      if (format.getType() === 'arraybuffer') {\n        xhr.responseType = 'arraybuffer';\n      }\n      if (interceptor) {\n        interceptor.interceptXhr(xhr, modifiedUrl);\n      }\n\n      const onError = () => {\n        vectorSource.removeLoadedExtent(extent);\n        failure();\n      };\n      xhr.onerror = onError;\n      xhr.onload = () => {\n        // status will be 0 for file:// urls\n        if (!xhr.status || (xhr.status >= 200 && xhr.status < 300)) {\n          const type = format.getType();\n          let source;\n          if (type === 'json' || type === 'text') {\n            source = xhr.responseText;\n          } else if (type === 'xml') {\n            source = xhr.responseXML;\n            if (!source) {\n              source = new DOMParser().parseFromString(\n                xhr.responseText,\n                'application/xml'\n              );\n            }\n          } else if (type === 'arraybuffer') {\n            source = xhr.response;\n          }\n          if (source) {\n            const features = format.readFeatures(source, {\n              extent,\n              featureProjection: projection\n            });\n            vectorSource.addFeatures(features, format.readProjection(source));\n            success(features);\n          } else {\n            onError();\n          }\n        } else {\n          onError();\n        }\n      };\n      xhr.send();\n    }\n  }\n\n  /**\n   * Custom loader for vector layer.\n   * @internal\n   * @param vectorSource the vector source to be created\n   * @param layerID the url string or function to retrieve the data\n   * @param interceptor the interceptor of the data\n   * @param extent the extent of the requested data\n   * @param resolution the current resolution\n   * @param projection the projection to retrieve the data\n   */\n  private customIDBLoader(\n    vectorSource,\n    layerID,\n    extent,\n    projection,\n    success,\n    failure\n  ) {\n    if (this.geoNetworkService) {\n      const onError = () => {\n        vectorSource.removeLoadedExtent(extent);\n        failure();\n      };\n      this.geoNetworkService.geoDBService.get(layerID).subscribe((content) => {\n        if (content) {\n          const format = vectorSource.getFormat();\n          const type = format.getType();\n          let source;\n          if (type === 'json' || type === 'text') {\n            source = content;\n          } else if (type === 'xml') {\n            source = content;\n            if (!source) {\n              source = new DOMParser().parseFromString(\n                content,\n                'application/xml'\n              );\n            }\n          } else if (type === 'arraybuffer') {\n            source = content;\n          }\n          if (source) {\n            const features = format.readFeatures(source, {\n              extent,\n              featureProjection: projection\n            });\n            vectorSource.addFeatures(features, format.readProjection(source));\n            success(features);\n          } else {\n            onError();\n          }\n        }\n      });\n    }\n  }\n}\n"]}