@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/datasource/shared/options/options-api.service.mjs

@@ -0,0 +1,85 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { OptionsService } from './options.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class OptionsApiService extends OptionsService {
+    http;
+    urlApi;
+    provideContextUri;
+    constructor(http, options = {}) {
+        super();
+        this.http = http;
+        this.urlApi = options.url || this.urlApi;
+        this.provideContextUri =
+            options.provideContextUri || this.provideContextUri;
+    }
+    getWMSOptions(baseOptions, detailedContextUri) {
+        if (!this.urlApi) {
+            return of({});
+        }
+        let params = new HttpParams({
+            fromObject: {
+                type: baseOptions.type,
+                url: baseOptions.url,
+                layers: baseOptions.params.LAYERS
+            }
+        });
+        if (detailedContextUri && this.provideContextUri) {
+            params = params.append('context', detailedContextUri);
+        }
+        const request = this.http.get(this.urlApi, {
+            params
+        });
+        return request.pipe(map((res) => {
+            if (!res || !res.sourceOptions) {
+                return {};
+            }
+            if (res.layerOptions) {
+                res.sourceOptions._layerOptionsFromSource = res.layerOptions;
+            }
+            return res.sourceOptions;
+        }));
+    }
+    getArcgisRestOptions(baseOptions, detailedContextUri) {
+        if (!this.urlApi) {
+            return of({});
+        }
+        let params = new HttpParams({
+            fromObject: {
+                type: baseOptions.type,
+                url: baseOptions.url,
+                layers: baseOptions.layer
+            }
+        });
+        if (detailedContextUri && this.provideContextUri) {
+            params = params.append('context', detailedContextUri);
+        }
+        const request = this.http.get(this.urlApi, {
+            params
+        });
+        return request.pipe(map((res) => {
+            if (!res || !res.sourceOptions) {
+                return {};
+            }
+            if (res.layerOptions) {
+                res.sourceOptions._layerOptionsFromSource = res.layerOptions;
+            }
+            return res.sourceOptions;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OptionsApiService, deps: [{ token: i1.HttpClient }, { token: 'options' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OptionsApiService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OptionsApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['options']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options-api.service.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/datasource/shared/options/options-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpParams } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\n\nimport { Observable, of } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nimport {\n  ArcGISRestDataSourceOptions,\n  ArcGISRestImageDataSourceOptions,\n  TileArcGISRestDataSourceOptions,\n  WMSDataSourceOptions\n} from '../datasources';\nimport { OptionsApiOptions } from './options-api.interface';\nimport { OptionsService } from './options.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class OptionsApiService extends OptionsService {\n  private urlApi: string;\n  private provideContextUri: boolean;\n\n  constructor(\n    private http: HttpClient,\n    @Inject('options') options: OptionsApiOptions = {}\n  ) {\n    super();\n    this.urlApi = options.url || this.urlApi;\n    this.provideContextUri =\n      options.provideContextUri || this.provideContextUri;\n  }\n\n  getWMSOptions(\n    baseOptions: WMSDataSourceOptions,\n    detailedContextUri?: string\n  ): Observable<WMSDataSourceOptions> {\n    if (!this.urlApi) {\n      return of({} as WMSDataSourceOptions);\n    }\n    let params = new HttpParams({\n      fromObject: {\n        type: baseOptions.type,\n        url: baseOptions.url,\n        layers: baseOptions.params.LAYERS\n      }\n    });\n\n    if (detailedContextUri && this.provideContextUri) {\n      params = params.append('context', detailedContextUri);\n    }\n\n    const request = this.http.get(this.urlApi, {\n      params\n    });\n\n    return request.pipe(\n      map(\n        (res: {\n          sourceOptions: WMSDataSourceOptions;\n          layerOptions: Record<string, string>;\n        }) => {\n          if (!res || !res.sourceOptions) {\n            return {} as WMSDataSourceOptions;\n          }\n          if (res.layerOptions) {\n            res.sourceOptions._layerOptionsFromSource = res.layerOptions;\n          }\n          return res.sourceOptions;\n        }\n      )\n    );\n  }\n\n  getArcgisRestOptions(\n    baseOptions:\n      | ArcGISRestDataSourceOptions\n      | ArcGISRestImageDataSourceOptions\n      | TileArcGISRestDataSourceOptions,\n    detailedContextUri?: string\n  ): Observable<\n    | ArcGISRestDataSourceOptions\n    | ArcGISRestImageDataSourceOptions\n    | TileArcGISRestDataSourceOptions\n  > {\n    if (!this.urlApi) {\n      return of({} as ArcGISRestImageDataSourceOptions);\n    }\n    let params = new HttpParams({\n      fromObject: {\n        type: baseOptions.type,\n        url: baseOptions.url,\n        layers: baseOptions.layer\n      }\n    });\n\n    if (detailedContextUri && this.provideContextUri) {\n      params = params.append('context', detailedContextUri);\n    }\n\n    const request = this.http.get(this.urlApi, {\n      params\n    });\n\n    return request.pipe(\n      map(\n        (res: {\n          sourceOptions:\n            | ArcGISRestDataSourceOptions\n            | ArcGISRestImageDataSourceOptions\n            | TileArcGISRestDataSourceOptions;\n          layerOptions: Record<string, string>;\n        }) => {\n          if (!res || !res.sourceOptions) {\n            return {} as\n              | ArcGISRestDataSourceOptions\n              | ArcGISRestImageDataSourceOptions\n              | TileArcGISRestDataSourceOptions;\n          }\n          if (res.layerOptions) {\n            res.sourceOptions._layerOptionsFromSource = res.layerOptions;\n          }\n          return res.sourceOptions;\n        }\n      )\n    );\n  }\n}\n"]}

package/esm2022/lib/datasource/shared/options/options.service.mjs

@@ -0,0 +1,3 @@
+export class OptionsService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvZGF0YXNvdXJjZS9zaGFyZWQvb3B0aW9ucy9vcHRpb25zLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsTUFBTSxPQUFnQixjQUFjO0NBZ0JuQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHtcbiAgQXJjR0lTUmVzdERhdGFTb3VyY2VPcHRpb25zLFxuICBBcmNHSVNSZXN0SW1hZ2VEYXRhU291cmNlT3B0aW9ucyxcbiAgVGlsZUFyY0dJU1Jlc3REYXRhU291cmNlT3B0aW9ucyxcbiAgV01TRGF0YVNvdXJjZU9wdGlvbnNcbn0gZnJvbSAnLi4vZGF0YXNvdXJjZXMnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgT3B0aW9uc1NlcnZpY2Uge1xuICBhYnN0cmFjdCBnZXRXTVNPcHRpb25zKFxuICAgIF9iYXNlT3B0aW9uczogV01TRGF0YVNvdXJjZU9wdGlvbnMsXG4gICAgZGV0YWlsZWRDb250ZXh0VXJpPzogc3RyaW5nXG4gICk6IE9ic2VydmFibGU8V01TRGF0YVNvdXJjZU9wdGlvbnM+O1xuICBhYnN0cmFjdCBnZXRBcmNnaXNSZXN0T3B0aW9ucyhcbiAgICBfYmFzZU9wdGlvbnM6XG4gICAgICB8IEFyY0dJU1Jlc3REYXRhU291cmNlT3B0aW9uc1xuICAgICAgfCBBcmNHSVNSZXN0SW1hZ2VEYXRhU291cmNlT3B0aW9uc1xuICAgICAgfCBUaWxlQXJjR0lTUmVzdERhdGFTb3VyY2VPcHRpb25zLFxuICAgIGRldGFpbGVkQ29udGV4dFVyaT86IHN0cmluZ1xuICApOiBPYnNlcnZhYmxlPFxuICAgIHwgQXJjR0lTUmVzdERhdGFTb3VyY2VPcHRpb25zXG4gICAgfCBBcmNHSVNSZXN0SW1hZ2VEYXRhU291cmNlT3B0aW9uc1xuICAgIHwgVGlsZUFyY0dJU1Jlc3REYXRhU291cmNlT3B0aW9uc1xuICA+O1xufVxuIl19

package/esm2022/lib/datasource/utils/index.mjs

@@ -0,0 +1,2 @@
+export * from './tilegrid';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kYXRhc291cmNlL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90aWxlZ3JpZCc7XG4iXX0=

package/esm2022/lib/datasource/utils/tilegrid.mjs

@@ -0,0 +1,20 @@
+import { getTopLeft as extentGetTopLeft, getWidth as extentGetWidth } from 'ol/extent.js';
+import * as olproj from 'ol/proj';
+import olTileGridWMTS from 'ol/tilegrid/WMTS';
+export function createDefaultTileGrid(epsg) {
+    const projection = epsg ? olproj.get(epsg) : olproj.get('EPSG:3857');
+    const projectionExtent = projection.getExtent();
+    const size = extentGetWidth(projectionExtent) / 256;
+    const resolutions = new Array(20);
+    const matrixIds = new Array(20);
+    for (let z = 0; z < 20; ++z) {
+        resolutions[z] = size / Math.pow(2, z);
+        matrixIds[z] = z;
+    }
+    return new olTileGridWMTS({
+        origin: extentGetTopLeft(projectionExtent),
+        resolutions,
+        matrixIds
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,246 @@
+import { AsyncPipe, NgIf } from '@angular/common';
+import { Component, Input, Optional } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { LanguageService } from '@igo2/core/language';
+import { IgoLanguageModule } from '@igo2/core/language';
+import { MessageService } from '@igo2/core/message';
+import { RouteService } from '@igo2/core/route';
+import { Clipboard } from '@igo2/utils';
+import { Subject } from 'rxjs';
+import { roundCoordTo, roundCoordToString } from '../../map/shared/map.utils';
+import { DirectionsService } from '../shared';
+import { formatDistance, formatDuration, formatStep } from '../shared/directions.utils';
+import { RoutesFeatureStore, StepsFeatureStore, StopsStore } from '../shared/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core/language";
+import * as i2 from "@igo2/core/message";
+import * as i3 from "@igo2/core/route";
+import * as i4 from "../shared";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/tooltip";
+import * as i7 from "@angular/material/icon";
+import * as i8 from "@ngx-translate/core";
+export class DirectionsButtonsComponent {
+    languageService;
+    messageService;
+    routeService;
+    directionsService;
+    contextUri;
+    zoomOnActiveRoute$ = new Subject();
+    stopsStore;
+    routesFeatureStore;
+    stepsFeatureStore;
+    downloadDirectionsBtnDisabled = false;
+    constructor(languageService, messageService, routeService, directionsService) {
+        this.languageService = languageService;
+        this.messageService = messageService;
+        this.routeService = routeService;
+        this.directionsService = directionsService;
+    }
+    /**
+     * Returns the active route from the routesFeatureStore.
+     *
+     * @return {FeatureWithDirections | undefined} The active route, or undefined if no active route is found.
+     */
+    get activeRoute() {
+        return this.routesFeatureStore
+            .all()
+            .find((route) => route.properties.active);
+    }
+    /**
+     * Resets the stops in the stopsStore by clearing all the stops.
+     *
+     */
+    resetStops() {
+        this.stopsStore.clearStops();
+    }
+    /**
+     * Triggers the zoom on the active route.
+     *
+     */
+    zoomOnActiveRoute() {
+        this.zoomOnActiveRoute$.next();
+    }
+    /**
+     * Copies the directions to the clipboard and displays a success message if the copy is successful.
+     *
+     */
+    copyDirectionsToClipboard() {
+        const directions = this.directionsToText();
+        const successful = Clipboard.copy(directions);
+        if (successful) {
+            this.messageService.success('igo.geo.directions.buttons.message.copyDirections');
+        }
+    }
+    /**
+     * Copies the link to the clipboard and displays a success message if the copy is successful.
+     *
+     */
+    copyLinkToClipboard() {
+        const copySuccessful = Clipboard.copy(this.getLink());
+        if (copySuccessful) {
+            this.messageService.success('igo.geo.directions.buttons.message.copyLink');
+        }
+    }
+    /**
+     * Downloads the directions.
+     *
+     */
+    downloadDirections() {
+        this.stepsFeatureStore.clear();
+        this.downloadDirectionsBtnDisabled = true;
+        this.directionsService
+            .downloadDirections(this.routesFeatureStore.map, this.activeRoute.properties.directions)
+            .subscribe(() => {
+            this.downloadDirectionsBtnDisabled = false;
+        });
+    }
+    /**
+     * Generates a text representation of the directions, including summary, stops, URL, and directions.
+     *
+     * @return {string} The directions in text format.
+     */
+    directionsToText() {
+        const indent = '\t';
+        const newLine = '\n';
+        let summary = this.languageService.translate.instant('igo.geo.directions.directionsText.summary') +
+            ':' +
+            newLine +
+            indent +
+            this.activeRoute.properties.directions.title;
+        const distance = formatDistance(this.activeRoute.properties.directions.distance);
+        const duration = formatDuration(this.activeRoute.properties.directions.duration);
+        if (distance && duration) {
+            summary += ' (' + distance + ' - ' + duration + ')';
+        }
+        summary += newLine + newLine;
+        let stops = this.languageService.translate.instant('igo.geo.directions.directionsText.stopList') +
+            ':' +
+            newLine;
+        let stopNumber = 1;
+        this.stopsStore.view.all().forEach((stop) => {
+            let coords = '';
+            let stopText = '';
+            if (stop.text !== roundCoordToString(stop.coordinates, 6).join(', ')) {
+                stopText = stop.text;
+                coords = ` (${roundCoordToString(stop.coordinates, 6).join(', ')})`;
+            }
+            else {
+                stopText = roundCoordToString(stop.coordinates, 6).join(', ');
+            }
+            stops =
+                stops +
+                    indent +
+                    stopNumber.toLocaleString() +
+                    '. ' +
+                    stopText +
+                    coords +
+                    newLine;
+            stopNumber++;
+        });
+        stops += newLine;
+        const url = this.languageService.translate.instant('igo.geo.directions.directionsText.link') +
+            ':' +
+            newLine +
+            indent +
+            this.getLink() +
+            newLine +
+            newLine;
+        let directions = this.languageService.translate.instant('igo.geo.directions.directions') +
+            ':' +
+            newLine;
+        this.activeRoute.properties.directions.steps.forEach((step, stepIndex, steps) => {
+            const distance = formatDistance(step.distance);
+            const duration = formatDuration(step.duration);
+            if ((distance && duration) || stepIndex === steps.length - 1) {
+                const instruction = this.getFormattedStepInstruction(step, stepIndex);
+                const formattedDistanceDuration = distance && duration ? ` (${distance} - ${duration}) ` : '';
+                directions =
+                    directions +
+                        indent +
+                        '- ' +
+                        instruction +
+                        formattedDistanceDuration +
+                        newLine;
+            }
+        });
+        const directionsBody = summary + stops + url + directions;
+        return directionsBody;
+    }
+    /**
+     * Formats a step.
+     *
+     * @param {IgoStep} step - The step to format.
+     * @param {number} stepIndex - The index of the step in the directions.
+     * @return {string} The formatted instruction for the step.
+     */
+    getFormattedStepInstruction(step, stepIndex) {
+        return formatStep(step, this.languageService, stepIndex === this.activeRoute.properties.directions.steps.length - 1).instruction;
+    }
+    /**
+     * Generates a link based on the current route and stops.
+     *
+     * @return {string | undefined} The generated link, or undefined if the route service is not available.
+     */
+    getLink() {
+        if (!this.routeService) {
+            return;
+        }
+        let context = '';
+        if (this.contextUri) {
+            context = `context=${this.contextUri}&`;
+        }
+        const routeIndex = this.routesFeatureStore
+            .all()
+            .map((direction) => direction.properties.id)
+            .indexOf(this.activeRoute.properties.id);
+        let routingOptions = '';
+        if (routeIndex !== 0) {
+            const routingOptionsKey = this.routeService.options.directionsOptionsKey;
+            routingOptions = `&${routingOptionsKey}=result:${routeIndex}`;
+        }
+        const directionsKey = this.routeService.options.directionsCoordKey;
+        const stopsCoordinates = this.stopsStore.view
+            .all()
+            .map((stop) => roundCoordTo(stop.coordinates, 6));
+        let directionsUrl = '';
+        if (stopsCoordinates.length >= 2) {
+            directionsUrl = `${directionsKey}=${stopsCoordinates.join(';')}`;
+            return `${location.origin}${location.pathname}?${context}tool=directions&sidenav=1&${directionsUrl}${routingOptions}`;
+        }
+        return;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DirectionsButtonsComponent, deps: [{ token: i1.LanguageService }, { token: i2.MessageService }, { token: i3.RouteService, optional: true }, { token: i4.DirectionsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DirectionsButtonsComponent, isStandalone: true, selector: "igo-directions-buttons", inputs: { contextUri: "contextUri", zoomOnActiveRoute$: "zoomOnActiveRoute$", stopsStore: "stopsStore", routesFeatureStore: "routesFeatureStore", stepsFeatureStore: "stepsFeatureStore" }, ngImport: i0, template: "<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.resetStops' | translate\"\n  color=\"warn\"\n  (click)=\"resetStops()\"\n>\n  <mat-icon>restart_alt</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.zoomOnRoute' | translate\"\n  color=\"primary\"\n  (click)=\"zoomOnActiveRoute()\"\n>\n  <mat-icon>frame_inspect</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.copyDirections' | translate\"\n  color=\"primary\"\n  (click)=\"copyDirectionsToClipboard()\"\n>\n  <mat-icon>content_copy</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.copyLink' | translate\"\n  color=\"primary\"\n  (click)=\"copyLinkToClipboard()\"\n>\n  <mat-icon>link</mat-icon>\n</button>\n\n<button\n  mat-icon-button\n  [disabled]=\"downloadDirectionsBtnDisabled\"\n  [matTooltip]=\"'igo.geo.directions.buttons.downloadDirections' | translate\"\n  color=\"primary\"\n  (click)=\"downloadDirections()\"\n>\n  <mat-icon>download</mat-icon>\n</button>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i5.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { 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: MatIconModule }, { kind: "component", type: i7.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: IgoLanguageModule }, { kind: "pipe", type: i8.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DirectionsButtonsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-directions-buttons', standalone: true, imports: [
+                        MatButtonModule,
+                        MatTooltipModule,
+                        MatIconModule,
+                        NgIf,
+                        AsyncPipe,
+                        IgoLanguageModule
+                    ], template: "<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.resetStops' | translate\"\n  color=\"warn\"\n  (click)=\"resetStops()\"\n>\n  <mat-icon>restart_alt</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.zoomOnRoute' | translate\"\n  color=\"primary\"\n  (click)=\"zoomOnActiveRoute()\"\n>\n  <mat-icon>frame_inspect</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.copyDirections' | translate\"\n  color=\"primary\"\n  (click)=\"copyDirectionsToClipboard()\"\n>\n  <mat-icon>content_copy</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.copyLink' | translate\"\n  color=\"primary\"\n  (click)=\"copyLinkToClipboard()\"\n>\n  <mat-icon>link</mat-icon>\n</button>\n\n<button\n  mat-icon-button\n  [disabled]=\"downloadDirectionsBtnDisabled\"\n  [matTooltip]=\"'igo.geo.directions.buttons.downloadDirections' | translate\"\n  color=\"primary\"\n  (click)=\"downloadDirections()\"\n>\n  <mat-icon>download</mat-icon>\n</button>\n" }]
+        }], ctorParameters: () => [{ type: i1.LanguageService }, { type: i2.MessageService }, { type: i3.RouteService, decorators: [{
+                    type: Optional
+                }] }, { type: i4.DirectionsService }], propDecorators: { contextUri: [{
+                type: Input,
+                args: [{ required: true }]
+            }], zoomOnActiveRoute$: [{
+                type: Input,
+                args: [{ required: true }]
+            }], stopsStore: [{
+                type: Input,
+                args: [{ required: true }]
+            }], routesFeatureStore: [{
+                type: Input,
+                args: [{ required: true }]
+            }], stepsFeatureStore: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directions-buttons.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/directions/directions-buttons/directions-buttons.component.ts","../../../../../../packages/geo/src/lib/directions/directions-buttons/directions-buttons.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AsyncPipe, NgIf } from '@angular/common';\nimport { Component, Input, Optional } from '@angular/core';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatTooltipModule } from '@angular/material/tooltip';\n\nimport { LanguageService } from '@igo2/core/language';\nimport { IgoLanguageModule } from '@igo2/core/language';\nimport { MessageService } from '@igo2/core/message';\nimport { RouteService } from '@igo2/core/route';\nimport { Clipboard } from '@igo2/utils';\n\nimport { Coordinate } from 'ol/coordinate';\n\nimport { Subject } from 'rxjs';\n\nimport { roundCoordTo, roundCoordToString } from '../../map/shared/map.utils';\nimport { DirectionsService } from '../shared';\nimport { FeatureWithDirections, IgoStep } from '../shared/directions.interface';\nimport {\n  formatDistance,\n  formatDuration,\n  formatStep\n} from '../shared/directions.utils';\nimport {\n  RoutesFeatureStore,\n  StepsFeatureStore,\n  StopsStore\n} from '../shared/store';\n\n@Component({\n  selector: 'igo-directions-buttons',\n  templateUrl: './directions-buttons.component.html',\n  styleUrls: ['./directions-buttons.component.scss'],\n  standalone: true,\n  imports: [\n    MatButtonModule,\n    MatTooltipModule,\n    MatIconModule,\n    NgIf,\n    AsyncPipe,\n    IgoLanguageModule\n  ]\n})\nexport class DirectionsButtonsComponent {\n  @Input({ required: true }) contextUri: string;\n  @Input({ required: true }) zoomOnActiveRoute$ = new Subject<void>();\n  @Input({ required: true }) stopsStore: StopsStore;\n  @Input({ required: true }) routesFeatureStore: RoutesFeatureStore;\n  @Input({ required: true }) stepsFeatureStore: StepsFeatureStore;\n\n  public downloadDirectionsBtnDisabled = false;\n\n  constructor(\n    private languageService: LanguageService,\n    private messageService: MessageService,\n    @Optional() private routeService: RouteService,\n    private directionsService: DirectionsService\n  ) {}\n\n  /**\n   * Returns the active route from the routesFeatureStore.\n   *\n   * @return {FeatureWithDirections | undefined} The active route, or undefined if no active route is found.\n   */\n  get activeRoute(): FeatureWithDirections {\n    return this.routesFeatureStore\n      .all()\n      .find((route) => route.properties.active);\n  }\n\n  /**\n   * Resets the stops in the stopsStore by clearing all the stops.\n   *\n   */\n  resetStops(): void {\n    this.stopsStore.clearStops();\n  }\n\n  /**\n   * Triggers the zoom on the active route.\n   *\n   */\n  zoomOnActiveRoute(): void {\n    this.zoomOnActiveRoute$.next();\n  }\n\n  /**\n   * Copies the directions to the clipboard and displays a success message if the copy is successful.\n   *\n   */\n  copyDirectionsToClipboard(): void {\n    const directions: string = this.directionsToText();\n    const successful: boolean = Clipboard.copy(directions);\n    if (successful) {\n      this.messageService.success(\n        'igo.geo.directions.buttons.message.copyDirections'\n      );\n    }\n  }\n\n  /**\n   * Copies the link to the clipboard and displays a success message if the copy is successful.\n   *\n   */\n  copyLinkToClipboard(): void {\n    const copySuccessful: boolean = Clipboard.copy(this.getLink());\n    if (copySuccessful) {\n      this.messageService.success(\n        'igo.geo.directions.buttons.message.copyLink'\n      );\n    }\n  }\n\n  /**\n   * Downloads the directions.\n   *\n   */\n  downloadDirections(): void {\n    this.stepsFeatureStore.clear();\n    this.downloadDirectionsBtnDisabled = true;\n    this.directionsService\n      .downloadDirections(\n        this.routesFeatureStore.map,\n        this.activeRoute.properties.directions\n      )\n      .subscribe(() => {\n        this.downloadDirectionsBtnDisabled = false;\n      });\n  }\n\n  /**\n   * Generates a text representation of the directions, including summary, stops, URL, and directions.\n   *\n   * @return {string} The directions in text format.\n   */\n  private directionsToText(): string {\n    const indent = '\\t';\n    const newLine = '\\n';\n\n    let summary: string =\n      this.languageService.translate.instant(\n        'igo.geo.directions.directionsText.summary'\n      ) +\n      ':' +\n      newLine +\n      indent +\n      this.activeRoute.properties.directions.title;\n\n    const distance: string = formatDistance(\n      this.activeRoute.properties.directions.distance\n    );\n    const duration: string = formatDuration(\n      this.activeRoute.properties.directions.duration\n    );\n\n    if (distance && duration) {\n      summary += ' (' + distance + ' - ' + duration + ')';\n    }\n\n    summary += newLine + newLine;\n\n    let stops: string =\n      this.languageService.translate.instant(\n        'igo.geo.directions.directionsText.stopList'\n      ) +\n      ':' +\n      newLine;\n\n    let stopNumber = 1;\n    this.stopsStore.view.all().forEach((stop) => {\n      let coords = '';\n      let stopText = '';\n      if (stop.text !== roundCoordToString(stop.coordinates, 6).join(', ')) {\n        stopText = stop.text;\n        coords = ` (${roundCoordToString(stop.coordinates, 6).join(', ')})`;\n      } else {\n        stopText = roundCoordToString(stop.coordinates, 6).join(', ');\n      }\n\n      stops =\n        stops +\n        indent +\n        stopNumber.toLocaleString() +\n        '. ' +\n        stopText +\n        coords +\n        newLine;\n      stopNumber++;\n    });\n    stops += newLine;\n\n    const url: string =\n      this.languageService.translate.instant(\n        'igo.geo.directions.directionsText.link'\n      ) +\n      ':' +\n      newLine +\n      indent +\n      this.getLink() +\n      newLine +\n      newLine;\n\n    let directions: string =\n      this.languageService.translate.instant('igo.geo.directions.directions') +\n      ':' +\n      newLine;\n\n    this.activeRoute.properties.directions.steps.forEach(\n      (step, stepIndex, steps) => {\n        const distance: string = formatDistance(step.distance);\n        const duration: string = formatDuration(step.duration);\n        if ((distance && duration) || stepIndex === steps.length - 1) {\n          const instruction: string = this.getFormattedStepInstruction(\n            step,\n            stepIndex\n          );\n          const formattedDistanceDuration: string =\n            distance && duration ? ` (${distance} - ${duration}) ` : '';\n          directions =\n            directions +\n            indent +\n            '- ' +\n            instruction +\n            formattedDistanceDuration +\n            newLine;\n        }\n      }\n    );\n\n    const directionsBody: string = summary + stops + url + directions;\n\n    return directionsBody;\n  }\n\n  /**\n   * Formats a step.\n   *\n   * @param {IgoStep} step - The step to format.\n   * @param {number} stepIndex - The index of the step in the directions.\n   * @return {string} The formatted instruction for the step.\n   */\n  private getFormattedStepInstruction(\n    step: IgoStep,\n    stepIndex: number\n  ): string {\n    return formatStep(\n      step,\n      this.languageService,\n      stepIndex === this.activeRoute.properties.directions.steps.length - 1\n    ).instruction;\n  }\n\n  /**\n   * Generates a link based on the current route and stops.\n   *\n   * @return {string | undefined} The generated link, or undefined if the route service is not available.\n   */\n  private getLink(): string | undefined {\n    if (!this.routeService) {\n      return;\n    }\n\n    let context = '';\n    if (this.contextUri) {\n      context = `context=${this.contextUri}&`;\n    }\n\n    const routeIndex: number = this.routesFeatureStore\n      .all()\n      .map((direction) => direction.properties.id)\n      .indexOf(this.activeRoute.properties.id);\n    let routingOptions = '';\n    if (routeIndex !== 0) {\n      const routingOptionsKey: string | boolean =\n        this.routeService.options.directionsOptionsKey;\n      routingOptions = `&${routingOptionsKey}=result:${routeIndex}`;\n    }\n    const directionsKey: string | boolean =\n      this.routeService.options.directionsCoordKey;\n    const stopsCoordinates: Coordinate[] = this.stopsStore.view\n      .all()\n      .map((stop) => roundCoordTo(stop.coordinates, 6));\n    let directionsUrl = '';\n    if (stopsCoordinates.length >= 2) {\n      directionsUrl = `${directionsKey}=${stopsCoordinates.join(';')}`;\n      return `${location.origin}${location.pathname}?${context}tool=directions&sidenav=1&${directionsUrl}${routingOptions}`;\n    }\n    return;\n  }\n}\n","<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.resetStops' | translate\"\n  color=\"warn\"\n  (click)=\"resetStops()\"\n>\n  <mat-icon>restart_alt</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.zoomOnRoute' | translate\"\n  color=\"primary\"\n  (click)=\"zoomOnActiveRoute()\"\n>\n  <mat-icon>frame_inspect</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.copyDirections' | translate\"\n  color=\"primary\"\n  (click)=\"copyDirectionsToClipboard()\"\n>\n  <mat-icon>content_copy</mat-icon>\n</button>\n<button\n  mat-icon-button\n  [matTooltip]=\"'igo.geo.directions.buttons.copyLink' | translate\"\n  color=\"primary\"\n  (click)=\"copyLinkToClipboard()\"\n>\n  <mat-icon>link</mat-icon>\n</button>\n\n<button\n  mat-icon-button\n  [disabled]=\"downloadDirectionsBtnDisabled\"\n  [matTooltip]=\"'igo.geo.directions.buttons.downloadDirections' | translate\"\n  color=\"primary\"\n  (click)=\"downloadDirections()\"\n>\n  <mat-icon>download</mat-icon>\n</button>\n"]}

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

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