@igo2/geo 18.0.1-next.2 → 18.0.2

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

@@ -0,0 +1,192 @@
+import { NgClass, NgFor, NgIf } from '@angular/common';
+import { ChangeDetectorRef, Component, Input } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatOptionModule } from '@angular/material/core';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatListModule } from '@angular/material/list';
+import { MatSelectModule } from '@angular/material/select';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { LanguageService } from '@igo2/core/language';
+import { IgoLanguageModule } from '@igo2/core/language';
+import olFeature from 'ol/Feature';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import * as olGeom from 'ol/geom';
+import { debounceTime } from 'rxjs/operators';
+import { FEATURE } from '../../feature/shared/feature.enums';
+import { DirectionsType } from '../shared/directions.enum';
+import { formatDistance, formatDuration, formatStep } from '../shared/directions.utils';
+import { RoutesFeatureStore, StepsFeatureStore } from '../shared/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core/language";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/select";
+import * as i4 from "@angular/material/core";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/tooltip";
+import * as i7 from "@angular/material/list";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@ngx-translate/core";
+export class DirectionsResultsComponent {
+    languageService;
+    cdRef;
+    routesFeatureStore;
+    stepsFeatureStore;
+    activeRoute;
+    routes;
+    entities$$;
+    constructor(languageService, cdRef) {
+        this.languageService = languageService;
+        this.cdRef = cdRef;
+    }
+    ngOnInit() {
+        this.entities$$ = this.routesFeatureStore.entities$
+            .pipe(debounceTime(200))
+            .subscribe((features) => {
+            const activeFeature = features.find((entity) => entity.properties.active);
+            this.routes = features.map((entity) => entity.properties.directions);
+            this.activeRoute = activeFeature
+                ? activeFeature.properties.directions
+                : undefined;
+            this.cdRef.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        this.entities$$.unsubscribe();
+    }
+    /**
+     * Toggles the active state of all features in the routesFeatureStore and updates
+     * the active state of their corresponding features in the layer.
+     */
+    chooseRouteOption() {
+        this.routesFeatureStore.entities$.value.map((feature) => (feature.properties.active = !feature.properties.active));
+        this.routesFeatureStore.layer.ol
+            .getSource()
+            .getFeatures()
+            .map((feature) => feature.set('active', !feature.get('active')));
+    }
+    /**
+     * Formats the given distance in meters.
+     *
+     * @param {number} distance - The distance in meters to be formatted.
+     * @return {string} The formatted distance string.
+     */
+    formatDistance(distance) {
+        return formatDistance(distance);
+    }
+    /**
+     * Formats the given duration in seconds.
+     *
+     * @param {number} duration - The duration in seconds to be formatted.
+     * @return {string} The formatted duration string.
+     */
+    formatDuration(duration) {
+        return formatDuration(duration);
+    }
+    /**
+     * Returns a formatted string containing the distance and duration of the active route.
+     *
+     * @return {string} The formatted string, or an empty string if either distance or duration is undefined.
+     */
+    getTitleDurationAndDistance() {
+        return this.formatDistance(this.activeRoute.distance) &&
+            this.formatDuration(this.activeRoute.duration)
+            ? ' (' +
+                this.formatDistance(this.activeRoute.distance) +
+                ' - ' +
+                this.formatDuration(this.activeRoute.duration) +
+                ')'
+            : '';
+    }
+    /**
+     * Formats a step and returns the formatted step.
+     *
+     * @param {IgoStep} step - The step to be formatted.
+     * @param {number} stepIndex - The index of the step in the active route.
+     * @return {FormattedStep} The formatted step.
+     */
+    getFormattedStep(step, stepIndex) {
+        return formatStep(step, this.languageService, stepIndex === this.activeRoute.steps.length - 1);
+    }
+    /**
+     * Clears the step feature store when the user's mouse leaves the list.
+     */
+    onLeaveList() {
+        this.stepsFeatureStore.clear();
+    }
+    /**
+     * Shows a step on the map and optionally zooming to the step.
+     *
+     * @param {IgoStep} step - The step to be shown.
+     * @param {boolean} [zoomToExtent=false] - Whether to zoom to the extent of the route segment geometry.
+     */
+    showStep(step, zoomToExtent = false) {
+        this.showRouteSegmentGeometry(step, zoomToExtent);
+    }
+    showRouteSegmentGeometry(step, zoomToExtent = false) {
+        const coordinates = step.geometry.coordinates;
+        const vertexId = 'vertex';
+        const geometry4326 = new olGeom.LineString(coordinates);
+        const geometryMapProjection = geometry4326.transform('EPSG:4326', this.stepsFeatureStore.layer.map.projection);
+        const routeSegmentCoordinates = geometryMapProjection.getCoordinates();
+        const lastPointCoordinates = routeSegmentCoordinates[0];
+        const lastPointGeometry = new olGeom.Point(lastPointCoordinates);
+        const lastPointFeature = new olFeature({
+            geometry: lastPointGeometry
+        });
+        const geojsonGeom = new OlGeoJSON().writeGeometryObject(lastPointGeometry, {
+            featureProjection: this.stepsFeatureStore.layer.map.projection,
+            dataProjection: this.stepsFeatureStore.layer.map.projection
+        });
+        const previousVertex = this.stepsFeatureStore.get(vertexId);
+        const previousVertexRevision = previousVertex
+            ? previousVertex.meta.revision
+            : 0;
+        const stepFeature = {
+            type: FEATURE,
+            geometry: geojsonGeom,
+            projection: this.stepsFeatureStore.layer.map.projection,
+            properties: {
+                id: vertexId,
+                step,
+                type: DirectionsType.Vertex
+            },
+            meta: {
+                id: vertexId,
+                revision: previousVertexRevision + 1
+            },
+            ol: lastPointFeature
+        };
+        this.stepsFeatureStore.update(stepFeature);
+        if (zoomToExtent) {
+            this.stepsFeatureStore.layer.map.viewController.zoomToExtent(lastPointFeature.getGeometry().getExtent());
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DirectionsResultsComponent, deps: [{ token: i1.LanguageService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DirectionsResultsComponent, isStandalone: true, selector: "igo-directions-results", inputs: { routesFeatureStore: "routesFeatureStore", stepsFeatureStore: "stepsFeatureStore" }, ngImport: i0, template: "<div class=\"igo-input-container\" *ngIf=\"routes && activeRoute\">\n  <mat-form-field *ngIf=\"routes.length > 1\" [matTooltip]=\"activeRoute.title\">\n    <mat-label>{{\n      'igo.geo.directions.results.routeOptions' | translate\n    }}</mat-label>\n    <mat-select\n      (selectionChange)=\"chooseRouteOption()\"\n      [(ngModel)]=\"activeRoute\"\n    >\n      <mat-option\n        *ngFor=\"let route of routes; let routeIndex = index\"\n        [value]=\"route\"\n      >\n        Option {{ routeIndex + 1 }}: {{ route.title }} ({{\n          formatDistance(route.distance)\n        }}\n        - {{ formatDuration(route.duration) }})\n      </mat-option>\n    </mat-select>\n  </mat-form-field>\n\n  <h3 mat-header class=\"igo-route-title\">\n    {{ activeRoute.title }}\n    {{ getTitleDurationAndDistance() }}\n  </h3>\n  <mat-list (mouseleave)=\"onLeaveList()\">\n    <ng-container *ngFor=\"let step of activeRoute.steps; let stepIndex = index\">\n      <mat-list-item\n        *ngIf=\"\n          (formatDistance(step.distance) && formatDuration(step.duration)) ||\n          stepIndex === activeRoute.steps.length - 1\n        \"\n        matListItem\n        class=\"igo-steps step\"\n        (mouseenter)=\"showStep(step)\"\n        (click)=\"showStep(step, true)\"\n      >\n        <mat-icon\n          matListItemIcon\n          [matTooltip]=\"\n            'igo.geo.directions.results.stepTitleTooltip' | translate\n          \"\n          >{{ getFormattedStep(step, stepIndex).iconName }}\n        </mat-icon>\n\n        <span\n          matListItemTitle\n          class=\"step-title\"\n          [matTooltip]=\"getFormattedStep(step, stepIndex).instruction\"\n        >\n          {{ getFormattedStep(step, stepIndex).instruction }}\n        </span>\n        <span\n          *ngIf=\"stepIndex !== activeRoute.steps.length - 1\"\n          matListItemLine\n        >\n          {{ formatDistance(step.distance) }} -\n          {{ formatDuration(step.duration) }}\n        </span>\n      </mat-list-item>\n    </ng-container>\n  </mat-list>\n</div>\n", styles: [".igo-input-container{width:100%;padding:20px 10px;box-sizing:border-box}.igo-input-container mat-form-field{width:100%}.igo-route-title{font-weight:700;margin:0}.step{cursor:pointer}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i2.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i2.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i3.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i4.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "ngmodule", type: MatOptionModule }, { kind: "ngmodule", type: MatDividerModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i6.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatListModule }, { kind: "component", type: i7.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i7.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "directive", type: i7.MatListItemIcon, selector: "[matListItemIcon]" }, { kind: "directive", type: i7.MatListItemLine, selector: "[matListItemLine]" }, { kind: "directive", type: i7.MatListItemTitle, selector: "[matListItemTitle]" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: IgoLanguageModule }, { kind: "pipe", type: i9.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DirectionsResultsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-directions-results', standalone: true, imports: [
+                        NgIf,
+                        MatFormFieldModule,
+                        MatSelectModule,
+                        FormsModule,
+                        NgFor,
+                        MatOptionModule,
+                        MatDividerModule,
+                        MatTooltipModule,
+                        MatListModule,
+                        MatIconModule,
+                        NgClass,
+                        IgoLanguageModule
+                    ], template: "<div class=\"igo-input-container\" *ngIf=\"routes && activeRoute\">\n  <mat-form-field *ngIf=\"routes.length > 1\" [matTooltip]=\"activeRoute.title\">\n    <mat-label>{{\n      'igo.geo.directions.results.routeOptions' | translate\n    }}</mat-label>\n    <mat-select\n      (selectionChange)=\"chooseRouteOption()\"\n      [(ngModel)]=\"activeRoute\"\n    >\n      <mat-option\n        *ngFor=\"let route of routes; let routeIndex = index\"\n        [value]=\"route\"\n      >\n        Option {{ routeIndex + 1 }}: {{ route.title }} ({{\n          formatDistance(route.distance)\n        }}\n        - {{ formatDuration(route.duration) }})\n      </mat-option>\n    </mat-select>\n  </mat-form-field>\n\n  <h3 mat-header class=\"igo-route-title\">\n    {{ activeRoute.title }}\n    {{ getTitleDurationAndDistance() }}\n  </h3>\n  <mat-list (mouseleave)=\"onLeaveList()\">\n    <ng-container *ngFor=\"let step of activeRoute.steps; let stepIndex = index\">\n      <mat-list-item\n        *ngIf=\"\n          (formatDistance(step.distance) && formatDuration(step.duration)) ||\n          stepIndex === activeRoute.steps.length - 1\n        \"\n        matListItem\n        class=\"igo-steps step\"\n        (mouseenter)=\"showStep(step)\"\n        (click)=\"showStep(step, true)\"\n      >\n        <mat-icon\n          matListItemIcon\n          [matTooltip]=\"\n            'igo.geo.directions.results.stepTitleTooltip' | translate\n          \"\n          >{{ getFormattedStep(step, stepIndex).iconName }}\n        </mat-icon>\n\n        <span\n          matListItemTitle\n          class=\"step-title\"\n          [matTooltip]=\"getFormattedStep(step, stepIndex).instruction\"\n        >\n          {{ getFormattedStep(step, stepIndex).instruction }}\n        </span>\n        <span\n          *ngIf=\"stepIndex !== activeRoute.steps.length - 1\"\n          matListItemLine\n        >\n          {{ formatDistance(step.distance) }} -\n          {{ formatDuration(step.duration) }}\n        </span>\n      </mat-list-item>\n    </ng-container>\n  </mat-list>\n</div>\n", styles: [".igo-input-container{width:100%;padding:20px 10px;box-sizing:border-box}.igo-input-container mat-form-field{width:100%}.igo-route-title{font-weight:700;margin:0}.step{cursor:pointer}\n"] }]
+        }], ctorParameters: () => [{ type: i1.LanguageService }, { type: i0.ChangeDetectorRef }], propDecorators: { routesFeatureStore: [{
+                type: Input,
+                args: [{ required: true }]
+            }], stepsFeatureStore: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directions-results.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/directions/directions-results/directions-results.component.ts","../../../../../../packages/geo/src/lib/directions/directions-results/directions-results.component.html"],"names":[],"mappings":"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","sourcesContent":["import { NgClass, NgFor, NgIf } from '@angular/common';\nimport {\n  ChangeDetectorRef,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit\n} from '@angular/core';\nimport { FormsModule } from '@angular/forms';\nimport { MatOptionModule } from '@angular/material/core';\nimport { MatDividerModule } from '@angular/material/divider';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatListModule } from '@angular/material/list';\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatTooltipModule } from '@angular/material/tooltip';\n\nimport { LanguageService } from '@igo2/core/language';\nimport { IgoLanguageModule } from '@igo2/core/language';\n\nimport olFeature from 'ol/Feature';\nimport { Coordinate } from 'ol/coordinate';\nimport OlGeoJSON from 'ol/format/GeoJSON';\nimport * as olGeom from 'ol/geom';\n\nimport { Subscription } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\nimport { FEATURE } from '../../feature/shared/feature.enums';\nimport { FeatureGeometry } from '../../feature/shared/feature.interfaces';\nimport { DirectionsType } from '../shared/directions.enum';\nimport {\n  Directions,\n  FeatureWithDirections,\n  FeatureWithStep,\n  FormattedStep,\n  IgoStep\n} from '../shared/directions.interface';\nimport {\n  formatDistance,\n  formatDuration,\n  formatStep\n} from '../shared/directions.utils';\nimport { RoutesFeatureStore, StepsFeatureStore } from '../shared/store';\n\n@Component({\n  selector: 'igo-directions-results',\n  templateUrl: './directions-results.component.html',\n  styleUrls: ['./directions-results.component.scss'],\n  standalone: true,\n  imports: [\n    NgIf,\n    MatFormFieldModule,\n    MatSelectModule,\n    FormsModule,\n    NgFor,\n    MatOptionModule,\n    MatDividerModule,\n    MatTooltipModule,\n    MatListModule,\n    MatIconModule,\n    NgClass,\n    IgoLanguageModule\n  ]\n})\nexport class DirectionsResultsComponent implements OnInit, OnDestroy {\n  @Input({ required: true }) routesFeatureStore: RoutesFeatureStore;\n  @Input({ required: true }) stepsFeatureStore: StepsFeatureStore;\n\n  public activeRoute: Directions;\n  public routes: Directions[];\n  private entities$$: Subscription;\n\n  constructor(\n    private languageService: LanguageService,\n    private cdRef: ChangeDetectorRef\n  ) {}\n\n  ngOnInit(): void {\n    this.entities$$ = this.routesFeatureStore.entities$\n      .pipe(debounceTime(200))\n      .subscribe((features) => {\n        const activeFeature: FeatureWithDirections = features.find(\n          (entity) => entity.properties.active\n        );\n        this.routes = features.map((entity) => entity.properties.directions);\n        this.activeRoute = activeFeature\n          ? activeFeature.properties.directions\n          : undefined;\n        this.cdRef.detectChanges();\n      });\n  }\n\n  ngOnDestroy(): void {\n    this.entities$$.unsubscribe();\n  }\n\n  /**\n   * Toggles the active state of all features in the routesFeatureStore and updates\n   * the active state of their corresponding features in the layer.\n   */\n  chooseRouteOption(): void {\n    this.routesFeatureStore.entities$.value.map(\n      (feature) => (feature.properties.active = !feature.properties.active)\n    );\n    this.routesFeatureStore.layer.ol\n      .getSource()\n      .getFeatures()\n      .map((feature) => feature.set('active', !feature.get('active')));\n  }\n\n  /**\n   * Formats the given distance in meters.\n   *\n   * @param {number} distance - The distance in meters to be formatted.\n   * @return {string} The formatted distance string.\n   */\n  formatDistance(distance: number): string {\n    return formatDistance(distance);\n  }\n\n  /**\n   * Formats the given duration in seconds.\n   *\n   * @param {number} duration - The duration in seconds to be formatted.\n   * @return {string} The formatted duration string.\n   */\n  formatDuration(duration: number): string {\n    return formatDuration(duration);\n  }\n\n  /**\n   * Returns a formatted string containing the distance and duration of the active route.\n   *\n   * @return {string} The formatted string, or an empty string if either distance or duration is undefined.\n   */\n  getTitleDurationAndDistance(): string {\n    return this.formatDistance(this.activeRoute.distance) &&\n      this.formatDuration(this.activeRoute.duration)\n      ? ' (' +\n          this.formatDistance(this.activeRoute.distance) +\n          ' - ' +\n          this.formatDuration(this.activeRoute.duration) +\n          ')'\n      : '';\n  }\n\n  /**\n   * Formats a step and returns the formatted step.\n   *\n   * @param {IgoStep} step - The step to be formatted.\n   * @param {number} stepIndex - The index of the step in the active route.\n   * @return {FormattedStep} The formatted step.\n   */\n  getFormattedStep(step: IgoStep, stepIndex: number): FormattedStep {\n    return formatStep(\n      step,\n      this.languageService,\n      stepIndex === this.activeRoute.steps.length - 1\n    );\n  }\n\n  /**\n   * Clears the step feature store when the user's mouse leaves the list.\n   */\n  onLeaveList(): void {\n    this.stepsFeatureStore.clear();\n  }\n\n  /**\n   * Shows a step on the map and optionally zooming to the step.\n   *\n   * @param {IgoStep} step - The step to be shown.\n   * @param {boolean} [zoomToExtent=false] - Whether to zoom to the extent of the route segment geometry.\n   */\n  showStep(step: IgoStep, zoomToExtent = false): void {\n    this.showRouteSegmentGeometry(step, zoomToExtent);\n  }\n\n  private showRouteSegmentGeometry(step: IgoStep, zoomToExtent = false) {\n    const coordinates: Coordinate = step.geometry.coordinates;\n    const vertexId = 'vertex';\n    const geometry4326: olGeom.LineString = new olGeom.LineString(coordinates);\n    const geometryMapProjection: olGeom.Geometry = geometry4326.transform(\n      'EPSG:4326',\n      this.stepsFeatureStore.layer.map.projection\n    );\n    const routeSegmentCoordinates: Coordinate[] = (\n      geometryMapProjection as any\n    ).getCoordinates();\n    const lastPointCoordinates: Coordinate = routeSegmentCoordinates[0];\n\n    const lastPointGeometry: olGeom.Point = new olGeom.Point(\n      lastPointCoordinates\n    );\n    const lastPointFeature: olFeature<olGeom.Point> =\n      new olFeature<olGeom.Point>({\n        geometry: lastPointGeometry\n      });\n\n    const geojsonGeom: FeatureGeometry = new OlGeoJSON().writeGeometryObject(\n      lastPointGeometry,\n      {\n        featureProjection: this.stepsFeatureStore.layer.map.projection,\n        dataProjection: this.stepsFeatureStore.layer.map.projection\n      }\n    ) as FeatureGeometry;\n\n    const previousVertex: FeatureWithStep =\n      this.stepsFeatureStore.get(vertexId);\n    const previousVertexRevision: number = previousVertex\n      ? previousVertex.meta.revision\n      : 0;\n\n    const stepFeature: FeatureWithStep = {\n      type: FEATURE,\n      geometry: geojsonGeom,\n      projection: this.stepsFeatureStore.layer.map.projection,\n      properties: {\n        id: vertexId,\n        step,\n        type: DirectionsType.Vertex\n      },\n      meta: {\n        id: vertexId,\n        revision: previousVertexRevision + 1\n      },\n      ol: lastPointFeature\n    };\n    this.stepsFeatureStore.update(stepFeature);\n    if (zoomToExtent) {\n      this.stepsFeatureStore.layer.map.viewController.zoomToExtent(\n        lastPointFeature.getGeometry().getExtent() as [\n          number,\n          number,\n          number,\n          number\n        ]\n      );\n    }\n  }\n}\n","<div class=\"igo-input-container\" *ngIf=\"routes && activeRoute\">\n  <mat-form-field *ngIf=\"routes.length > 1\" [matTooltip]=\"activeRoute.title\">\n    <mat-label>{{\n      'igo.geo.directions.results.routeOptions' | translate\n    }}</mat-label>\n    <mat-select\n      (selectionChange)=\"chooseRouteOption()\"\n      [(ngModel)]=\"activeRoute\"\n    >\n      <mat-option\n        *ngFor=\"let route of routes; let routeIndex = index\"\n        [value]=\"route\"\n      >\n        Option {{ routeIndex + 1 }}: {{ route.title }} ({{\n          formatDistance(route.distance)\n        }}\n        - {{ formatDuration(route.duration) }})\n      </mat-option>\n    </mat-select>\n  </mat-form-field>\n\n  <h3 mat-header class=\"igo-route-title\">\n    {{ activeRoute.title }}\n    {{ getTitleDurationAndDistance() }}\n  </h3>\n  <mat-list (mouseleave)=\"onLeaveList()\">\n    <ng-container *ngFor=\"let step of activeRoute.steps; let stepIndex = index\">\n      <mat-list-item\n        *ngIf=\"\n          (formatDistance(step.distance) && formatDuration(step.duration)) ||\n          stepIndex === activeRoute.steps.length - 1\n        \"\n        matListItem\n        class=\"igo-steps step\"\n        (mouseenter)=\"showStep(step)\"\n        (click)=\"showStep(step, true)\"\n      >\n        <mat-icon\n          matListItemIcon\n          [matTooltip]=\"\n            'igo.geo.directions.results.stepTitleTooltip' | translate\n          \"\n          >{{ getFormattedStep(step, stepIndex).iconName }}\n        </mat-icon>\n\n        <span\n          matListItemTitle\n          class=\"step-title\"\n          [matTooltip]=\"getFormattedStep(step, stepIndex).instruction\"\n        >\n          {{ getFormattedStep(step, stepIndex).instruction }}\n        </span>\n        <span\n          *ngIf=\"stepIndex !== activeRoute.steps.length - 1\"\n          matListItemLine\n        >\n          {{ formatDistance(step.distance) }} -\n          {{ formatDuration(step.duration) }}\n        </span>\n      </mat-list-item>\n    </ng-container>\n  </mat-list>\n</div>\n"]}

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

