@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/directions/shared/directions-source.service.mjs

@@ -0,0 +1,18 @@
+import { DirectionsSource } from '../directions-sources/directions-source';
+export class DirectionsSourceService {
+    sources;
+    constructor(sources) {
+        this.sources = sources;
+    }
+}
+export function directionsSourceServiceFactory(sources) {
+    return new DirectionsSourceService(sources);
+}
+export function provideDirectionsSourceService() {
+    return {
+        provide: DirectionsSourceService,
+        useFactory: directionsSourceServiceFactory,
+        deps: [DirectionsSource]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlyZWN0aW9ucy1zb3VyY2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL2RpcmVjdGlvbnMvc2hhcmVkL2RpcmVjdGlvbnMtc291cmNlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFFM0UsTUFBTSxPQUFPLHVCQUF1QjtJQUNmO0lBQW5CLFlBQW1CLE9BQTJCO1FBQTNCLFlBQU8sR0FBUCxPQUFPLENBQW9CO0lBQUcsQ0FBQztDQUNuRDtBQUVELE1BQU0sVUFBVSw4QkFBOEIsQ0FBQyxPQUEyQjtJQUN4RSxPQUFPLElBQUksdUJBQXVCLENBQUMsT0FBTyxDQUFDLENBQUM7QUFDOUMsQ0FBQztBQUVELE1BQU0sVUFBVSw4QkFBOEI7SUFDNUMsT0FBTztRQUNMLE9BQU8sRUFBRSx1QkFBdUI7UUFDaEMsVUFBVSxFQUFFLDhCQUE4QjtRQUMxQyxJQUFJLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztLQUN6QixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGlvbnNTb3VyY2UgfSBmcm9tICcuLi9kaXJlY3Rpb25zLXNvdXJjZXMvZGlyZWN0aW9ucy1zb3VyY2UnO1xuXG5leHBvcnQgY2xhc3MgRGlyZWN0aW9uc1NvdXJjZVNlcnZpY2Uge1xuICBjb25zdHJ1Y3RvcihwdWJsaWMgc291cmNlczogRGlyZWN0aW9uc1NvdXJjZVtdKSB7fVxufVxuXG5leHBvcnQgZnVuY3Rpb24gZGlyZWN0aW9uc1NvdXJjZVNlcnZpY2VGYWN0b3J5KHNvdXJjZXM6IERpcmVjdGlvbnNTb3VyY2VbXSkge1xuICByZXR1cm4gbmV3IERpcmVjdGlvbnNTb3VyY2VTZXJ2aWNlKHNvdXJjZXMpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZURpcmVjdGlvbnNTb3VyY2VTZXJ2aWNlKCkge1xuICByZXR1cm4ge1xuICAgIHByb3ZpZGU6IERpcmVjdGlvbnNTb3VyY2VTZXJ2aWNlLFxuICAgIHVzZUZhY3Rvcnk6IGRpcmVjdGlvbnNTb3VyY2VTZXJ2aWNlRmFjdG9yeSxcbiAgICBkZXBzOiBbRGlyZWN0aW9uc1NvdXJjZV1cbiAgfTtcbn1cbiJdfQ==

package/esm2022/lib/directions/shared/directions.enum.mjs

@@ -0,0 +1,72 @@
+export var DirectionsFormat;
+(function (DirectionsFormat) {
+    DirectionsFormat[DirectionsFormat["GeoJSON"] = 0] = "GeoJSON";
+    DirectionsFormat[DirectionsFormat["JSON"] = 1] = "JSON";
+})(DirectionsFormat || (DirectionsFormat = {}));
+export var SourceDirectionsType;
+(function (SourceDirectionsType) {
+    SourceDirectionsType["Route"] = "route";
+    SourceDirectionsType["Trip"] = "trip";
+})(SourceDirectionsType || (SourceDirectionsType = {}));
+export var ProposalType;
+(function (ProposalType) {
+    ProposalType["Coord"] = "coord";
+    ProposalType["Text"] = "text";
+})(ProposalType || (ProposalType = {}));
+export var DirectionsType;
+(function (DirectionsType) {
+    DirectionsType["Stop"] = "stop";
+    DirectionsType["Route"] = "route";
+    DirectionsType["Vertex"] = "vertex";
+})(DirectionsType || (DirectionsType = {}));
+export var DirectionRelativePositionType;
+(function (DirectionRelativePositionType) {
+    DirectionRelativePositionType["Start"] = "start";
+    DirectionRelativePositionType["Intermediate"] = "intermediate";
+    DirectionRelativePositionType["End"] = "end";
+})(DirectionRelativePositionType || (DirectionRelativePositionType = {}));
+export var ManeuverType;
+(function (ManeuverType) {
+    ManeuverType["Turn"] = "turn";
+    ManeuverType["NewName"] = "new name";
+    ManeuverType["Depart"] = "depart";
+    ManeuverType["Arrive"] = "arrive";
+    ManeuverType["Merge"] = "merge";
+    ManeuverType["Ramp"] = "ramp";
+    ManeuverType["OnRamp"] = "on ramp";
+    ManeuverType["OffRamp"] = "off ramp";
+    ManeuverType["Fork"] = "fork";
+    ManeuverType["EndOfRoad"] = "end of road";
+    ManeuverType["UseLane"] = "use lane";
+    ManeuverType["Continue"] = "continue";
+    ManeuverType["Roundabout"] = "roundabout";
+    ManeuverType["Rotary"] = "rotary";
+    ManeuverType["RoundaboutTurn"] = "roundabout turn";
+    ManeuverType["Notification"] = "notification";
+    ManeuverType["ExitRoundabout"] = "exit roundabout";
+    ManeuverType["ExitRotary"] = "exit rotary";
+})(ManeuverType || (ManeuverType = {}));
+export var ManeuverModifier;
+(function (ManeuverModifier) {
+    ManeuverModifier["Uturn"] = "uturn";
+    ManeuverModifier["SharpRight"] = "sharp right";
+    ManeuverModifier["Right"] = "right";
+    ManeuverModifier["SlightRight"] = "slight right";
+    ManeuverModifier["SharpLeft"] = "sharp left";
+    ManeuverModifier["Left"] = "left";
+    ManeuverModifier["SlightLeft"] = "slight left";
+    ManeuverModifier["Straight"] = "straight";
+})(ManeuverModifier || (ManeuverModifier = {}));
+export var LaneType;
+(function (LaneType) {
+    LaneType["None"] = "none";
+    LaneType["Uturn"] = "uturn";
+    LaneType["SharpRight"] = "sharp right";
+    LaneType["Right"] = "right";
+    LaneType["SlightRight"] = "slight right";
+    LaneType["SharpLeft"] = "sharp left";
+    LaneType["Left"] = "left";
+    LaneType["SlightLeft"] = "slight left";
+    LaneType["Straight"] = "straight";
+})(LaneType || (LaneType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directions/shared/directions.interface.mjs

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

package/esm2022/lib/directions/shared/directions.service.mjs

@@ -0,0 +1,239 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { ActivityService } from '@igo2/core/activity';
+import { ConfigService } from '@igo2/core/config';
+import { LanguageService } from '@igo2/core/language';
+import { SubjectStatus } from '@igo2/utils';
+import html2canvas from 'html2canvas';
+import { jsPDF } from 'jspdf';
+import { autoTable } from 'jspdf-autotable';
+import moment from 'moment';
+import { Subject } from 'rxjs';
+import { PrintService } from '../../print/shared/print.service';
+import { DirectionsSourceService } from './directions-source.service';
+import { formatDistance, formatDuration, formatStep } from './directions.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./directions-source.service";
+import * as i2 from "@igo2/core/config";
+import * as i3 from "@igo2/core/language";
+import * as i4 from "../../print/shared/print.service";
+import * as i5 from "@igo2/core/activity";
+export class DirectionsService {
+    directionsSourceService;
+    configService;
+    languageService;
+    printService;
+    document;
+    activityService;
+    constructor(directionsSourceService, configService, languageService, printService, document, activityService) {
+        this.directionsSourceService = directionsSourceService;
+        this.configService = configService;
+        this.languageService = languageService;
+        this.printService = printService;
+        this.document = document;
+        this.activityService = activityService;
+    }
+    /**
+     * Routes the given coordinates using the specified directions source and options.
+     *
+     * @param {DirectionsSource} source - The directions source to use for routing.
+     * @param {Position[]} coordinates - The array of coordinates to route.
+     * @param {DirectionOptions} [directionsOptions={}] - The optional direction options.
+     * @return {Observable<Directions[]>} An observable that emits an array of directions.
+     */
+    route(coordinates, directionsOptions = {}) {
+        if (coordinates.length === 0) {
+            return;
+        }
+        const source = this.directionsSourceService.sources[0];
+        const request = source.route(coordinates, directionsOptions);
+        return request;
+    }
+    /**
+     * Downloads directions for a given map and directions object.
+     *
+     * @param {IgoMap} map - The map object to download directions for.
+     * @param {Directions} directions - The directions object containing the route information.
+     * @return {Observable<SubjectStatus>} An observable that emits the status of the download process.
+     */
+    downloadDirections(map, directions) {
+        const activityId = this.activityService.register();
+        const status$ = new Subject();
+        const doc = new jsPDF({
+            orientation: 'p',
+            format: 'letter',
+            unit: 'mm' // default
+        });
+        const pageSize = doc.internal.pageSize;
+        const margins = [30, 10, 20, 10];
+        const zoneWidth = pageSize.getWidth() - margins[3] - margins[1];
+        const zoneHeight = pageSize.getHeight() - margins[0] - margins[2];
+        const imageDimensions = [zoneWidth, zoneHeight];
+        const distance = formatDistance(directions.distance);
+        const duration = formatDuration(directions.duration);
+        const title = distance && duration
+            ? `${directions.title} (${distance} - ${duration})`
+            : directions.title;
+        doc.text(title, pageSize.getWidth() / 2, 25, {
+            align: 'center'
+        });
+        const resolution = 96; // Default is 96
+        this.printService
+            .addMap(doc, map, resolution, imageDimensions, margins)
+            .subscribe(async (status) => {
+            if (status === SubjectStatus.Done) {
+                await this.addInstructions(doc, directions, title);
+                this.setPageHeaderFooter(doc);
+                await doc.save(`${title}.pdf`, { returnPromise: true });
+            }
+            this.activityService.unregister(activityId);
+            status$.next(status);
+        });
+        return status$;
+    }
+    /**
+     * Generates an HTML table element with directions steps.
+     *
+     * @param {Directions} directions - The directions object containing the steps.
+     * @return {Promise<HTMLTableElement>} - A promise that resolves to the generated HTML table element.
+     */
+    async setHTMLTableDirections(directions) {
+        const steps = await this.directionsSteps(directions);
+        const table = document.createElement('table');
+        const tblBody = document.createElement('tbody');
+        for (const step of steps) {
+            const row = document.createElement('tr');
+            // icon
+            const cellIcon = document.createElement('td');
+            const iconElement = document.createElement('img');
+            iconElement.style.verticalAlign = 'middle';
+            iconElement.src = step.icon;
+            cellIcon.appendChild(iconElement);
+            row.append(cellIcon);
+            // instruction
+            const cellText = document.createElement('td');
+            const spanInstructionElement = document.createElement('span');
+            spanInstructionElement.style.verticalAlign = 'middle';
+            spanInstructionElement.innerHTML = step.instruction;
+            cellText.appendChild(spanInstructionElement);
+            // distance/duration
+            if (step.distanceDuration) {
+                const spanDistanceElement = document.createElement('span');
+                spanDistanceElement.style.verticalAlign = 'middle';
+                spanDistanceElement.innerHTML = ' ' + step.distanceDuration;
+                cellText.appendChild(spanDistanceElement);
+            }
+            row.append(cellText);
+            tblBody.appendChild(row);
+        }
+        table.appendChild(tblBody);
+        return table;
+    }
+    /**
+     * Generates formatted steps for the given directions.
+     *
+     * @param {Directions} directions - The directions object containing the steps.
+     * @return {Promise<{ instruction: string; icon: string; distanceDuration: string }[]>}
+     * A promise that resolves to an array of formatted steps.
+     */
+    async directionsSteps(directions) {
+        const matListElement = this.document
+            .getElementsByTagName('igo-directions-results')[0]
+            .getElementsByTagName('mat-list')[0];
+        const matListItemElements = matListElement.getElementsByTagName('mat-list-item');
+        // convert icons list to base64
+        const icons = [];
+        for (const element of Array.from(matListItemElements)) {
+            const iconElement = element.getElementsByTagName('mat-icon')[0];
+            const iconName = iconElement.innerText;
+            const found = icons.some((icon) => icon.name === iconName);
+            if (!found) {
+                const iconCanvas = await html2canvas(iconElement);
+                icons.push({ name: iconName, icon: iconCanvas.toDataURL() });
+            }
+        }
+        const formattedSteps = [];
+        for (let stepIndex = 0; stepIndex < directions.steps.length; stepIndex++) {
+            const step = directions.steps[stepIndex];
+            const formattedStep = formatStep(step, this.languageService, stepIndex === directions.steps.length - 1);
+            const formattedDistance = formatDistance(step.distance);
+            const formattedDuration = formatDuration(step.duration);
+            if ((formattedDistance && formattedDuration) ||
+                stepIndex === directions.steps.length - 1) {
+                formattedSteps.push({
+                    instruction: `${formattedStep.instruction}`,
+                    icon: icons.find((icon) => icon.name === formattedStep.iconName).icon,
+                    distanceDuration: formattedDistance && formattedDuration
+                        ? `(${formattedDistance} - ${formattedDuration})`
+                        : ''
+                });
+            }
+        }
+        return formattedSteps;
+    }
+    /**
+     * Adds instructions to the given jsPDF document.
+     *
+     * @param {jsPDF} doc - The jsPDF document to add instructions to.
+     * @param {Directions} directions - The directions object containing the instructions.
+     * @param {string} title - The title of the instructions.
+     * @return {Promise<void>} A promise that resolves when the instructions are added to the document.
+     */
+    async addInstructions(doc, directions, title) {
+        doc.addPage();
+        doc.text(title, doc.internal.pageSize.getWidth() / 2, 25, {
+            align: 'center'
+        });
+        const HTMLtable = await this.setHTMLTableDirections(directions);
+        autoTable(doc, {
+            html: HTMLtable,
+            startY: 30,
+            margin: { top: 20, bottom: 20 },
+            columnStyles: {
+                0: { cellWidth: 10 }
+            },
+            theme: 'plain',
+            styles: {
+                fontSize: 10
+            },
+            didDrawCell: function (data) {
+                if (data.column.index === 0 && data.cell.section === 'body') {
+                    data.row.height = 10;
+                    const td = data.cell.raw;
+                    const img = td.getElementsByTagName('img')[0];
+                    doc.addImage(img.src, data.cell.x, data.cell.y, 8, 8);
+                }
+            }
+        });
+    }
+    /**
+     * Sets the header and footer of each page in the given jsPDF document.
+     *
+     * @param {jsPDF} doc - The jsPDF document to modify.
+     */
+    setPageHeaderFooter(doc) {
+        const pageCount = doc.getNumberOfPages();
+        const dateTime = moment(Date.now()).format('YYYY-MM-DD HH:mm');
+        const logo = this.configService.getConfig('directionsSources.logo')
+            ? this.configService.getConfig('directionsSources.logo')
+            : 'assets/logo.png';
+        for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {
+            doc.setPage(pageIndex);
+            doc.setFontSize(8);
+            const pageSize = doc.internal.pageSize;
+            doc.text(dateTime, 10, 10, { baseline: 'top' });
+            doc.addImage(logo, 'PNG', pageSize.getWidth() - 20, 5, 10, 10);
+            doc.text(dateTime, 10, pageSize.getHeight() - 10);
+            doc.text('Page ' + doc.getCurrentPageInfo().pageNumber + ' / ' + pageCount, pageSize.getWidth() - 20, pageSize.getHeight() - 10);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DirectionsService, deps: [{ token: i1.DirectionsSourceService }, { token: i2.ConfigService }, { token: i3.LanguageService }, { token: i4.PrintService }, { token: DOCUMENT }, { token: i5.ActivityService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DirectionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DirectionsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.DirectionsSourceService }, { type: i2.ConfigService }, { type: i3.LanguageService }, { type: i4.PrintService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i5.ActivityService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directions.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/directions/shared/directions.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { Inject, Injectable } from '@angular/core';\n\nimport { ActivityService } from '@igo2/core/activity';\nimport { ConfigService } from '@igo2/core/config';\nimport { LanguageService } from '@igo2/core/language';\nimport { SubjectStatus } from '@igo2/utils';\n\nimport { Position } from 'geojson';\nimport html2canvas from 'html2canvas';\nimport { jsPDF } from 'jspdf';\nimport { UserOptions, autoTable } from 'jspdf-autotable';\nimport moment from 'moment';\nimport { Observable, Subject } from 'rxjs';\n\nimport { IgoMap } from '../../map/shared/map';\nimport { PrintService } from '../../print/shared/print.service';\nimport { DirectionsSource } from '../directions-sources/directions-source';\nimport { DirectionOptions, Directions } from '../shared/directions.interface';\nimport { DirectionsSourceService } from './directions-source.service';\nimport { FormattedStep, IgoStep } from './directions.interface';\nimport { formatDistance, formatDuration, formatStep } from './directions.utils';\n\n@Injectable()\nexport class DirectionsService {\n  constructor(\n    private directionsSourceService: DirectionsSourceService,\n    private configService: ConfigService,\n    private languageService: LanguageService,\n    private printService: PrintService,\n    @Inject(DOCUMENT) private document: Document,\n    private activityService: ActivityService\n  ) {}\n\n  /**\n   * Routes the given coordinates using the specified directions source and options.\n   *\n   * @param {DirectionsSource} source - The directions source to use for routing.\n   * @param {Position[]} coordinates - The array of coordinates to route.\n   * @param {DirectionOptions} [directionsOptions={}] - The optional direction options.\n   * @return {Observable<Directions[]>} An observable that emits an array of directions.\n   */\n  route(\n    coordinates: Position[],\n    directionsOptions: DirectionOptions = {}\n  ): Observable<Directions[]> {\n    if (coordinates.length === 0) {\n      return;\n    }\n    const source: DirectionsSource = this.directionsSourceService.sources[0];\n    const request = source.route(coordinates, directionsOptions);\n    return request;\n  }\n\n  /**\n   * Downloads directions for a given map and directions object.\n   *\n   * @param {IgoMap} map - The map object to download directions for.\n   * @param {Directions} directions - The directions object containing the route information.\n   * @return {Observable<SubjectStatus>} An observable that emits the status of the download process.\n   */\n  downloadDirections(\n    map: IgoMap,\n    directions: Directions\n  ): Observable<SubjectStatus> {\n    const activityId: string = this.activityService.register();\n    const status$: Subject<SubjectStatus> = new Subject<SubjectStatus>();\n\n    const doc: jsPDF = new jsPDF({\n      orientation: 'p',\n      format: 'letter',\n      unit: 'mm' // default\n    });\n\n    const pageSize = doc.internal.pageSize;\n\n    const margins: [number, number, number, number] = [30, 10, 20, 10];\n\n    const zoneWidth: number = pageSize.getWidth() - margins[3] - margins[1];\n    const zoneHeight: number = pageSize.getHeight() - margins[0] - margins[2];\n    const imageDimensions: [number, number] = [zoneWidth, zoneHeight];\n\n    const distance: string = formatDistance(directions.distance);\n    const duration: string = formatDuration(directions.duration);\n\n    const title: string =\n      distance && duration\n        ? `${directions.title} (${distance} - ${duration})`\n        : directions.title;\n\n    doc.text(title, pageSize.getWidth() / 2, 25, {\n      align: 'center'\n    });\n\n    const resolution = 96; // Default is 96\n    this.printService\n      .addMap(doc, map, resolution, imageDimensions, margins)\n      .subscribe(async (status: SubjectStatus) => {\n        if (status === SubjectStatus.Done) {\n          await this.addInstructions(doc, directions, title);\n          this.setPageHeaderFooter(doc);\n          await doc.save(`${title}.pdf`, { returnPromise: true });\n        }\n\n        this.activityService.unregister(activityId);\n        status$.next(status);\n      });\n\n    return status$;\n  }\n\n  /**\n   * Generates an HTML table element with directions steps.\n   *\n   * @param {Directions} directions - The directions object containing the steps.\n   * @return {Promise<HTMLTableElement>} - A promise that resolves to the generated HTML table element.\n   */\n  private async setHTMLTableDirections(\n    directions: Directions\n  ): Promise<HTMLTableElement> {\n    const steps = await this.directionsSteps(directions);\n    const table: HTMLTableElement = document.createElement('table');\n    const tblBody: HTMLTableSectionElement = document.createElement('tbody');\n\n    for (const step of steps) {\n      const row: HTMLTableRowElement = document.createElement('tr');\n\n      // icon\n      const cellIcon: HTMLTableCellElement = document.createElement('td');\n      const iconElement: HTMLImageElement = document.createElement('img');\n      iconElement.style.verticalAlign = 'middle';\n      iconElement.src = step.icon;\n      cellIcon.appendChild(iconElement);\n      row.append(cellIcon);\n\n      // instruction\n      const cellText: HTMLTableCellElement = document.createElement('td');\n      const spanInstructionElement: HTMLSpanElement =\n        document.createElement('span');\n      spanInstructionElement.style.verticalAlign = 'middle';\n      spanInstructionElement.innerHTML = step.instruction;\n      cellText.appendChild(spanInstructionElement);\n\n      // distance/duration\n      if (step.distanceDuration) {\n        const spanDistanceElement: HTMLSpanElement =\n          document.createElement('span');\n        spanDistanceElement.style.verticalAlign = 'middle';\n        spanDistanceElement.innerHTML = ' ' + step.distanceDuration;\n        cellText.appendChild(spanDistanceElement);\n      }\n\n      row.append(cellText);\n      tblBody.appendChild(row);\n    }\n    table.appendChild(tblBody);\n    return table;\n  }\n\n  /**\n   * Generates formatted steps for the given directions.\n   *\n   * @param {Directions} directions - The directions object containing the steps.\n   * @return {Promise<{ instruction: string; icon: string; distanceDuration: string }[]>}\n   * A promise that resolves to an array of formatted steps.\n   */\n  private async directionsSteps(\n    directions: Directions\n  ): Promise<\n    { instruction: string; icon: string; distanceDuration: string }[]\n  > {\n    const matListElement: Element = this.document\n      .getElementsByTagName('igo-directions-results')[0]\n      .getElementsByTagName('mat-list')[0];\n    const matListItemElements: HTMLCollectionOf<Element> =\n      matListElement.getElementsByTagName('mat-list-item');\n    // convert icons list to base64\n    const icons: { name: string; icon: string }[] = [];\n    for (const element of Array.from(matListItemElements)) {\n      const iconElement: HTMLElement = element.getElementsByTagName(\n        'mat-icon'\n      )[0] as HTMLElement;\n      const iconName: string = iconElement.innerText;\n      const found: boolean = icons.some((icon) => icon.name === iconName);\n      if (!found) {\n        const iconCanvas: HTMLCanvasElement = await html2canvas(iconElement);\n        icons.push({ name: iconName, icon: iconCanvas.toDataURL() });\n      }\n    }\n\n    const formattedSteps: {\n      instruction: string;\n      icon: string;\n      distanceDuration: string;\n    }[] = [];\n    for (let stepIndex = 0; stepIndex < directions.steps.length; stepIndex++) {\n      const step: IgoStep = directions.steps[stepIndex];\n      const formattedStep: FormattedStep = formatStep(\n        step,\n        this.languageService,\n        stepIndex === directions.steps.length - 1\n      );\n\n      const formattedDistance: string = formatDistance(step.distance);\n      const formattedDuration: string = formatDuration(step.duration);\n\n      if (\n        (formattedDistance && formattedDuration) ||\n        stepIndex === directions.steps.length - 1\n      ) {\n        formattedSteps.push({\n          instruction: `${formattedStep.instruction}`,\n          icon: icons.find((icon) => icon.name === formattedStep.iconName).icon,\n          distanceDuration:\n            formattedDistance && formattedDuration\n              ? `(${formattedDistance} - ${formattedDuration})`\n              : ''\n        });\n      }\n    }\n    return formattedSteps;\n  }\n\n  /**\n   * Adds instructions to the given jsPDF document.\n   *\n   * @param {jsPDF} doc - The jsPDF document to add instructions to.\n   * @param {Directions} directions - The directions object containing the instructions.\n   * @param {string} title - The title of the instructions.\n   * @return {Promise<void>} A promise that resolves when the instructions are added to the document.\n   */\n  private async addInstructions(\n    doc: jsPDF,\n    directions: Directions,\n    title: string\n  ): Promise<void> {\n    doc.addPage();\n    doc.text(title, doc.internal.pageSize.getWidth() / 2, 25, {\n      align: 'center'\n    });\n    const HTMLtable: HTMLTableElement =\n      await this.setHTMLTableDirections(directions);\n    autoTable(doc, {\n      html: HTMLtable,\n      startY: 30,\n      margin: { top: 20, bottom: 20 },\n      columnStyles: {\n        0: { cellWidth: 10 }\n      },\n      theme: 'plain',\n      styles: {\n        fontSize: 10\n      },\n      didDrawCell: function (data) {\n        if (data.column.index === 0 && data.cell.section === 'body') {\n          data.row.height = 10;\n          const td: HTMLElement = data.cell.raw as HTMLElement;\n          const img: HTMLImageElement = td.getElementsByTagName('img')[0];\n          doc.addImage(img.src, data.cell.x, data.cell.y, 8, 8);\n        }\n      }\n    } satisfies UserOptions);\n  }\n\n  /**\n   * Sets the header and footer of each page in the given jsPDF document.\n   *\n   * @param {jsPDF} doc - The jsPDF document to modify.\n   */\n  private setPageHeaderFooter(doc: jsPDF): void {\n    const pageCount: number = doc.getNumberOfPages();\n    const dateTime: string = moment(Date.now()).format('YYYY-MM-DD HH:mm');\n\n    const logo: string = this.configService.getConfig('directionsSources.logo')\n      ? this.configService.getConfig('directionsSources.logo')\n      : 'assets/logo.png';\n\n    for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {\n      doc.setPage(pageIndex);\n      doc.setFontSize(8);\n      const pageSize = doc.internal.pageSize;\n      doc.text(dateTime, 10, 10, { baseline: 'top' });\n      doc.addImage(logo, 'PNG', pageSize.getWidth() - 20, 5, 10, 10);\n      doc.text(dateTime, 10, pageSize.getHeight() - 10);\n      doc.text(\n        'Page ' + doc.getCurrentPageInfo().pageNumber + ' / ' + pageCount,\n        pageSize.getWidth() - 20,\n        pageSize.getHeight() - 10\n      );\n    }\n  }\n}\n"]}