@igo2/geo 1.15.4 → 16.0.0-rc.0

package/esm2022/lib/directions/directions-sources/directions-source.provider.mjs

@@ -0,0 +1,16 @@
+import { HttpClient } from '@angular/common/http';
+import { ConfigService } from '@igo2/core';
+import { DirectionsSource } from './directions-source';
+import { OsrmDirectionsSource } from './osrm-directions-source';
+export function osrmDirectionsSourcesFactory(http, config) {
+    return new OsrmDirectionsSource(http, config);
+}
+export function provideOsrmDirectionsSource() {
+    return {
+        provide: DirectionsSource,
+        useFactory: osrmDirectionsSourcesFactory,
+        multi: true,
+        deps: [HttpClient, ConfigService]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlyZWN0aW9ucy1zb3VyY2UucHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kaXJlY3Rpb25zL2RpcmVjdGlvbnMtc291cmNlcy9kaXJlY3Rpb25zLXNvdXJjZS5wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFbEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUzQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUVoRSxNQUFNLFVBQVUsNEJBQTRCLENBQzFDLElBQWdCLEVBQ2hCLE1BQXFCO0lBRXJCLE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDaEQsQ0FBQztBQUVELE1BQU0sVUFBVSwyQkFBMkI7SUFDekMsT0FBTztRQUNMLE9BQU8sRUFBRSxnQkFBZ0I7UUFDekIsVUFBVSxFQUFFLDRCQUE0QjtRQUN4QyxLQUFLLEVBQUUsSUFBSTtRQUNYLElBQUksRUFBRSxDQUFDLFVBQVUsRUFBRSxhQUFhLENBQUM7S0FDbEMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwQ2xpZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuXG5pbXBvcnQgeyBDb25maWdTZXJ2aWNlIH0gZnJvbSAnQGlnbzIvY29yZSc7XG5cbmltcG9ydCB7IERpcmVjdGlvbnNTb3VyY2UgfSBmcm9tICcuL2RpcmVjdGlvbnMtc291cmNlJztcbmltcG9ydCB7IE9zcm1EaXJlY3Rpb25zU291cmNlIH0gZnJvbSAnLi9vc3JtLWRpcmVjdGlvbnMtc291cmNlJztcblxuZXhwb3J0IGZ1bmN0aW9uIG9zcm1EaXJlY3Rpb25zU291cmNlc0ZhY3RvcnkoXG4gIGh0dHA6IEh0dHBDbGllbnQsXG4gIGNvbmZpZzogQ29uZmlnU2VydmljZVxuKSB7XG4gIHJldHVybiBuZXcgT3NybURpcmVjdGlvbnNTb3VyY2UoaHR0cCwgY29uZmlnKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVPc3JtRGlyZWN0aW9uc1NvdXJjZSgpIHtcbiAgcmV0dXJuIHtcbiAgICBwcm92aWRlOiBEaXJlY3Rpb25zU291cmNlLFxuICAgIHVzZUZhY3Rvcnk6IG9zcm1EaXJlY3Rpb25zU291cmNlc0ZhY3RvcnksXG4gICAgbXVsdGk6IHRydWUsXG4gICAgZGVwczogW0h0dHBDbGllbnQsIENvbmZpZ1NlcnZpY2VdXG4gIH07XG59XG4iXX0=

package/esm2022/lib/directions/directions-sources/index.mjs

@@ -0,0 +1,5 @@
+export * from './directions-source';
+export * from './directions-source.interface';
+export * from './osrm-directions-source';
+export * from './directions-source.provider';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kaXJlY3Rpb25zL2RpcmVjdGlvbnMtc291cmNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaXJlY3Rpb25zLXNvdXJjZSc7XG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGlvbnMtc291cmNlLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL29zcm0tZGlyZWN0aW9ucy1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3Rpb25zLXNvdXJjZS5wcm92aWRlcic7XG4iXX0=

package/esm2022/lib/directions/directions-sources/osrm-directions-source.mjs

@@ -0,0 +1,128 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Cacheable } from 'ts-cacheable';
+import { customCacheHasher, uuid } from '@igo2/utils';
+import { ConfigService } from '@igo2/core';
+import { DirectionsFormat, SourceDirectionsType } from '../shared/directions.enum';
+import { DirectionsSource } from './directions-source';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@igo2/core";
+export class OsrmDirectionsSource extends DirectionsSource {
+    http;
+    config;
+    get enabled() {
+        return this.options.enabled !== false;
+    }
+    set enabled(value) {
+        this.options.enabled = value;
+    }
+    static _name = 'OSRM Québec';
+    directionsUrl = 'https://geoegl.msp.gouv.qc.ca/services/itineraire/route/v1/driving/';
+    options;
+    constructor(http, config) {
+        super();
+        this.http = http;
+        this.config = config;
+        this.options = this.config.getConfig('directionsSources.osrm') || {};
+        this.directionsUrl = this.options.url || this.directionsUrl;
+    }
+    getName() {
+        return OsrmDirectionsSource._name;
+    }
+    route(coordinates, directionsOptions = {}) {
+        const directionsParams = this.getRouteParams(directionsOptions);
+        return this.getRoute(coordinates, directionsParams);
+    }
+    getRoute(coordinates, params) {
+        return this.http
+            .get(this.directionsUrl + coordinates.join(';'), {
+            params
+        })
+            .pipe(map((res) => this.extractRoutesData(res)));
+    }
+    extractRoutesData(response) {
+        const routeResponse = [];
+        response.routes.forEach((route) => {
+            routeResponse.push(this.formatRoute(route, response.waypoints));
+        });
+        return routeResponse;
+    }
+    getRouteParams(directionsOptions = {}) {
+        directionsOptions.alternatives =
+            directionsOptions.alternatives !== undefined
+                ? directionsOptions.alternatives
+                : true;
+        directionsOptions.steps =
+            directionsOptions.steps !== undefined ? directionsOptions.steps : true;
+        directionsOptions.geometries =
+            directionsOptions.geometries !== undefined
+                ? directionsOptions.geometries
+                : 'geojson';
+        directionsOptions.overview =
+            directionsOptions.overview !== undefined
+                ? directionsOptions.overview
+                : false;
+        directionsOptions.continue_straight =
+            directionsOptions.continue_straight !== undefined
+                ? directionsOptions.continue_straight
+                : false;
+        return new HttpParams({
+            fromObject: {
+                alternatives: directionsOptions.alternatives ? 'true' : 'false',
+                overview: directionsOptions.overview ? 'simplified' : 'full',
+                steps: directionsOptions.steps ? 'true' : 'false',
+                geometries: directionsOptions.geometries
+                    ? directionsOptions.geometries
+                    : 'geojson',
+                continue_straight: directionsOptions.continue_straight
+                    ? 'true'
+                    : 'false'
+            }
+        });
+    }
+    formatRoute(roadNetworkRoute, waypoints) {
+        const stepsUI = [];
+        roadNetworkRoute.legs.forEach((leg) => {
+            leg.steps.forEach((step) => {
+                stepsUI.push(step);
+            });
+        });
+        return {
+            id: uuid(),
+            title: roadNetworkRoute.legs[0].summary,
+            source: OsrmDirectionsSource._name,
+            sourceType: SourceDirectionsType.Route,
+            order: 1,
+            format: DirectionsFormat.GeoJSON,
+            icon: 'directions',
+            projection: 'EPSG:4326',
+            waypoints,
+            distance: roadNetworkRoute.distance,
+            duration: roadNetworkRoute.duration,
+            geometry: roadNetworkRoute.geometry,
+            legs: roadNetworkRoute.legs,
+            steps: stepsUI,
+            weight: roadNetworkRoute.weight,
+            weight_name: roadNetworkRoute.weight_name
+        };
+    }
+    static ɵfac = function OsrmDirectionsSource_Factory(t) { return new (t || OsrmDirectionsSource)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: OsrmDirectionsSource, factory: OsrmDirectionsSource.ɵfac });
+}
+__decorate([
+    Cacheable({
+        maxCacheCount: 20,
+        cacheHasher: customCacheHasher
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, HttpParams]),
+    __metadata("design:returntype", Observable)
+], OsrmDirectionsSource.prototype, "getRoute", null);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OsrmDirectionsSource, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; }, { getRoute: [] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"osrm-directions-source.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/directions/directions-sources/osrm-directions-source.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpParams } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\n\r\nimport { Cacheable } from 'ts-cacheable';\r\n\r\nimport { customCacheHasher, uuid } from '@igo2/utils';\r\nimport { ConfigService } from '@igo2/core';\r\n\r\nimport { Direction, DirectionOptions } from '../shared/directions.interface';\r\nimport {\r\n  DirectionsFormat,\r\n  SourceDirectionsType\r\n} from '../shared/directions.enum';\r\n\r\nimport { DirectionsSource } from './directions-source';\r\nimport { DirectionsSourceOptions } from './directions-source.interface';\r\n\r\n@Injectable()\r\nexport class OsrmDirectionsSource extends DirectionsSource {\r\n  get enabled(): boolean {\r\n    return this.options.enabled !== false;\r\n  }\r\n  set enabled(value: boolean) {\r\n    this.options.enabled = value;\r\n  }\r\n  static _name = 'OSRM Québec';\r\n  private directionsUrl =\r\n    'https://geoegl.msp.gouv.qc.ca/services/itineraire/route/v1/driving/';\r\n  private options: DirectionsSourceOptions;\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private config: ConfigService\r\n  ) {\r\n    super();\r\n    this.options = this.config.getConfig('directionsSources.osrm') || {};\r\n    this.directionsUrl = this.options.url || this.directionsUrl;\r\n  }\r\n\r\n  getName(): string {\r\n    return OsrmDirectionsSource._name;\r\n  }\r\n\r\n  route(\r\n    coordinates: [number, number][],\r\n    directionsOptions: DirectionOptions = {}\r\n  ): Observable<Direction[]> {\r\n    const directionsParams = this.getRouteParams(directionsOptions);\r\n    return this.getRoute(coordinates, directionsParams);\r\n  }\r\n\r\n  @Cacheable({\r\n    maxCacheCount: 20,\r\n    cacheHasher: customCacheHasher\r\n  })\r\n  private getRoute(\r\n    coordinates: [number, number][],\r\n    params: HttpParams\r\n  ): Observable<Direction[]> {\r\n    return this.http\r\n      .get<JSON[]>(this.directionsUrl + coordinates.join(';'), {\r\n        params\r\n      })\r\n      .pipe(map((res) => this.extractRoutesData(res)));\r\n  }\r\n\r\n  private extractRoutesData(response): Direction[] {\r\n    const routeResponse = [];\r\n    response.routes.forEach((route) => {\r\n      routeResponse.push(this.formatRoute(route, response.waypoints));\r\n    });\r\n    return routeResponse;\r\n  }\r\n\r\n  private getRouteParams(directionsOptions: DirectionOptions = {}): HttpParams {\r\n    directionsOptions.alternatives =\r\n      directionsOptions.alternatives !== undefined\r\n        ? directionsOptions.alternatives\r\n        : true;\r\n    directionsOptions.steps =\r\n      directionsOptions.steps !== undefined ? directionsOptions.steps : true;\r\n    directionsOptions.geometries =\r\n      directionsOptions.geometries !== undefined\r\n        ? directionsOptions.geometries\r\n        : 'geojson';\r\n    directionsOptions.overview =\r\n      directionsOptions.overview !== undefined\r\n        ? directionsOptions.overview\r\n        : false;\r\n    directionsOptions.continue_straight =\r\n      directionsOptions.continue_straight !== undefined\r\n        ? directionsOptions.continue_straight\r\n        : false;\r\n\r\n    return new HttpParams({\r\n      fromObject: {\r\n        alternatives: directionsOptions.alternatives ? 'true' : 'false',\r\n        overview: directionsOptions.overview ? 'simplified' : 'full',\r\n        steps: directionsOptions.steps ? 'true' : 'false',\r\n        geometries: directionsOptions.geometries\r\n          ? directionsOptions.geometries\r\n          : 'geojson',\r\n        continue_straight: directionsOptions.continue_straight\r\n          ? 'true'\r\n          : 'false'\r\n      }\r\n    });\r\n  }\r\n\r\n  private formatRoute(roadNetworkRoute: any, waypoints: any): Direction {\r\n    const stepsUI = [];\r\n    roadNetworkRoute.legs.forEach((leg) => {\r\n      leg.steps.forEach((step) => {\r\n        stepsUI.push(step);\r\n      });\r\n    });\r\n    return {\r\n      id: uuid(),\r\n      title: roadNetworkRoute.legs[0].summary,\r\n      source: OsrmDirectionsSource._name,\r\n      sourceType: SourceDirectionsType.Route,\r\n      order: 1,\r\n      format: DirectionsFormat.GeoJSON,\r\n      icon: 'directions',\r\n      projection: 'EPSG:4326',\r\n      waypoints,\r\n      distance: roadNetworkRoute.distance,\r\n      duration: roadNetworkRoute.duration,\r\n      geometry: roadNetworkRoute.geometry,\r\n      legs: roadNetworkRoute.legs,\r\n      steps: stepsUI,\r\n      weight: roadNetworkRoute.weight,\r\n      weight_name: roadNetworkRoute.weight_name\r\n    };\r\n  }\r\n}\r\n"]}