@@ -0,0 +1,2 @@
+export * from './directions-results.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kaXJlY3Rpb25zL2RpcmVjdGlvbnMtcmVzdWx0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaXJlY3Rpb25zLXJlc3VsdHMuY29tcG9uZW50JztcbiJdfQ==

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

@@ -0,0 +1,5 @@
+export var DirectionSourceKind;
+(function (DirectionSourceKind) {
+    DirectionSourceKind[DirectionSourceKind["OSRM"] = 0] = "OSRM";
+})(DirectionSourceKind || (DirectionSourceKind = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlyZWN0aW9ucy1zb3VyY2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvZGlyZWN0aW9ucy9kaXJlY3Rpb25zLXNvdXJjZXMvZGlyZWN0aW9ucy1zb3VyY2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQStCQSxNQUFNLENBQU4sSUFBWSxtQkFFWDtBQUZELFdBQVksbUJBQW1CO0lBQzdCLDZEQUFRLENBQUE7QUFDVixDQUFDLEVBRlcsbUJBQW1CLEtBQW5CLG1CQUFtQixRQUU5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFByb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGlyZWN0aW9uc1NvdXJjZU9wdGlvbnMgZXh0ZW5kcyBCYXNlRGlyZWN0aW9uc1NvdXJjZU9wdGlvbnMge1xuICBvc3JtPzogT3NybURpcmVjdGlvbnNTb3VyY2VPcHRpb25zO1xuICBsb2dvPzogc3RyaW5nO1xufVxuXG5leHBvcnQgdHlwZSBPc3JtRGlyZWN0aW9uc1NvdXJjZU9wdGlvbnMgPSBCYXNlRGlyZWN0aW9uc1NvdXJjZU9wdGlvbnM7XG5cbmludGVyZmFjZSBCYXNlRGlyZWN0aW9uc1NvdXJjZU9wdGlvbnMge1xuICBuYW1lPzogc3RyaW5nO1xuICBiYXNlVXJsPzogc3RyaW5nO1xuICBwcm9maWxlcz86IEJhc2VEaXJlY3Rpb25zU291cmNlT3B0aW9uc1Byb2ZpbGVbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBCYXNlRGlyZWN0aW9uc1NvdXJjZU9wdGlvbnNQcm9maWxlIHtcbiAgZW5hYmxlZD86IGJvb2xlYW47XG4gIG5hbWU6IHN0cmluZztcbiAgYXV0aG9yaXphdGlvbj86IEJhc2VEaXJlY3Rpb25zU291cmNlT3B0aW9uc1Byb2ZpbGVBdXRob3JpemF0aW9uO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJhc2VEaXJlY3Rpb25zU291cmNlT3B0aW9uc1Byb2ZpbGVBdXRob3JpemF0aW9uIHtcbiAgdXJsOiBzdHJpbmc7XG4gIHByb3BlcnR5OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGlyZWN0aW9uU291cmNlRmVhdHVyZTxLaW5kVCBleHRlbmRzIERpcmVjdGlvblNvdXJjZUtpbmQ+IHtcbiAga2luZDogS2luZFQ7XG4gIHByb3ZpZGVyczogUHJvdmlkZXJbXTtcbn1cblxuZXhwb3J0IGVudW0gRGlyZWN0aW9uU291cmNlS2luZCB7XG4gIE9TUk0gPSAwXG59XG4iXX0=

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

@@ -0,0 +1,3 @@
+export class DirectionsSource {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlyZWN0aW9ucy1zb3VyY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kaXJlY3Rpb25zL2RpcmVjdGlvbnMtc291cmNlcy9kaXJlY3Rpb25zLXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxNQUFNLE9BQWdCLGdCQUFnQjtDQVNyQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBvc2l0aW9uIH0gZnJvbSAnZ2VvanNvbic7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IERpcmVjdGlvbk9wdGlvbnMsIERpcmVjdGlvbnMgfSBmcm9tICcuLi9zaGFyZWQvZGlyZWN0aW9ucy5pbnRlcmZhY2UnO1xuaW1wb3J0IHsgQmFzZURpcmVjdGlvbnNTb3VyY2VPcHRpb25zUHJvZmlsZSB9IGZyb20gJy4vZGlyZWN0aW9ucy1zb3VyY2UuaW50ZXJmYWNlJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIERpcmVjdGlvbnNTb3VyY2Uge1xuICBhYnN0cmFjdCBwcm9maWxlczogQmFzZURpcmVjdGlvbnNTb3VyY2VPcHRpb25zUHJvZmlsZVtdO1xuICBhYnN0cmFjdCBnZXRTb3VyY2VOYW1lKCk6IHN0cmluZztcbiAgYWJzdHJhY3QgZ2V0RW5hYmxlZFByb2ZpbGUoKTogQmFzZURpcmVjdGlvbnNTb3VyY2VPcHRpb25zUHJvZmlsZTtcbiAgYWJzdHJhY3QgZ2V0UHJvZmlsZVdpdGhBdXRob3JpemF0aW9uKCk6IEJhc2VEaXJlY3Rpb25zU291cmNlT3B0aW9uc1Byb2ZpbGU7XG4gIGFic3RyYWN0IHJvdXRlKFxuICAgIGNvb3JkaW5hdGVzOiBQb3NpdGlvbltdLFxuICAgIGRpcmVjdGlvbnNPcHRpb25zOiBEaXJlY3Rpb25PcHRpb25zXG4gICk6IE9ic2VydmFibGU8RGlyZWN0aW9uc1tdPjtcbn1cbiJdfQ==

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

@@ -0,0 +1,23 @@
+import { HttpClient } from '@angular/common/http';
+import { ConfigService } from '@igo2/core/config';
+import { DirectionsSource } from './directions-source';
+import { DirectionSourceKind } from './directions-source.interface';
+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]
+    };
+}
+export function withOsrmSource() {
+    return {
+        kind: DirectionSourceKind.OSRM,
+        providers: [provideOsrmDirectionsSource()]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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,159 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { ConfigService } from '@igo2/core/config';
+import { uuid } from '@igo2/utils';
+import { map } from 'rxjs/operators';
+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/config";
+export class OsrmDirectionsSource extends DirectionsSource {
+    _http;
+    _config;
+    get options() {
+        return this._options;
+    }
+    set options(value) {
+        this._options = value;
+    }
+    get sourceName() {
+        return this._options.name;
+    }
+    set sourceName(value) {
+        this._options.name = value;
+    }
+    get baseUrl() {
+        return this._options.baseUrl;
+    }
+    set baseUrl(value) {
+        this._options.baseUrl = value;
+    }
+    get url() {
+        return `${this.baseUrl}${this.getEnabledProfile().name}/`;
+    }
+    get profiles() {
+        return this._options.profiles;
+    }
+    set profiles(value) {
+        this._options.profiles = value;
+    }
+    _options;
+    constructor(_http, _config) {
+        super();
+        this._http = _http;
+        this._config = _config;
+        this._options = this._config.getConfig('directionsSources.osrm');
+        if (!this.baseUrl) {
+            this.baseUrl = '/apis/itineraire/route/v1/';
+        }
+        if (!this.sourceName) {
+            this.sourceName = 'OSRM Québec';
+        }
+        if (!this.profiles) {
+            const profile = {
+                enabled: true,
+                name: 'driving'
+            };
+            this.profiles = [profile];
+        }
+        else {
+            if (!this.profiles.find((profile) => profile.enabled)) {
+                this.profiles[0].enabled = true;
+            }
+        }
+    }
+    getSourceName() {
+        return this.sourceName;
+    }
+    getEnabledProfile() {
+        return this.profiles.find((profile) => profile.enabled);
+    }
+    getProfileWithAuthorization() {
+        return this.profiles.find((profile) => profile.authorization);
+    }
+    route(coordinates, directionsOptions = {}) {
+        const directionsParams = this.getRouteParams(directionsOptions);
+        return this.getRoute(coordinates, directionsParams);
+    }
+    getRoute(coordinates, params) {
+        const url = this.url;
+        return this._http
+            .get(url + 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: this.url,
+            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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OsrmDirectionsSource, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OsrmDirectionsSource });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OsrmDirectionsSource, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ConfigService }] });
+//# 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 { HttpClient, HttpParams } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\n\nimport { ConfigService } from '@igo2/core/config';\nimport { uuid } from '@igo2/utils';\n\nimport { Position } from 'geojson';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nimport {\n  DirectionsFormat,\n  SourceDirectionsType\n} from '../shared/directions.enum';\nimport { DirectionOptions, Directions } from '../shared/directions.interface';\nimport { DirectionsSource } from './directions-source';\nimport {\n  BaseDirectionsSourceOptionsProfile,\n  OsrmDirectionsSourceOptions\n} from './directions-source.interface';\n\n@Injectable()\nexport class OsrmDirectionsSource extends DirectionsSource {\n  get options(): OsrmDirectionsSourceOptions {\n    return this._options;\n  }\n\n  set options(value: OsrmDirectionsSourceOptions) {\n    this._options = value;\n  }\n\n  get sourceName(): string {\n    return this._options.name;\n  }\n\n  set sourceName(value: string) {\n    this._options.name = value;\n  }\n\n  get baseUrl(): string {\n    return this._options.baseUrl;\n  }\n\n  set baseUrl(value: string) {\n    this._options.baseUrl = value;\n  }\n\n  get url(): string {\n    return `${this.baseUrl}${this.getEnabledProfile().name}/`;\n  }\n\n  get profiles(): BaseDirectionsSourceOptionsProfile[] {\n    return this._options.profiles;\n  }\n\n  set profiles(value: BaseDirectionsSourceOptionsProfile[]) {\n    this._options.profiles = value;\n  }\n\n  private _options: OsrmDirectionsSourceOptions;\n\n  constructor(\n    private _http: HttpClient,\n    private _config: ConfigService\n  ) {\n    super();\n    this._options = this._config.getConfig('directionsSources.osrm');\n    if (!this.baseUrl) {\n      this.baseUrl = '/apis/itineraire/route/v1/';\n    }\n\n    if (!this.sourceName) {\n      this.sourceName = 'OSRM Québec';\n    }\n\n    if (!this.profiles) {\n      const profile: BaseDirectionsSourceOptionsProfile = {\n        enabled: true,\n        name: 'driving'\n      };\n      this.profiles = [profile];\n    } else {\n      if (!this.profiles.find((profile) => profile.enabled)) {\n        this.profiles[0].enabled = true;\n      }\n    }\n  }\n\n  getSourceName(): string {\n    return this.sourceName;\n  }\n\n  getEnabledProfile(): BaseDirectionsSourceOptionsProfile {\n    return this.profiles.find((profile) => profile.enabled);\n  }\n\n  getProfileWithAuthorization(): BaseDirectionsSourceOptionsProfile {\n    return this.profiles.find((profile) => profile.authorization);\n  }\n\n  route(\n    coordinates: Position[],\n    directionsOptions: DirectionOptions = {}\n  ): Observable<Directions[]> {\n    const directionsParams = this.getRouteParams(directionsOptions);\n    return this.getRoute(coordinates, directionsParams);\n  }\n\n  private getRoute(\n    coordinates: Position[],\n    params: HttpParams\n  ): Observable<Directions[]> {\n    const url: string = this.url;\n    return this._http\n      .get<JSON[]>(url + coordinates.join(';'), {\n        params\n      })\n      .pipe(map((res) => this.extractRoutesData(res)));\n  }\n\n  private extractRoutesData(response): Directions[] {\n    const routeResponse = [];\n    response.routes.forEach((route) => {\n      routeResponse.push(this.formatRoute(route, response.waypoints));\n    });\n    return routeResponse;\n  }\n\n  private getRouteParams(directionsOptions: DirectionOptions = {}): HttpParams {\n    directionsOptions.alternatives =\n      directionsOptions.alternatives !== undefined\n        ? directionsOptions.alternatives\n        : true;\n    directionsOptions.steps =\n      directionsOptions.steps !== undefined ? directionsOptions.steps : true;\n    directionsOptions.geometries =\n      directionsOptions.geometries !== undefined\n        ? directionsOptions.geometries\n        : 'geojson';\n    directionsOptions.overview =\n      directionsOptions.overview !== undefined\n        ? directionsOptions.overview\n        : false;\n    directionsOptions.continue_straight =\n      directionsOptions.continue_straight !== undefined\n        ? directionsOptions.continue_straight\n        : false;\n\n    return new HttpParams({\n      fromObject: {\n        alternatives: directionsOptions.alternatives ? 'true' : 'false',\n        overview: directionsOptions.overview ? 'simplified' : 'full',\n        steps: directionsOptions.steps ? 'true' : 'false',\n        geometries: directionsOptions.geometries\n          ? directionsOptions.geometries\n          : 'geojson',\n        continue_straight: directionsOptions.continue_straight\n          ? 'true'\n          : 'false'\n      }\n    });\n  }\n\n  private formatRoute(roadNetworkRoute: any, waypoints: any): Directions {\n    const stepsUI = [];\n    roadNetworkRoute.legs.forEach((leg) => {\n      leg.steps.forEach((step) => {\n        stepsUI.push(step);\n      });\n    });\n    return {\n      id: uuid(),\n      title: roadNetworkRoute.legs[0].summary,\n      source: this.url,\n      sourceType: SourceDirectionsType.Route,\n      order: 1,\n      format: DirectionsFormat.GeoJSON,\n      icon: 'directions',\n      projection: 'EPSG:4326',\n      waypoints,\n      distance: roadNetworkRoute.distance,\n      duration: roadNetworkRoute.duration,\n      geometry: roadNetworkRoute.geometry,\n      legs: roadNetworkRoute.legs,\n      steps: stepsUI,\n      weight: roadNetworkRoute.weight,\n      weight_name: roadNetworkRoute.weight_name\n    };\n  }\n}\n"]}