package/esm2022/lib/directions/directions.component.mjs

@@ -0,0 +1,349 @@
+import { ChangeDetectorRef, Component, Input } from '@angular/core';
+import { debounceTime, distinctUntilChanged, map } from 'rxjs/operators';
+import { LanguageService } from '@igo2/core';
+import { EntityStoreWatcher } from '@igo2/common';
+import * as olCondition from 'ol/events/condition';
+import * as olInteraction from 'ol/interaction';
+import * as olProj from 'ol/proj';
+import { Subject } from 'rxjs';
+import { addDirectionToRoutesFeatureStore, addStopToStopsFeatureStore, addStopToStore, initRoutesFeatureStore, initStepFeatureStore, initStopsFeatureStore, updateStoreSorting } from './shared/directions.utils';
+import { DirectionsService } from './shared/directions.service';
+import { DirectionType, ProposalType } from './shared/directions.enum';
+import { roundCoordTo, stringToLonLat } from '../map';
+import { SearchService } from '../search/shared/search.service';
+import { ChangeUtils, ObjectUtils } from '@igo2/utils';
+import { RoutesFeatureStore, StepFeatureStore, StopsFeatureStore, StopsStore } from './shared/store';
+import { FeatureStoreLoadingStrategy } from '../feature/shared/strategies/loading';
+import { QueryService } from '../query/shared/query.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+import * as i2 from "./shared/directions.service";
+import * as i3 from "../search/shared/search.service";
+import * as i4 from "../query/shared/query.service";
+import * as i5 from "./directions-inputs/directions-inputs.component";
+import * as i6 from "./directions-buttons/directions-buttons.component";
+import * as i7 from "./directions-results/directions-results.component";
+export class DirectionsComponent {
+    cdRef;
+    languageService;
+    directionsService;
+    searchService;
+    queryService;
+    watcher;
+    projection = 'EPSG:4326';
+    zoomRoute$$;
+    storeEmpty$$;
+    storeChange$$;
+    routesQueries$$ = [];
+    selectStopInteraction;
+    translateStop;
+    selectedRoute;
+    focusOnStop = false;
+    isTranslating = false;
+    previousStops = [];
+    searchs$$ = [];
+    contextUri;
+    stopsStore;
+    stopsFeatureStore;
+    routesFeatureStore;
+    stepFeatureStore;
+    debounce = 200;
+    length = 2;
+    coordRoundedDecimals = 6;
+    zoomToActiveRoute$ = new Subject();
+    constructor(cdRef, languageService, directionsService, searchService, queryService) {
+        this.cdRef = cdRef;
+        this.languageService = languageService;
+        this.directionsService = directionsService;
+        this.searchService = searchService;
+        this.queryService = queryService;
+    }
+    ngOnInit() {
+        this.queryService.queryEnabled = false;
+        this.initEntityStores();
+        setTimeout(() => {
+            initStopsFeatureStore(this.stopsFeatureStore, this.languageService);
+            initRoutesFeatureStore(this.routesFeatureStore, this.languageService);
+            initStepFeatureStore(this.stepFeatureStore);
+            this.initOlInteraction();
+        }, 1);
+    }
+    ngOnDestroy() {
+        this.queryService.queryEnabled = true;
+        this.storeEmpty$$.unsubscribe();
+        this.storeChange$$.unsubscribe();
+        this.routesQueries$$.map((u) => u.unsubscribe());
+        this.zoomRoute$$.unsubscribe();
+        this.freezeStores();
+    }
+    freezeStores() {
+        this.stopsFeatureStore.layer.map.ol.removeInteraction(this.selectStopInteraction);
+        this.stopsFeatureStore.layer.map.ol.removeInteraction(this.translateStop);
+        this.routesFeatureStore.layer.map.ol.removeInteraction(this.selectedRoute);
+        this.stopsFeatureStore.deactivateStrategyOfType(FeatureStoreLoadingStrategy);
+        this.routesFeatureStore.deactivateStrategyOfType(FeatureStoreLoadingStrategy);
+        this.stepFeatureStore.deactivateStrategyOfType(FeatureStoreLoadingStrategy);
+    }
+    initEntityStores() {
+        this.watcher = new EntityStoreWatcher(this.stopsStore, this.cdRef);
+        this.monitorEmptyEntityStore();
+        this.monitorEntityStoreChange();
+        this.monitorActiveRouteZoom();
+    }
+    monitorActiveRouteZoom() {
+        this.zoomRoute$$ = this.zoomToActiveRoute$.subscribe(() => {
+            if (this.routesFeatureStore.count >= 1) {
+                const activeRoute = this.routesFeatureStore
+                    .all()
+                    .find((route) => route.properties.active);
+                if (activeRoute) {
+                    activeRoute.ol.getGeometry();
+                    const routeExtent = activeRoute.ol.getGeometry().getExtent();
+                    this.routesFeatureStore.layer.map.viewController.zoomToExtent(routeExtent);
+                }
+            }
+        });
+    }
+    initOlInteraction() {
+        this.selectStopInteraction = new olInteraction.Select({
+            layers: [this.stopsFeatureStore.layer.ol],
+            hitTolerance: 7,
+            condition: (event) => {
+                return event.type === 'pointermove' && !event.dragging;
+            }
+        });
+        this.translateStop = new olInteraction.Translate({
+            features: this.selectStopInteraction.getFeatures()
+        });
+        this.translateStop.on('translating', (evt) => {
+            this.isTranslating = true;
+            this.executeStopTranslation(evt.features);
+        });
+        this.translateStop.on('translateend', (evt) => {
+            this.isTranslating = false;
+            this.executeStopTranslation(evt.features);
+        });
+        this.selectedRoute = new olInteraction.Select({
+            layers: [this.routesFeatureStore.layer.ol],
+            condition: olCondition.click,
+            hitTolerance: 7,
+            filter: (feature) => {
+                return (feature.get('type') === DirectionType.Route &&
+                    feature.get('active') &&
+                    !this.isTranslating);
+            }
+        });
+        this.selectedRoute.on('select', (evt) => {
+            if (this.focusOnStop === false) {
+                const selectCoordinates = roundCoordTo(olProj.transform(evt.mapBrowserEvent.coordinate, this.routesFeatureStore.layer.map.projection, this.projection), this.coordRoundedDecimals);
+                const addedStop = addStopToStore(this.stopsStore);
+                addedStop.text = selectCoordinates.join(',');
+                addedStop.coordinates = [selectCoordinates[0], selectCoordinates[1]];
+            }
+        });
+        this.stopsFeatureStore.layer.map.ol.addInteraction(this.selectStopInteraction);
+        this.stopsFeatureStore.layer.map.ol.addInteraction(this.translateStop);
+        this.routesFeatureStore.layer.map.ol.addInteraction(this.selectedRoute);
+    }
+    onStopInputHasFocusChange(stopInputHasFocus) {
+        stopInputHasFocus
+            ? this.routesFeatureStore.layer.map.ol.removeInteraction(this.selectedRoute)
+            : this.routesFeatureStore.layer.map.ol.addInteraction(this.selectedRoute);
+    }
+    executeStopTranslation(features) {
+        if (features.getLength() === 0) {
+            return;
+        }
+        const firstFeature = features.getArray()[0];
+        const translatedStopId = firstFeature.getId();
+        const translationCoordinates = olProj.transform(firstFeature.getGeometry().getCoordinates(), this.stopsFeatureStore.layer.map.projection, this.projection);
+        const translatedStop = this.stopsStore.get(translatedStopId);
+        const roundedCoord = roundCoordTo(translationCoordinates, this.coordRoundedDecimals);
+        translatedStop.coordinates = roundedCoord;
+        translatedStop.text = roundedCoord.join(',');
+        this.stopsStore.update(translatedStop);
+    }
+    monitorEmptyEntityStore() {
+        // Watch if the store is empty to reset it
+        this.storeEmpty$$ = this.stopsStore.count$
+            .pipe(distinctUntilChanged())
+            .subscribe((count) => {
+            if (count < 2) {
+                addStopToStore(this.stopsStore);
+                if (this.stopsStore.count === 2) {
+                    this.stopsStore.storeInitialized$.next(true);
+                    return;
+                }
+                this.stopsStore.storeInitialized$.next(false);
+            }
+            this.routesQueries$$.map((u) => u.unsubscribe());
+        });
+    }
+    monitorEntityStoreChange() {
+        this.storeChange$$ = this.stopsStore.entities$
+            .pipe(debounceTime(this.debounce))
+            .subscribe((stops) => {
+            this.handleStopDiff(stops);
+            updateStoreSorting(this.stopsStore);
+            this.handleStopsFeature();
+            this.getRoutes(this.isTranslating);
+        });
+    }
+    cancelSearch() {
+        this.searchs$$.map((s) => s.unsubscribe());
+    }
+    handleStopDiff(stops) {
+        const simplifiedStops = stops.map((stop) => {
+            return ObjectUtils.removeUndefined({
+                ...{ id: stop.id, text: stop.text, coordinates: stop.coordinates }
+            });
+        });
+        const diff = ChangeUtils.findChanges(this.previousStops, simplifiedStops, [
+            'coordinates'
+        ]);
+        const stopIdToProcess = diff.added.concat(diff.modified);
+        if (stopIdToProcess) {
+            stopIdToProcess.map((change) => {
+                const changedStop = change.newValue;
+                if (changedStop) {
+                    const stop = this.stopsStore.get(changedStop.id);
+                    const term = stop.text;
+                    if (!term || term.length === 0) {
+                        return;
+                    }
+                    const response = stringToLonLat(term, this.stopsFeatureStore.layer.map.projection);
+                    let researches;
+                    let isCoord = false;
+                    if (response.lonLat) {
+                        isCoord = true;
+                    }
+                    researches = this.searchService.search(term, {
+                        searchType: 'Feature'
+                    });
+                    this.cancelSearch();
+                    const requests$ = researches.map((res) => res.request.pipe(map((results) => results.filter((r) => isCoord
+                        ? r.data.geometry.type === 'Point' && r.data.geometry
+                        : r.data.geometry))));
+                    this.searchs$$ = requests$.map((request) => {
+                        return request
+                            .pipe(map((results) => results.filter((r) => isCoord
+                            ? r.data.geometry.type === 'Point' && r.data.geometry
+                            : r.data.geometry)))
+                            .subscribe((res) => {
+                            if (res.length > 0) {
+                                const source = res[0].source;
+                                const meta = res[0].meta;
+                                const results = res.map((r) => r.data);
+                                if (!stop.searchProposals) {
+                                    stop.searchProposals = [];
+                                }
+                                stop.searchProposals = stop.searchProposals.filter((sp) => sp.type ===
+                                    (isCoord ? ProposalType.Coord : ProposalType.Text));
+                                let storedSource = stop.searchProposals.find((sp) => sp.source === source);
+                                if (storedSource) {
+                                    storedSource.results = results;
+                                }
+                                else {
+                                    stop.searchProposals.push({
+                                        type: isCoord ? ProposalType.Coord : ProposalType.Text,
+                                        source,
+                                        meta,
+                                        results
+                                    });
+                                }
+                            }
+                            this.cdRef.detectChanges();
+                        });
+                    });
+                }
+            });
+        }
+        this.previousStops = simplifiedStops;
+    }
+    handleStopsFeature() {
+        const stops = this.stopsStore.all();
+        const stopsWithCoordinates = stops.filter((stop) => stop.coordinates);
+        stopsWithCoordinates.map((stop) => this.addStopOverlay(stop));
+        this.stopsFeatureStore
+            .all()
+            .map((stopFeature) => {
+            if (!this.stopsStore.get(stopFeature.properties.id)) {
+                this.stopsFeatureStore.delete(stopFeature);
+            }
+        });
+        const stopsWithoutCoordinates = stops.filter((stop) => !stop.coordinates);
+        stopsWithoutCoordinates.map((stop) => {
+            const stopFeature = this.stopsFeatureStore.get(stop.id);
+            if (stopFeature) {
+                this.stopsFeatureStore.delete(stopFeature);
+            }
+        });
+    }
+    getRoutes(isOverview = false) {
+        const stopsWithCoordinates = this.stopsStore.view
+            .all()
+            .filter((stop) => stop.coordinates);
+        if (stopsWithCoordinates.length < 2) {
+            this.routesFeatureStore.deleteMany(this.routesFeatureStore.all());
+            return;
+        }
+        const roundedCoordinates = stopsWithCoordinates.map((stop) => {
+            const roundedCoord = roundCoordTo(stop.coordinates, this.coordRoundedDecimals);
+            return roundedCoord;
+        });
+        const overviewDirectionsOptions = {
+            overview: true,
+            steps: false,
+            alternatives: false,
+            continue_straight: false
+        };
+        this.routesQueries$$.map((u) => u.unsubscribe());
+        const routeResponse = this.directionsService.route(roundedCoordinates, isOverview ? overviewDirectionsOptions : undefined);
+        if (routeResponse) {
+            routeResponse.map((res) => this.routesQueries$$.push(res.subscribe((directions) => {
+                this.routesFeatureStore.deleteMany(this.routesFeatureStore.all());
+                directions.map((direction) => addDirectionToRoutesFeatureStore(this.routesFeatureStore, direction, this.projection, direction === directions[0] ? true : false));
+            })));
+        }
+    }
+    addStopOverlay(stop) {
+        addStopToStopsFeatureStore(stop, this.stopsStore, this.stopsFeatureStore, this.projection, this.languageService);
+    }
+    static ɵfac = function DirectionsComponent_Factory(t) { return new (t || DirectionsComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i1.LanguageService), i0.ɵɵdirectiveInject(i2.DirectionsService), i0.ɵɵdirectiveInject(i3.SearchService), i0.ɵɵdirectiveInject(i4.QueryService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: DirectionsComponent, selectors: [["igo-directions"]], inputs: { contextUri: "contextUri", stopsStore: "stopsStore", stopsFeatureStore: "stopsFeatureStore", routesFeatureStore: "routesFeatureStore", stepFeatureStore: "stepFeatureStore", debounce: "debounce", length: "length", coordRoundedDecimals: "coordRoundedDecimals", zoomToActiveRoute$: "zoomToActiveRoute$" }, decls: 3, vars: 13, consts: [[3, "stepFeatureStore", "contextUri", "zoomToActiveRoute$", "routesFeatureStore", "stopsStore"], [3, "coordRoundedDecimals", "projection", "stopsFeatureStore", "stopsStore", "debounce", "length", "stopInputHasFocus"], [3, "stepFeatureStore", "routesFeatureStore"]], template: function DirectionsComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "igo-directions-buttons", 0);
+            i0.ɵɵelementStart(1, "igo-directions-inputs", 1);
+            i0.ɵɵlistener("stopInputHasFocus", function DirectionsComponent_Template_igo_directions_inputs_stopInputHasFocus_1_listener($event) { return ctx.onStopInputHasFocusChange($event); });
+            i0.ɵɵelementEnd();
+            i0.ɵɵelement(2, "igo-directions-results", 2);
+        } if (rf & 2) {
+            i0.ɵɵproperty("stepFeatureStore", ctx.stepFeatureStore)("contextUri", ctx.contextUri)("zoomToActiveRoute$", ctx.zoomToActiveRoute$)("routesFeatureStore", ctx.routesFeatureStore)("stopsStore", ctx.stopsStore);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("coordRoundedDecimals", ctx.coordRoundedDecimals)("projection", ctx.projection)("stopsFeatureStore", ctx.stopsFeatureStore)("stopsStore", ctx.stopsStore)("debounce", ctx.debounce)("length", ctx.length);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("stepFeatureStore", ctx.stepFeatureStore)("routesFeatureStore", ctx.routesFeatureStore);
+        } }, dependencies: [i5.DirectionsInputsComponent, i6.DirectionsButtonsComponent, i7.DirectionsResultsComponent] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DirectionsComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-directions', template: "<igo-directions-buttons\r\n  [stepFeatureStore]=\"stepFeatureStore\"\r\n  [contextUri]=\"contextUri\"\r\n  [zoomToActiveRoute$]=\"zoomToActiveRoute$\"\r\n  [routesFeatureStore]=\"routesFeatureStore\"\r\n  [stopsStore]=\"stopsStore\"\r\n></igo-directions-buttons>\r\n\r\n<igo-directions-inputs\r\n  (stopInputHasFocus)=\"onStopInputHasFocusChange($event)\"\r\n  [coordRoundedDecimals]=\"coordRoundedDecimals\"\r\n  [projection]=\"projection\"\r\n  [stopsFeatureStore]=\"stopsFeatureStore\"\r\n  [stopsStore]=\"stopsStore\"\r\n  [debounce]=\"debounce\"\r\n  [length]=\"length\"\r\n></igo-directions-inputs>\r\n\r\n<igo-directions-results\r\n  [stepFeatureStore]=\"stepFeatureStore\"\r\n  [routesFeatureStore]=\"routesFeatureStore\"\r\n></igo-directions-results>\r\n" }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.LanguageService }, { type: i2.DirectionsService }, { type: i3.SearchService }, { type: i4.QueryService }]; }, { contextUri: [{
+            type: Input
+        }], stopsStore: [{
+            type: Input
+        }], stopsFeatureStore: [{
+            type: Input
+        }], routesFeatureStore: [{
+            type: Input
+        }], stepFeatureStore: [{
+            type: Input
+        }], debounce: [{
+            type: Input
+        }], length: [{
+            type: Input
+        }], coordRoundedDecimals: [{
+            type: Input
+        }], zoomToActiveRoute$: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directions.component.js","sourceRoot":"","sources":["../../../../../packages/geo/src/lib/directions/directions.component.ts","../../../../../packages/geo/src/lib/directions/directions.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit\r\n} from '@angular/core';\r\n\r\nimport { debounceTime, distinctUntilChanged, map } from 'rxjs/operators';\r\n\r\nimport { LanguageService } from '@igo2/core';\r\nimport { EntityStoreWatcher } from '@igo2/common';\r\n\r\nimport * as olCondition from 'ol/events/condition';\r\nimport * as olInteraction from 'ol/interaction';\r\nimport * as olProj from 'ol/proj';\r\nimport { TranslateEvent } from 'ol/interaction/Translate';\r\nimport Collection from 'ol/Collection';\r\nimport { SelectEvent } from 'ol/interaction/Select';\r\n\r\nimport {\r\n  DirectionOptions,\r\n  FeatureWithStopProperties,\r\n  Stop\r\n} from './shared/directions.interface';\r\nimport { Subject, Subscription } from 'rxjs';\r\nimport {\r\n  addDirectionToRoutesFeatureStore,\r\n  addStopToStopsFeatureStore,\r\n  addStopToStore,\r\n  initRoutesFeatureStore,\r\n  initStepFeatureStore,\r\n  initStopsFeatureStore,\r\n  updateStoreSorting\r\n} from './shared/directions.utils';\r\nimport { Feature } from '../feature/shared/feature.interfaces';\r\nimport { DirectionsService } from './shared/directions.service';\r\nimport { DirectionType, ProposalType } from './shared/directions.enum';\r\nimport { roundCoordTo, stringToLonLat } from '../map';\r\nimport { SearchService } from '../search/shared/search.service';\r\nimport { ChangeUtils, ObjectUtils } from '@igo2/utils';\r\nimport {\r\n  RoutesFeatureStore,\r\n  StepFeatureStore,\r\n  StopsFeatureStore,\r\n  StopsStore\r\n} from './shared/store';\r\nimport { FeatureStoreLoadingStrategy } from '../feature/shared/strategies/loading';\r\nimport { Research, SearchResult } from '../search/shared/search.interfaces';\r\nimport { QueryService } from '../query/shared/query.service';\r\n\r\n@Component({\r\n  selector: 'igo-directions',\r\n  templateUrl: './directions.component.html',\r\n  styleUrls: ['./directions.component.scss']\r\n})\r\nexport class DirectionsComponent implements OnInit, OnDestroy {\r\n  private watcher: EntityStoreWatcher<Stop>;\r\n\r\n  public projection: string = 'EPSG:4326';\r\n\r\n  private zoomRoute$$: Subscription;\r\n  private storeEmpty$$: Subscription;\r\n  private storeChange$$: Subscription;\r\n  private routesQueries$$: Subscription[] = [];\r\n\r\n  private selectStopInteraction: olInteraction.Select;\r\n  private translateStop: olInteraction.Translate;\r\n  private selectedRoute;\r\n  private focusOnStop: boolean = false;\r\n  private isTranslating: boolean = false;\r\n\r\n  public previousStops: Stop[] = [];\r\n\r\n  private searchs$$: Subscription[] = [];\r\n\r\n  @Input() contextUri: string;\r\n  @Input() stopsStore: StopsStore;\r\n  @Input() stopsFeatureStore: StopsFeatureStore;\r\n  @Input() routesFeatureStore: RoutesFeatureStore;\r\n  @Input() stepFeatureStore: StepFeatureStore;\r\n  @Input() debounce: number = 200;\r\n  @Input() length: number = 2;\r\n  @Input() coordRoundedDecimals: number = 6;\r\n  @Input() zoomToActiveRoute$: Subject<void> = new Subject();\r\n\r\n  constructor(\r\n    private cdRef: ChangeDetectorRef,\r\n    private languageService: LanguageService,\r\n    private directionsService: DirectionsService,\r\n    private searchService: SearchService,\r\n    private queryService: QueryService\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    this.queryService.queryEnabled = false;\r\n    this.initEntityStores();\r\n    setTimeout(() => {\r\n      initStopsFeatureStore(this.stopsFeatureStore, this.languageService);\r\n      initRoutesFeatureStore(this.routesFeatureStore, this.languageService);\r\n      initStepFeatureStore(this.stepFeatureStore);\r\n      this.initOlInteraction();\r\n    }, 1);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.queryService.queryEnabled = true;\r\n    this.storeEmpty$$.unsubscribe();\r\n    this.storeChange$$.unsubscribe();\r\n    this.routesQueries$$.map((u) => u.unsubscribe());\r\n    this.zoomRoute$$.unsubscribe();\r\n    this.freezeStores();\r\n  }\r\n\r\n  private freezeStores() {\r\n    this.stopsFeatureStore.layer.map.ol.removeInteraction(\r\n      this.selectStopInteraction\r\n    );\r\n    this.stopsFeatureStore.layer.map.ol.removeInteraction(this.translateStop);\r\n    this.routesFeatureStore.layer.map.ol.removeInteraction(this.selectedRoute);\r\n    this.stopsFeatureStore.deactivateStrategyOfType(\r\n      FeatureStoreLoadingStrategy\r\n    );\r\n    this.routesFeatureStore.deactivateStrategyOfType(\r\n      FeatureStoreLoadingStrategy\r\n    );\r\n    this.stepFeatureStore.deactivateStrategyOfType(FeatureStoreLoadingStrategy);\r\n  }\r\n\r\n  private initEntityStores() {\r\n    this.watcher = new EntityStoreWatcher(this.stopsStore, this.cdRef);\r\n    this.monitorEmptyEntityStore();\r\n    this.monitorEntityStoreChange();\r\n    this.monitorActiveRouteZoom();\r\n  }\r\n\r\n  private monitorActiveRouteZoom() {\r\n    this.zoomRoute$$ = this.zoomToActiveRoute$.subscribe(() => {\r\n      if (this.routesFeatureStore.count >= 1) {\r\n        const activeRoute = this.routesFeatureStore\r\n          .all()\r\n          .find((route) => route.properties.active);\r\n\r\n        if (activeRoute) {\r\n          activeRoute.ol.getGeometry();\r\n          const routeExtent = activeRoute.ol.getGeometry().getExtent();\r\n          this.routesFeatureStore.layer.map.viewController.zoomToExtent(\r\n            routeExtent as [number, number, number, number]\r\n          );\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  private initOlInteraction() {\r\n    this.selectStopInteraction = new olInteraction.Select({\r\n      layers: [this.stopsFeatureStore.layer.ol],\r\n      hitTolerance: 7,\r\n      condition: (event) => {\r\n        return event.type === 'pointermove' && !event.dragging;\r\n      }\r\n    });\r\n\r\n    this.translateStop = new olInteraction.Translate({\r\n      features: this.selectStopInteraction.getFeatures()\r\n    });\r\n    this.translateStop.on('translating', (evt: TranslateEvent) => {\r\n      this.isTranslating = true;\r\n      this.executeStopTranslation(evt.features);\r\n    });\r\n    this.translateStop.on('translateend', (evt: TranslateEvent) => {\r\n      this.isTranslating = false;\r\n      this.executeStopTranslation(evt.features);\r\n    });\r\n\r\n    this.selectedRoute = new olInteraction.Select({\r\n      layers: [this.routesFeatureStore.layer.ol],\r\n      condition: olCondition.click,\r\n      hitTolerance: 7,\r\n      filter: (feature) => {\r\n        return (\r\n          feature.get('type') === DirectionType.Route &&\r\n          feature.get('active') &&\r\n          !this.isTranslating\r\n        );\r\n      }\r\n    });\r\n    this.selectedRoute.on('select', (evt: SelectEvent) => {\r\n      if (this.focusOnStop === false) {\r\n        const selectCoordinates = roundCoordTo(\r\n          olProj.transform(\r\n            (evt as any).mapBrowserEvent.coordinate,\r\n            this.routesFeatureStore.layer.map.projection,\r\n            this.projection\r\n          ) as [number, number],\r\n          this.coordRoundedDecimals\r\n        );\r\n        const addedStop = addStopToStore(this.stopsStore);\r\n        addedStop.text = selectCoordinates.join(',');\r\n        addedStop.coordinates = [selectCoordinates[0], selectCoordinates[1]];\r\n      }\r\n    });\r\n\r\n    this.stopsFeatureStore.layer.map.ol.addInteraction(\r\n      this.selectStopInteraction\r\n    );\r\n    this.stopsFeatureStore.layer.map.ol.addInteraction(this.translateStop);\r\n    this.routesFeatureStore.layer.map.ol.addInteraction(this.selectedRoute);\r\n  }\r\n\r\n  onStopInputHasFocusChange(stopInputHasFocus: boolean) {\r\n    stopInputHasFocus\r\n      ? this.routesFeatureStore.layer.map.ol.removeInteraction(\r\n          this.selectedRoute\r\n        )\r\n      : this.routesFeatureStore.layer.map.ol.addInteraction(this.selectedRoute);\r\n  }\r\n\r\n  private executeStopTranslation(features: Collection<any>) {\r\n    if (features.getLength() === 0) {\r\n      return;\r\n    }\r\n    const firstFeature = features.getArray()[0];\r\n    const translatedStopId = firstFeature.getId();\r\n\r\n    const translationCoordinates = olProj.transform(\r\n      firstFeature.getGeometry().getCoordinates(),\r\n      this.stopsFeatureStore.layer.map.projection,\r\n      this.projection\r\n    );\r\n    const translatedStop = this.stopsStore.get(translatedStopId);\r\n    const roundedCoord = roundCoordTo(\r\n      translationCoordinates as [number, number],\r\n      this.coordRoundedDecimals\r\n    );\r\n    translatedStop.coordinates = roundedCoord;\r\n    translatedStop.text = roundedCoord.join(',');\r\n    this.stopsStore.update(translatedStop);\r\n  }\r\n\r\n  private monitorEmptyEntityStore() {\r\n    // Watch if the store is empty to reset it\r\n    this.storeEmpty$$ = this.stopsStore.count$\r\n      .pipe(distinctUntilChanged())\r\n      .subscribe((count) => {\r\n        if (count < 2) {\r\n          addStopToStore(this.stopsStore);\r\n          if (this.stopsStore.count === 2) {\r\n            this.stopsStore.storeInitialized$.next(true);\r\n            return;\r\n          }\r\n          this.stopsStore.storeInitialized$.next(false);\r\n        }\r\n        this.routesQueries$$.map((u) => u.unsubscribe());\r\n      });\r\n  }\r\n\r\n  private monitorEntityStoreChange() {\r\n    this.storeChange$$ = this.stopsStore.entities$\r\n      .pipe(debounceTime(this.debounce))\r\n      .subscribe((stops: Stop[]) => {\r\n        this.handleStopDiff(stops);\r\n        updateStoreSorting(this.stopsStore);\r\n        this.handleStopsFeature();\r\n        this.getRoutes(this.isTranslating);\r\n      });\r\n  }\r\n\r\n  cancelSearch() {\r\n    this.searchs$$.map((s) => s.unsubscribe());\r\n  }\r\n\r\n  private handleStopDiff(stops: Stop[]) {\r\n    const simplifiedStops = stops.map((stop: Stop) => {\r\n      return ObjectUtils.removeUndefined({\r\n        ...{ id: stop.id, text: stop.text, coordinates: stop.coordinates }\r\n      });\r\n    });\r\n    const diff = ChangeUtils.findChanges(this.previousStops, simplifiedStops, [\r\n      'coordinates'\r\n    ]);\r\n    const stopIdToProcess = diff.added.concat(diff.modified);\r\n    if (stopIdToProcess) {\r\n      stopIdToProcess.map((change) => {\r\n        const changedStop = change.newValue as Stop;\r\n        if (changedStop) {\r\n          const stop: Stop = this.stopsStore.get(changedStop.id);\r\n          const term = stop.text;\r\n          if (!term || term.length === 0) {\r\n            return;\r\n          }\r\n          const response = stringToLonLat(\r\n            term,\r\n            this.stopsFeatureStore.layer.map.projection\r\n          );\r\n          let researches: Research[];\r\n          let isCoord = false;\r\n          if (response.lonLat) {\r\n            isCoord = true;\r\n          }\r\n          researches = this.searchService.search(term, {\r\n            searchType: 'Feature'\r\n          });\r\n          this.cancelSearch();\r\n          const requests$ = researches.map((res) =>\r\n            res.request.pipe(\r\n              map((results: SearchResult[]) =>\r\n                results.filter((r) =>\r\n                  isCoord\r\n                    ? r.data.geometry.type === 'Point' && r.data.geometry\r\n                    : r.data.geometry\r\n                )\r\n              )\r\n            )\r\n          );\r\n          this.searchs$$ = requests$.map((request) => {\r\n            return request\r\n              .pipe(\r\n                map((results: SearchResult[]) =>\r\n                  results.filter((r) =>\r\n                    isCoord\r\n                      ? r.data.geometry.type === 'Point' && r.data.geometry\r\n                      : r.data.geometry\r\n                  )\r\n                )\r\n              )\r\n              .subscribe((res: SearchResult[]) => {\r\n                if (res.length > 0) {\r\n                  const source = res[0].source;\r\n                  const meta = res[0].meta;\r\n                  const results = res.map((r) => r.data);\r\n                  if (!stop.searchProposals) {\r\n                    stop.searchProposals = [];\r\n                  }\r\n                  stop.searchProposals = stop.searchProposals.filter(\r\n                    (sp) =>\r\n                      sp.type ===\r\n                      (isCoord ? ProposalType.Coord : ProposalType.Text)\r\n                  );\r\n                  let storedSource = stop.searchProposals.find(\r\n                    (sp) => sp.source === source\r\n                  );\r\n                  if (storedSource) {\r\n                    storedSource.results = results;\r\n                  } else {\r\n                    stop.searchProposals.push({\r\n                      type: isCoord ? ProposalType.Coord : ProposalType.Text,\r\n                      source,\r\n                      meta,\r\n                      results\r\n                    });\r\n                  }\r\n                }\r\n                this.cdRef.detectChanges();\r\n              });\r\n          });\r\n        }\r\n      });\r\n    }\r\n    this.previousStops = simplifiedStops;\r\n  }\r\n\r\n  private handleStopsFeature() {\r\n    const stops = this.stopsStore.all();\r\n    const stopsWithCoordinates = stops.filter((stop) => stop.coordinates);\r\n    stopsWithCoordinates.map((stop) => this.addStopOverlay(stop));\r\n    this.stopsFeatureStore\r\n      .all()\r\n      .map((stopFeature: Feature<FeatureWithStopProperties>) => {\r\n        if (!this.stopsStore.get(stopFeature.properties.id)) {\r\n          this.stopsFeatureStore.delete(stopFeature);\r\n        }\r\n      });\r\n    const stopsWithoutCoordinates = stops.filter((stop) => !stop.coordinates);\r\n    stopsWithoutCoordinates.map((stop) => {\r\n      const stopFeature = this.stopsFeatureStore.get(stop.id);\r\n      if (stopFeature) {\r\n        this.stopsFeatureStore.delete(stopFeature);\r\n      }\r\n    });\r\n  }\r\n\r\n  private getRoutes(isOverview: boolean = false) {\r\n    const stopsWithCoordinates = this.stopsStore.view\r\n      .all()\r\n      .filter((stop) => stop.coordinates);\r\n    if (stopsWithCoordinates.length < 2) {\r\n      this.routesFeatureStore.deleteMany(this.routesFeatureStore.all());\r\n      return;\r\n    }\r\n\r\n    const roundedCoordinates = stopsWithCoordinates.map((stop) => {\r\n      const roundedCoord = roundCoordTo(\r\n        stop.coordinates,\r\n        this.coordRoundedDecimals\r\n      );\r\n      return roundedCoord;\r\n    });\r\n    const overviewDirectionsOptions: DirectionOptions = {\r\n      overview: true,\r\n      steps: false,\r\n      alternatives: false,\r\n      continue_straight: false\r\n    };\r\n    this.routesQueries$$.map((u) => u.unsubscribe());\r\n    const routeResponse = this.directionsService.route(\r\n      roundedCoordinates,\r\n      isOverview ? overviewDirectionsOptions : undefined\r\n    );\r\n    if (routeResponse) {\r\n      routeResponse.map((res) =>\r\n        this.routesQueries$$.push(\r\n          res.subscribe((directions) => {\r\n            this.routesFeatureStore.deleteMany(this.routesFeatureStore.all());\r\n            directions.map((direction) =>\r\n              addDirectionToRoutesFeatureStore(\r\n                this.routesFeatureStore,\r\n                direction,\r\n                this.projection,\r\n                direction === directions[0] ? true : false\r\n              )\r\n            );\r\n          })\r\n        )\r\n      );\r\n    }\r\n  }\r\n\r\n  public addStopOverlay(stop: Stop) {\r\n    addStopToStopsFeatureStore(\r\n      stop,\r\n      this.stopsStore,\r\n      this.stopsFeatureStore,\r\n      this.projection,\r\n      this.languageService\r\n    );\r\n  }\r\n}\r\n","<igo-directions-buttons\r\n  [stepFeatureStore]=\"stepFeatureStore\"\r\n  [contextUri]=\"contextUri\"\r\n  [zoomToActiveRoute$]=\"zoomToActiveRoute$\"\r\n  [routesFeatureStore]=\"routesFeatureStore\"\r\n  [stopsStore]=\"stopsStore\"\r\n></igo-directions-buttons>\r\n\r\n<igo-directions-inputs\r\n  (stopInputHasFocus)=\"onStopInputHasFocusChange($event)\"\r\n  [coordRoundedDecimals]=\"coordRoundedDecimals\"\r\n  [projection]=\"projection\"\r\n  [stopsFeatureStore]=\"stopsFeatureStore\"\r\n  [stopsStore]=\"stopsStore\"\r\n  [debounce]=\"debounce\"\r\n  [length]=\"length\"\r\n></igo-directions-inputs>\r\n\r\n<igo-directions-results\r\n  [stepFeatureStore]=\"stepFeatureStore\"\r\n  [routesFeatureStore]=\"routesFeatureStore\"\r\n></igo-directions-results>\r\n"]}