@igo2/geo 18.0.1-next.2 → 18.0.2

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

@@ -0,0 +1,522 @@
+import { NumberUtils, uuid } from '@igo2/utils';
+import olFeature from 'ol/Feature';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import * as olGeom from 'ol/geom';
+import * as olProj from 'ol/proj';
+import * as olStyle from 'ol/style';
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';
+import { FEATURE, FeatureMotion } from '../../feature/shared/feature.enums';
+import { tryAddLoadingStrategy } from '../../feature/shared/strategies.utils';
+import { FeatureStoreLoadingStrategy } from '../../feature/shared/strategies/loading';
+import { VectorLayer } from '../../layer/shared/layers/vector-layer';
+import { createOverlayMarkerStyle } from '../../style/shared/overlay/overlay-marker-style.utils';
+import { DirectionRelativePositionType, DirectionsType, ManeuverModifier, ManeuverType } from './directions.enum';
+/**
+ * Updates the sorting of the stops in the provided StopsStore based on the specified field and direction.
+ *
+ * @param {StopsStore} stopsStore - The StopsStore to update the sorting for.
+ * @param {'asc' | 'desc'} [direction='asc'] - The direction of sorting ('asc' for ascending, 'desc' for descending).
+ * @param {string} [field='position'] - The field to sort the stops by.
+ */
+export function updateStoreSorting(stopsStore, direction = 'asc', field = 'position') {
+    stopsStore.view.sort({
+        direction,
+        valueAccessor: (entity) => entity[field]
+    });
+}
+/**
+ * Computes the relative position of a stop in a list of stops.
+ *
+ * @param {number} stopIndex - The index of the stop.
+ * @param {number} stopListLength - The total number of stops.
+ * @return {DirectionRelativePositionType} The relative position of the stop.
+ */
+export function computeRelativePosition(stopIndex, stopListLength) {
+    let relativePosition = DirectionRelativePositionType.Intermediate;
+    if (stopIndex === 0) {
+        relativePosition = DirectionRelativePositionType.Start;
+    }
+    else if (stopIndex === stopListLength) {
+        relativePosition = DirectionRelativePositionType.End;
+    }
+    return relativePosition;
+}
+/**
+ * Computes the position and relative position of stops in the given stopsStore.
+ *
+ * @param {StopsStore} stopsStore - The store containing the stops.
+ */
+export function computeStopsPosition(deletedStopIndex, stopsStore) {
+    for (const stop of stopsStore.all()) {
+        stop.position =
+            stop.position > deletedStopIndex ? (stop.position -= 1) : stop.position;
+        stop.relativePosition = computeRelativePosition(stop.position, stopsStore.all().length - 1);
+    }
+}
+/**
+ * Adds a stop to the given stopsStore. The stop is always added as the last stop.
+ *
+ * @param {StopsStore} stopsStore - The store containing the stops.
+ * @return {Stop} The newly added stop.
+ */
+export function addStopToStore(stopsStore) {
+    const id = uuid();
+    const stops = stopsStore.all();
+    const insertIndex = stops.length;
+    for (const stop of stopsStore.all()) {
+        stop.relativePosition = computeRelativePosition(stop.position, stops.length);
+    }
+    stopsStore.insert({
+        id,
+        position: insertIndex,
+        relativePosition: computeRelativePosition(insertIndex, stops.length)
+    });
+    updateStoreSorting(stopsStore);
+    return stopsStore.get(id);
+}
+/**
+ * Removes a stop from the given stopsStore and updates the positions of the remaining stops.
+ *
+ * @param {StopsStore} stopsStore - The store containing the stops.
+ * @param {Stop} stop - The stop to be removed.
+ */
+export function removeStopFromStore(stopsStore, stop) {
+    stopsStore.delete(stop);
+    computeStopsPosition(stop.position, stopsStore);
+}
+/**
+ * Create a style for the directions steps, stops and route
+ * @param feature OlFeature
+ * @returns OL style function
+ */
+export function directionsStyle(feature) {
+    const stepStyle = [
+        new olStyle.Style({
+            geometry: feature.getGeometry(),
+            image: new olStyle.Circle({
+                radius: 7,
+                stroke: new olStyle.Stroke({ color: '#FF0000', width: 3 })
+            })
+        })
+    ];
+    const stopStyle = createOverlayMarkerStyle({
+        text: feature.get('stopText'),
+        opacity: feature.get('stopOpacity'),
+        markerColor: feature.get('stopColor'),
+        markerOutlineColor: [255, 255, 255]
+    });
+    const routeStyle = [
+        new olStyle.Style({
+            stroke: new olStyle.Stroke({
+                color: `rgba(106, 121, 130, ${feature.get('active') ? 0.75 : 0})`,
+                width: 10
+            })
+        }),
+        new olStyle.Style({
+            stroke: new olStyle.Stroke({
+                color: `rgba(79, 169, 221, ${feature.get('active') ? 0.75 : 0})`,
+                width: 6
+            })
+        })
+    ];
+    if (feature.get('type') === DirectionsType.Stop) {
+        return stopStyle;
+    }
+    if (feature.get('type') === DirectionsType.Vertex) {
+        return stepStyle;
+    }
+    if (feature.get('type') === DirectionsType.Route) {
+        return routeStyle;
+    }
+}
+/**
+ * Initializes the stops feature store with the provided language service.
+ *
+ * @param {StopsFeatureStore} stopsFeatureStore - The stops feature store to initialize.
+ * @param {LanguageService} languageService - The language service used for translations.
+ */
+export function initStopsFeatureStore(stopsFeatureStore, languageService) {
+    const loadingStrategy = new FeatureStoreLoadingStrategy({
+        motion: FeatureMotion.None
+    });
+    const stopsLayer = new VectorLayer({
+        isIgoInternalLayer: true,
+        id: 'igo-direction-stops-layer',
+        title: languageService.translate.instant('igo.geo.directions.layer.stops'),
+        zIndex: 911,
+        source: new FeatureDataSource(),
+        showInLayerList: true,
+        visible: true,
+        workspace: {
+            enabled: false
+        },
+        linkedLayers: {
+            linkId: 'igo-direction-stops-layer',
+            links: [
+                {
+                    syncedDelete: true,
+                    linkedIds: ['igo-direction-route-layer'],
+                    properties: []
+                }
+            ]
+        },
+        exportable: true,
+        browsable: false,
+        style: directionsStyle
+    });
+    tryBindStoreLayer(stopsFeatureStore, stopsLayer);
+    tryAddLoadingStrategy(stopsFeatureStore, loadingStrategy);
+}
+/**
+ * Initializes the routes feature store with the provided language service.
+ *
+ * @param {StopsFeatureStore} routesFeatureStore - The routes feature store to initialize.
+ * @param {LanguageService} languageService - The language service used for translations.
+ */
+export function initRoutesFeatureStore(routesFeatureStore, languageService) {
+    const loadingStrategy = new FeatureStoreLoadingStrategy({
+        motion: FeatureMotion.None
+    });
+    const routeLayer = new VectorLayer({
+        isIgoInternalLayer: true,
+        id: 'igo-direction-route-layer',
+        title: languageService.translate.instant('igo.geo.directions.layer.route'),
+        zIndex: 910,
+        source: new FeatureDataSource(),
+        showInLayerList: true,
+        visible: true,
+        workspace: {
+            enabled: false
+        },
+        linkedLayers: {
+            linkId: 'igo-direction-route-layer'
+        },
+        exportable: true,
+        browsable: false,
+        style: directionsStyle
+    });
+    tryBindStoreLayer(routesFeatureStore, routeLayer);
+    tryAddLoadingStrategy(routesFeatureStore, loadingStrategy);
+}
+/**
+ * Initializes the routes feature store.
+ *
+ * @param {StopsFeatureStore} stepsFeatureStore - The steps feature store to initialize.
+ */
+export function initStepsFeatureStore(stepsFeatureStore) {
+    const loadingStrategy = new FeatureStoreLoadingStrategy({
+        motion: FeatureMotion.None
+    });
+    const stepLayer = new VectorLayer({
+        isIgoInternalLayer: true,
+        id: 'igo-direction-step-layer',
+        title: '',
+        zIndex: 910,
+        source: new FeatureDataSource(),
+        showInLayerList: false,
+        visible: true,
+        workspace: {
+            enabled: false
+        },
+        linkedLayers: {
+            linkId: 'igo-direction-route-layer'
+        },
+        exportable: false,
+        browsable: false,
+        style: directionsStyle
+    });
+    tryBindStoreLayer(stepsFeatureStore, stepLayer);
+    tryAddLoadingStrategy(stepsFeatureStore, loadingStrategy);
+}
+/**
+ * Adds a stop to the stopsFeatureStore.
+ *
+ * @param {Stop} stop - The stop to be added.
+ * @param {StopsFeatureStore} stopsFeatureStore - The stopsFeatureStore to add the stop to.
+ * @param {string} projection - The projection of the stop coordinates.
+ * @param {LanguageService} languageService - The language service for translating stop text.
+ */
+export function addStopToStopsFeatureStore(stop, stopsFeatureStore, projection, languageService) {
+    let stopColor;
+    let stopText;
+    switch (stop.relativePosition) {
+        case DirectionRelativePositionType.Start:
+            stopColor = '#008000';
+            stopText = languageService.translate.instant('igo.geo.directions.input.start');
+            break;
+        case DirectionRelativePositionType.End:
+            stopColor = '#f64139';
+            stopText = languageService.translate.instant('igo.geo.directions.input.end');
+            break;
+        default:
+            stopColor = '#ffd700';
+            stopText =
+                languageService.translate.instant('igo.geo.directions.input.intermediate') +
+                    ' #' +
+                    stop.position;
+            break;
+    }
+    const point = new olGeom.Point(olProj.transform(stop.coordinates, projection, stopsFeatureStore.map.projectionCode));
+    const geojsonGeom = new OlGeoJSON().writeGeometryObject(point, {
+        featureProjection: stopsFeatureStore.map.projectionCode,
+        dataProjection: stopsFeatureStore.map.projectionCode
+    });
+    const previousStop = stopsFeatureStore.get(stop.id);
+    const previousStopRevision = previousStop
+        ? previousStop.meta.revision
+        : 0;
+    const stopFeatureStore = {
+        type: FEATURE,
+        geometry: geojsonGeom,
+        projection: stopsFeatureStore.map.projectionCode,
+        properties: {
+            id: stop.id,
+            type: DirectionsType.Stop,
+            stopText,
+            stopColor,
+            stopOpacity: 1,
+            stop
+        },
+        meta: {
+            id: stop.id,
+            revision: previousStopRevision + 1
+        },
+        ol: new olFeature({ point })
+    };
+    stopsFeatureStore.update(stopFeatureStore);
+}
+/**
+ * Adds a route to the routes feature store.
+ *
+ * @param {RoutesFeatureStore} routesFeatureStore - The routes feature store to add the route to.
+ * @param {Directions} directions - The directions object containing the geometry and other information.
+ * @param {string} projection - The projection of the geometry coordinates.
+ * @param {boolean} [active=false] - Indicates whether the direction is active or not. Default is false.
+ */
+export function addRouteToRoutesFeatureStore(routesFeatureStore, directions, projection, active = false) {
+    const coordinate = directions.geometry.coordinates;
+    const linestring4326 = new olGeom.LineString(coordinate);
+    const linestringStore = linestring4326.transform(projection, routesFeatureStore.map.projectionCode);
+    const geojsonGeom = new OlGeoJSON().writeGeometryObject(linestringStore, {
+        featureProjection: routesFeatureStore.map.projectionCode,
+        dataProjection: routesFeatureStore.map.projectionCode
+    });
+    const previousRoute = routesFeatureStore.get(directions.id);
+    const previousRouteRevision = previousRoute
+        ? previousRoute.meta.revision
+        : 0;
+    const routeFeatureStore = {
+        type: FEATURE,
+        geometry: geojsonGeom,
+        projection: routesFeatureStore.map.projectionCode,
+        properties: {
+            id: directions.id,
+            type: DirectionsType.Route,
+            active,
+            directions
+        },
+        meta: {
+            id: directions.id,
+            revision: previousRouteRevision + 1
+        },
+        ol: new olFeature({ linestringStore })
+    };
+    routesFeatureStore.update(routeFeatureStore);
+}
+/**
+ * Formats the given distance in meters to a human-readable string.
+ *
+ * @param {number} meters - The distance in meters to be formatted.
+ * @return {string | undefined} The formatted distance string.
+ */
+export function formatDistance(meters) {
+    if (meters === 0) {
+        return undefined;
+    }
+    if (meters < 1000) {
+        return `${Math.round(meters)} m`;
+    }
+    const kilometers = meters / 1000;
+    const roundToDecimal = kilometers >= 10 ? 1 : 0;
+    return `${NumberUtils.roundToNDecimal(kilometers, roundToDecimal)} km`.replace('.', ',');
+}
+/**
+ * Formats the given duration in seconds to a human-readable string.
+ *
+ * @param {number} seconds - The duration in seconds to be formatted.
+ * @return {string} The formatted duration string.
+ */
+export function formatDuration(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    if (hours) {
+        return `${hours} h ${minutes} min`;
+    }
+    if (minutes) {
+        return `${minutes} min`;
+    }
+    return '< 1 min';
+}
+export function formatStep(step, languageService, lastStep = false) {
+    const maneuverType = step.maneuver.type;
+    const maneuverModifier = step.maneuver.modifier;
+    const name = step.name;
+    const maneuverBearingAfter = step.maneuver.bearing_after;
+    const translate = languageService.translate;
+    const translatedManeuverBearingAfter = translateManeuverBearing(maneuverBearingAfter, languageService);
+    const translatedManeuverModifier = translateManeuverModifier(maneuverModifier, languageService);
+    let iconName = 'straight'; // arrow point up by default
+    let instruction = '';
+    if (maneuverType === ManeuverType.Turn) {
+        if (maneuverModifier === ManeuverModifier.Uturn ||
+            maneuverModifier === ManeuverModifier.Straight) {
+            instruction = translate.instant(`igo.geo.directions.results.maneuverType.turn.${maneuverModifier}`, {
+                maneuverModifier: translatedManeuverModifier,
+                name
+            });
+            if (maneuverModifier === ManeuverModifier.Uturn) {
+                iconName = 'u_turn_left';
+            }
+        }
+        else {
+            instruction = translate.instant('igo.geo.directions.results.maneuverType.turn.else', {
+                maneuverModifier: translatedManeuverModifier,
+                name
+            });
+            if (maneuverModifier === ManeuverModifier.SlightRight) {
+                iconName = 'turn_slight_right';
+            }
+            else if (maneuverModifier === ManeuverModifier.Right ||
+                maneuverModifier === ManeuverModifier.SharpRight) {
+                iconName = 'turn_right';
+            }
+            else if (maneuverModifier === ManeuverModifier.Left ||
+                maneuverModifier === ManeuverModifier.SharpLeft) {
+                iconName = 'turn_left';
+            }
+            else if (maneuverModifier === ManeuverModifier.SlightLeft) {
+                iconName = 'turn_slight_left';
+            }
+        }
+    }
+    else if (maneuverType === ManeuverType.NewName) {
+        instruction = translate.instant(`igo.geo.directions.results.maneuverType.new name`, {
+            name,
+            maneuverBearing: translatedManeuverBearingAfter
+        });
+    }
+    else if (maneuverType === ManeuverType.Depart) {
+        iconName = 'directions';
+        instruction = translate.instant(`igo.geo.directions.results.maneuverType.depart`, {
+            name,
+            maneuverBearing: translatedManeuverBearingAfter
+        });
+    }
+    else if (maneuverType === ManeuverType.Arrive) {
+        iconName = 'sports_score';
+        instruction = translate.instant(`igo.geo.directions.results.maneuverType.arrive.${lastStep ? 'lastStep' : 'intermediate'}`, {
+            name
+        });
+    }
+    else if (maneuverType === ManeuverType.Merge) {
+        instruction = translate.instant('igo.geo.directions.results.maneuverType.merge', {
+            name
+        });
+        iconName = 'merge';
+    }
+    else if (maneuverType === ManeuverType.OnRamp ||
+        maneuverType === ManeuverType.OffRamp) {
+        instruction = translate.instant(`igo.geo.directions.results.maneuverType.${maneuverType}`, {
+            maneuverModifier: translatedManeuverModifier
+        });
+    }
+    else if (maneuverType === ManeuverType.Fork) {
+        const directionKey = maneuverModifier.search('left') >= 0 ? 'left' : 'right';
+        iconName =
+            directionKey === 'left' ? 'turn_slight_left' : 'turn_slight_right';
+        instruction = translate.instant(`igo.geo.directions.results.maneuverType.fork.${directionKey}`, {
+            name
+        });
+    }
+    else if (maneuverType === ManeuverType.EndOfRoad ||
+        maneuverType === ManeuverType.UseLane ||
+        maneuverType === ManeuverType.Continue) {
+        if (maneuverType === ManeuverType.Continue) {
+            if (maneuverModifier === ManeuverModifier.Uturn) {
+                iconName = 'u_turn_left';
+                instruction = translate.instant(`igo.geo.directions.results.maneuverType.turn.${maneuverModifier}`, {
+                    maneuverModifier: translatedManeuverModifier,
+                    name
+                });
+            }
+            else {
+                instruction = translate.instant(`igo.geo.directions.results.maneuverType.${maneuverType}`, {
+                    maneuverModifier: translatedManeuverModifier,
+                    name
+                });
+            }
+        }
+        else {
+            if (maneuverModifier === ManeuverModifier.SharpRight ||
+                maneuverModifier === ManeuverModifier.Right) {
+                iconName = 'turn_right';
+            }
+            else if (maneuverModifier === ManeuverModifier.SharpLeft ||
+                maneuverModifier === ManeuverModifier.Left) {
+                iconName = 'turn_left';
+            }
+            else if (maneuverModifier === ManeuverModifier.SlightRight) {
+                iconName = 'turn_slight_right';
+            }
+            else if (maneuverModifier === ManeuverModifier.SlightLeft) {
+                iconName = 'turn_slight_left';
+            }
+            instruction = translate.instant(`igo.geo.directions.results.maneuverType.${maneuverType}`, {
+                maneuverModifier: translatedManeuverModifier,
+                name
+            });
+        }
+    }
+    else if (maneuverType === ManeuverType.Roundabout ||
+        maneuverType === ManeuverType.Rotary ||
+        maneuverType === ManeuverType.RoundaboutTurn ||
+        maneuverType === ManeuverType.ExitRoundabout) {
+        const roundaboutKey = maneuverType.replace('roundabout ', '');
+        instruction = translate.instant(`igo.geo.directions.results.maneuverType.${roundaboutKey}`, {
+            name
+        });
+        iconName = 'donut_large';
+    }
+    else if (maneuverType === ManeuverType.Notification) {
+        instruction = translate.instant('igo.geo.directions.results.maneuverType.notification');
+    }
+    return { instruction, iconName };
+}
+/**
+ * Translates a maneuver modifier into a human-readable string using the provided language service.
+ *
+ * @param {ManeuverModifier} maneuverModifier - The maneuver modifier to be translated.
+ * @param {LanguageService} languageService - The language service used for translation.
+ * @return {string | undefined} The translated maneuver modifier string, or undefined if the modifier is falsy.
+ */
+export function translateManeuverModifier(maneuverModifier, languageService) {
+    const translate = languageService.translate;
+    return maneuverModifier
+        ? translate.instant(`igo.geo.directions.results.maneuverModifier.${maneuverModifier}`)
+        : undefined;
+}
+/**
+ * Translates the given bearing value into a human-readable direction using the provided language service.
+ *
+ * @param {number} bearing - The bearing value to be translated.
+ * @param {LanguageService} languageService - The language service used for translation.
+ * @return {string} The translated direction corresponding to the given bearing value.
+ */
+export function translateManeuverBearing(bearing, languageService) {
+    const translate = languageService.translate;
+    const directions = ['n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw'];
+    const directionIndex = Math.round(bearing / 45) % 8;
+    return translate.instant(`igo.geo.directions.results.direction.${directions[directionIndex]}`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directions.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/directions/shared/directions.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { LanguageService } from '@igo2/core/language';\nimport { NumberUtils, uuid } from '@igo2/utils';\n\nimport olFeature from 'ol/Feature';\nimport { Coordinate } from 'ol/coordinate';\nimport OlGeoJSON from 'ol/format/GeoJSON';\nimport * as olGeom from 'ol/geom';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\nimport * as olProj from 'ol/proj';\nimport * as olStyle from 'ol/style';\n\nimport { TranslateService } from '@ngx-translate/core';\n\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\nimport { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';\nimport { FEATURE, FeatureMotion } from '../../feature/shared/feature.enums';\nimport { FeatureGeometry } from '../../feature/shared/feature.interfaces';\nimport { tryAddLoadingStrategy } from '../../feature/shared/strategies.utils';\nimport { FeatureStoreLoadingStrategy } from '../../feature/shared/strategies/loading';\nimport { VectorLayer } from '../../layer/shared/layers/vector-layer';\nimport { createOverlayMarkerStyle } from '../../style/shared/overlay/overlay-marker-style.utils';\nimport {\n  DirectionRelativePositionType,\n  DirectionsType,\n  ManeuverModifier,\n  ManeuverType\n} from './directions.enum';\nimport {\n  Directions,\n  FeatureWithDirections,\n  FeatureWithStop,\n  IgoStep,\n  Stop\n} from './directions.interface';\nimport {\n  RoutesFeatureStore,\n  StepsFeatureStore,\n  StopsFeatureStore,\n  StopsStore\n} from './store';\n\n/**\n * Updates the sorting of the stops in the provided StopsStore based on the specified field and direction.\n *\n * @param {StopsStore} stopsStore - The StopsStore to update the sorting for.\n * @param {'asc' | 'desc'} [direction='asc'] - The direction of sorting ('asc' for ascending, 'desc' for descending).\n * @param {string} [field='position'] - The field to sort the stops by.\n */\nexport function updateStoreSorting(\n  stopsStore: StopsStore,\n  direction: 'asc' | 'desc' = 'asc',\n  field = 'position'\n): void {\n  stopsStore.view.sort({\n    direction,\n    valueAccessor: (entity: Stop) => entity[field]\n  });\n}\n\n/**\n * Computes the relative position of a stop in a list of stops.\n *\n * @param {number} stopIndex - The index of the stop.\n * @param {number} stopListLength - The total number of stops.\n * @return {DirectionRelativePositionType} The relative position of the stop.\n */\nexport function computeRelativePosition(\n  stopIndex: number,\n  stopListLength: number\n): DirectionRelativePositionType {\n  let relativePosition: DirectionRelativePositionType =\n    DirectionRelativePositionType.Intermediate;\n  if (stopIndex === 0) {\n    relativePosition = DirectionRelativePositionType.Start;\n  } else if (stopIndex === stopListLength) {\n    relativePosition = DirectionRelativePositionType.End;\n  }\n  return relativePosition;\n}\n\n/**\n * Computes the position and relative position of stops in the given stopsStore.\n *\n * @param {StopsStore} stopsStore - The store containing the stops.\n */\nexport function computeStopsPosition(\n  deletedStopIndex: number,\n  stopsStore: StopsStore\n): void {\n  for (const stop of stopsStore.all()) {\n    stop.position =\n      stop.position > deletedStopIndex ? (stop.position -= 1) : stop.position;\n    stop.relativePosition = computeRelativePosition(\n      stop.position,\n      stopsStore.all().length - 1\n    );\n  }\n}\n\n/**\n * Adds a stop to the given stopsStore. The stop is always added as the last stop.\n *\n * @param {StopsStore} stopsStore - The store containing the stops.\n * @return {Stop} The newly added stop.\n */\nexport function addStopToStore(stopsStore: StopsStore): Stop {\n  const id: string = uuid();\n  const stops: Stop[] = stopsStore.all();\n  const insertIndex = stops.length;\n\n  for (const stop of stopsStore.all()) {\n    stop.relativePosition = computeRelativePosition(\n      stop.position,\n      stops.length\n    );\n  }\n\n  stopsStore.insert({\n    id,\n    position: insertIndex,\n    relativePosition: computeRelativePosition(insertIndex, stops.length)\n  });\n\n  updateStoreSorting(stopsStore);\n  return stopsStore.get(id);\n}\n\n/**\n * Removes a stop from the given stopsStore and updates the positions of the remaining stops.\n *\n * @param {StopsStore} stopsStore - The store containing the stops.\n * @param {Stop} stop - The stop to be removed.\n */\nexport function removeStopFromStore(stopsStore: StopsStore, stop: Stop): void {\n  stopsStore.delete(stop);\n  computeStopsPosition(stop.position, stopsStore);\n}\n\n/**\n * Create a style for the directions steps, stops and route\n * @param feature OlFeature\n * @returns OL style function\n */\nexport function directionsStyle(\n  feature: olFeature<OlGeometry>\n): olStyle.Style | olStyle.Style[] {\n  const stepStyle = [\n    new olStyle.Style({\n      geometry: feature.getGeometry(),\n      image: new olStyle.Circle({\n        radius: 7,\n        stroke: new olStyle.Stroke({ color: '#FF0000', width: 3 })\n      })\n    })\n  ];\n\n  const stopStyle: olStyle.Style = createOverlayMarkerStyle({\n    text: feature.get('stopText'),\n    opacity: feature.get('stopOpacity'),\n    markerColor: feature.get('stopColor'),\n    markerOutlineColor: [255, 255, 255]\n  });\n\n  const routeStyle: olStyle.Style[] = [\n    new olStyle.Style({\n      stroke: new olStyle.Stroke({\n        color: `rgba(106, 121, 130, ${feature.get('active') ? 0.75 : 0})`,\n        width: 10\n      })\n    }),\n    new olStyle.Style({\n      stroke: new olStyle.Stroke({\n        color: `rgba(79, 169, 221, ${feature.get('active') ? 0.75 : 0})`,\n        width: 6\n      })\n    })\n  ];\n\n  if (feature.get('type') === DirectionsType.Stop) {\n    return stopStyle;\n  }\n  if (feature.get('type') === DirectionsType.Vertex) {\n    return stepStyle;\n  }\n  if (feature.get('type') === DirectionsType.Route) {\n    return routeStyle;\n  }\n}\n\n/**\n * Initializes the stops feature store with the provided language service.\n *\n * @param {StopsFeatureStore} stopsFeatureStore - The stops feature store to initialize.\n * @param {LanguageService} languageService - The language service used for translations.\n */\nexport function initStopsFeatureStore(\n  stopsFeatureStore: StopsFeatureStore,\n  languageService: LanguageService\n): void {\n  const loadingStrategy: FeatureStoreLoadingStrategy =\n    new FeatureStoreLoadingStrategy({\n      motion: FeatureMotion.None\n    });\n\n  const stopsLayer: VectorLayer = new VectorLayer({\n    isIgoInternalLayer: true,\n    id: 'igo-direction-stops-layer',\n    title: languageService.translate.instant('igo.geo.directions.layer.stops'),\n    zIndex: 911,\n    source: new FeatureDataSource(),\n    showInLayerList: true,\n    visible: true,\n    workspace: {\n      enabled: false\n    },\n    linkedLayers: {\n      linkId: 'igo-direction-stops-layer',\n      links: [\n        {\n          syncedDelete: true,\n          linkedIds: ['igo-direction-route-layer'],\n          properties: []\n        }\n      ]\n    },\n    exportable: true,\n    browsable: false,\n    style: directionsStyle\n  });\n  tryBindStoreLayer(stopsFeatureStore, stopsLayer);\n  tryAddLoadingStrategy(stopsFeatureStore, loadingStrategy);\n}\n\n/**\n * Initializes the routes feature store with the provided language service.\n *\n * @param {StopsFeatureStore} routesFeatureStore - The routes feature store to initialize.\n * @param {LanguageService} languageService - The language service used for translations.\n */\nexport function initRoutesFeatureStore(\n  routesFeatureStore: RoutesFeatureStore,\n  languageService: LanguageService\n): void {\n  const loadingStrategy: FeatureStoreLoadingStrategy =\n    new FeatureStoreLoadingStrategy({\n      motion: FeatureMotion.None\n    });\n\n  const routeLayer: VectorLayer = new VectorLayer({\n    isIgoInternalLayer: true,\n    id: 'igo-direction-route-layer',\n    title: languageService.translate.instant('igo.geo.directions.layer.route'),\n    zIndex: 910,\n    source: new FeatureDataSource(),\n    showInLayerList: true,\n    visible: true,\n    workspace: {\n      enabled: false\n    },\n    linkedLayers: {\n      linkId: 'igo-direction-route-layer'\n    },\n    exportable: true,\n    browsable: false,\n    style: directionsStyle\n  });\n  tryBindStoreLayer(routesFeatureStore, routeLayer);\n  tryAddLoadingStrategy(routesFeatureStore, loadingStrategy);\n}\n\n/**\n * Initializes the routes feature store.\n *\n * @param {StopsFeatureStore} stepsFeatureStore - The steps feature store to initialize.\n */\nexport function initStepsFeatureStore(stepsFeatureStore: StepsFeatureStore) {\n  const loadingStrategy: FeatureStoreLoadingStrategy =\n    new FeatureStoreLoadingStrategy({\n      motion: FeatureMotion.None\n    });\n\n  const stepLayer: VectorLayer = new VectorLayer({\n    isIgoInternalLayer: true,\n    id: 'igo-direction-step-layer',\n    title: '',\n    zIndex: 910,\n    source: new FeatureDataSource(),\n    showInLayerList: false,\n    visible: true,\n    workspace: {\n      enabled: false\n    },\n    linkedLayers: {\n      linkId: 'igo-direction-route-layer'\n    },\n    exportable: false,\n    browsable: false,\n    style: directionsStyle\n  });\n  tryBindStoreLayer(stepsFeatureStore, stepLayer);\n  tryAddLoadingStrategy(stepsFeatureStore, loadingStrategy);\n}\n\n/**\n * Adds a stop to the stopsFeatureStore.\n *\n * @param {Stop} stop - The stop to be added.\n * @param {StopsFeatureStore} stopsFeatureStore - The stopsFeatureStore to add the stop to.\n * @param {string} projection - The projection of the stop coordinates.\n * @param {LanguageService} languageService - The language service for translating stop text.\n */\nexport function addStopToStopsFeatureStore(\n  stop: Stop,\n  stopsFeatureStore: StopsFeatureStore,\n  projection: string,\n  languageService: LanguageService\n): void {\n  let stopColor: string;\n  let stopText: string;\n\n  switch (stop.relativePosition) {\n    case DirectionRelativePositionType.Start:\n      stopColor = '#008000';\n      stopText = languageService.translate.instant(\n        'igo.geo.directions.input.start'\n      );\n      break;\n    case DirectionRelativePositionType.End:\n      stopColor = '#f64139';\n      stopText = languageService.translate.instant(\n        'igo.geo.directions.input.end'\n      );\n      break;\n    default:\n      stopColor = '#ffd700';\n      stopText =\n        languageService.translate.instant(\n          'igo.geo.directions.input.intermediate'\n        ) +\n        ' #' +\n        stop.position;\n      break;\n  }\n\n  const point: olGeom.Point = new olGeom.Point(\n    olProj.transform(\n      stop.coordinates,\n      projection,\n      stopsFeatureStore.map.projectionCode\n    )\n  );\n\n  const geojsonGeom: FeatureGeometry = new OlGeoJSON().writeGeometryObject(\n    point,\n    {\n      featureProjection: stopsFeatureStore.map.projectionCode,\n      dataProjection: stopsFeatureStore.map.projectionCode\n    }\n  ) as FeatureGeometry;\n\n  const previousStop: FeatureWithStop = stopsFeatureStore.get(stop.id);\n  const previousStopRevision: number = previousStop\n    ? previousStop.meta.revision\n    : 0;\n\n  const stopFeatureStore: FeatureWithStop = {\n    type: FEATURE,\n    geometry: geojsonGeom,\n    projection: stopsFeatureStore.map.projectionCode,\n    properties: {\n      id: stop.id,\n      type: DirectionsType.Stop,\n      stopText,\n      stopColor,\n      stopOpacity: 1,\n      stop\n    },\n    meta: {\n      id: stop.id,\n      revision: previousStopRevision + 1\n    },\n    ol: new olFeature({ point })\n  };\n  stopsFeatureStore.update(stopFeatureStore);\n}\n\n/**\n * Adds a route to the routes feature store.\n *\n * @param {RoutesFeatureStore} routesFeatureStore - The routes feature store to add the route to.\n * @param {Directions} directions - The directions object containing the geometry and other information.\n * @param {string} projection - The projection of the geometry coordinates.\n * @param {boolean} [active=false] - Indicates whether the direction is active or not. Default is false.\n */\nexport function addRouteToRoutesFeatureStore(\n  routesFeatureStore: RoutesFeatureStore,\n  directions: Directions,\n  projection: string,\n  active = false\n): void {\n  const coordinate: Coordinate = directions.geometry.coordinates;\n  const linestring4326: olGeom.LineString = new olGeom.LineString(coordinate);\n  const linestringStore: olGeom.LineString = linestring4326.transform(\n    projection,\n    routesFeatureStore.map.projectionCode\n  );\n\n  const geojsonGeom: FeatureGeometry = new OlGeoJSON().writeGeometryObject(\n    linestringStore,\n    {\n      featureProjection: routesFeatureStore.map.projectionCode,\n      dataProjection: routesFeatureStore.map.projectionCode\n    }\n  ) as FeatureGeometry;\n\n  const previousRoute: FeatureWithDirections = routesFeatureStore.get(\n    directions.id\n  );\n  const previousRouteRevision: number = previousRoute\n    ? previousRoute.meta.revision\n    : 0;\n\n  const routeFeatureStore: FeatureWithDirections = {\n    type: FEATURE,\n    geometry: geojsonGeom,\n    projection: routesFeatureStore.map.projectionCode,\n    properties: {\n      id: directions.id,\n      type: DirectionsType.Route,\n      active,\n      directions\n    },\n    meta: {\n      id: directions.id,\n      revision: previousRouteRevision + 1\n    },\n    ol: new olFeature({ linestringStore })\n  };\n  routesFeatureStore.update(routeFeatureStore);\n}\n\n/**\n * Formats the given distance in meters to a human-readable string.\n *\n * @param {number} meters - The distance in meters to be formatted.\n * @return {string | undefined} The formatted distance string.\n */\nexport function formatDistance(meters: number): string {\n  if (meters === 0) {\n    return undefined;\n  }\n\n  if (meters < 1000) {\n    return `${Math.round(meters)} m`;\n  }\n\n  const kilometers: number = meters / 1000;\n  const roundToDecimal: 0 | 1 = kilometers >= 10 ? 1 : 0;\n\n  return `${NumberUtils.roundToNDecimal(kilometers, roundToDecimal)} km`.replace(\n    '.',\n    ','\n  );\n}\n\n/**\n * Formats the given duration in seconds to a human-readable string.\n *\n * @param {number} seconds - The duration in seconds to be formatted.\n * @return {string} The formatted duration string.\n */\nexport function formatDuration(seconds: number): string {\n  const hours: number = Math.floor(seconds / 3600);\n  const minutes: number = Math.floor((seconds % 3600) / 60);\n\n  if (hours) {\n    return `${hours} h ${minutes} min`;\n  }\n\n  if (minutes) {\n    return `${minutes} min`;\n  }\n\n  return '< 1 min';\n}\n\nexport function formatStep(\n  step: IgoStep,\n  languageService: LanguageService,\n  lastStep = false\n) {\n  const maneuverType: ManeuverType = step.maneuver.type;\n  const maneuverModifier: ManeuverModifier = step.maneuver.modifier;\n  const name: string = step.name;\n  const maneuverBearingAfter: number = step.maneuver.bearing_after;\n\n  const translate: TranslateService = languageService.translate;\n  const translatedManeuverBearingAfter: string = translateManeuverBearing(\n    maneuverBearingAfter,\n    languageService\n  );\n  const translatedManeuverModifier: string = translateManeuverModifier(\n    maneuverModifier,\n    languageService\n  );\n\n  let iconName = 'straight'; // arrow point up by default\n  let instruction = '';\n\n  if (maneuverType === ManeuverType.Turn) {\n    if (\n      maneuverModifier === ManeuverModifier.Uturn ||\n      maneuverModifier === ManeuverModifier.Straight\n    ) {\n      instruction = translate.instant(\n        `igo.geo.directions.results.maneuverType.turn.${maneuverModifier}`,\n        {\n          maneuverModifier: translatedManeuverModifier,\n          name\n        }\n      );\n      if (maneuverModifier === ManeuverModifier.Uturn) {\n        iconName = 'u_turn_left';\n      }\n    } else {\n      instruction = translate.instant(\n        'igo.geo.directions.results.maneuverType.turn.else',\n        {\n          maneuverModifier: translatedManeuverModifier,\n          name\n        }\n      );\n\n      if (maneuverModifier === ManeuverModifier.SlightRight) {\n        iconName = 'turn_slight_right';\n      } else if (\n        maneuverModifier === ManeuverModifier.Right ||\n        maneuverModifier === ManeuverModifier.SharpRight\n      ) {\n        iconName = 'turn_right';\n      } else if (\n        maneuverModifier === ManeuverModifier.Left ||\n        maneuverModifier === ManeuverModifier.SharpLeft\n      ) {\n        iconName = 'turn_left';\n      } else if (maneuverModifier === ManeuverModifier.SlightLeft) {\n        iconName = 'turn_slight_left';\n      }\n    }\n  } else if (maneuverType === ManeuverType.NewName) {\n    instruction = translate.instant(\n      `igo.geo.directions.results.maneuverType.new name`,\n      {\n        name,\n        maneuverBearing: translatedManeuverBearingAfter\n      }\n    );\n  } else if (maneuverType === ManeuverType.Depart) {\n    iconName = 'directions';\n    instruction = translate.instant(\n      `igo.geo.directions.results.maneuverType.depart`,\n      {\n        name,\n        maneuverBearing: translatedManeuverBearingAfter\n      }\n    );\n  } else if (maneuverType === ManeuverType.Arrive) {\n    iconName = 'sports_score';\n    instruction = translate.instant(\n      `igo.geo.directions.results.maneuverType.arrive.${lastStep ? 'lastStep' : 'intermediate'}`,\n      {\n        name\n      }\n    );\n  } else if (maneuverType === ManeuverType.Merge) {\n    instruction = translate.instant(\n      'igo.geo.directions.results.maneuverType.merge',\n      {\n        name\n      }\n    );\n    iconName = 'merge';\n  } else if (\n    maneuverType === ManeuverType.OnRamp ||\n    maneuverType === ManeuverType.OffRamp\n  ) {\n    instruction = translate.instant(\n      `igo.geo.directions.results.maneuverType.${maneuverType}`,\n      {\n        maneuverModifier: translatedManeuverModifier\n      }\n    );\n  } else if (maneuverType === ManeuverType.Fork) {\n    const directionKey: string =\n      maneuverModifier.search('left') >= 0 ? 'left' : 'right';\n    iconName =\n      directionKey === 'left' ? 'turn_slight_left' : 'turn_slight_right';\n    instruction = translate.instant(\n      `igo.geo.directions.results.maneuverType.fork.${directionKey}`,\n      {\n        name\n      }\n    );\n  } else if (\n    maneuverType === ManeuverType.EndOfRoad ||\n    maneuverType === ManeuverType.UseLane ||\n    maneuverType === ManeuverType.Continue\n  ) {\n    if (maneuverType === ManeuverType.Continue) {\n      if (maneuverModifier === ManeuverModifier.Uturn) {\n        iconName = 'u_turn_left';\n        instruction = translate.instant(\n          `igo.geo.directions.results.maneuverType.turn.${maneuverModifier}`,\n          {\n            maneuverModifier: translatedManeuverModifier,\n            name\n          }\n        );\n      } else {\n        instruction = translate.instant(\n          `igo.geo.directions.results.maneuverType.${maneuverType}`,\n          {\n            maneuverModifier: translatedManeuverModifier,\n            name\n          }\n        );\n      }\n    } else {\n      if (\n        maneuverModifier === ManeuverModifier.SharpRight ||\n        maneuverModifier === ManeuverModifier.Right\n      ) {\n        iconName = 'turn_right';\n      } else if (\n        maneuverModifier === ManeuverModifier.SharpLeft ||\n        maneuverModifier === ManeuverModifier.Left\n      ) {\n        iconName = 'turn_left';\n      } else if (maneuverModifier === ManeuverModifier.SlightRight) {\n        iconName = 'turn_slight_right';\n      } else if (maneuverModifier === ManeuverModifier.SlightLeft) {\n        iconName = 'turn_slight_left';\n      }\n      instruction = translate.instant(\n        `igo.geo.directions.results.maneuverType.${maneuverType}`,\n        {\n          maneuverModifier: translatedManeuverModifier,\n          name\n        }\n      );\n    }\n  } else if (\n    maneuverType === ManeuverType.Roundabout ||\n    maneuverType === ManeuverType.Rotary ||\n    maneuverType === ManeuverType.RoundaboutTurn ||\n    maneuverType === ManeuverType.ExitRoundabout\n  ) {\n    const roundaboutKey = maneuverType.replace('roundabout ', '');\n    instruction = translate.instant(\n      `igo.geo.directions.results.maneuverType.${roundaboutKey}`,\n      {\n        name\n      }\n    );\n    iconName = 'donut_large';\n  } else if (maneuverType === ManeuverType.Notification) {\n    instruction = translate.instant(\n      'igo.geo.directions.results.maneuverType.notification'\n    );\n  }\n\n  return { instruction, iconName };\n}\n\n/**\n * Translates a maneuver modifier into a human-readable string using the provided language service.\n *\n * @param {ManeuverModifier} maneuverModifier - The maneuver modifier to be translated.\n * @param {LanguageService} languageService - The language service used for translation.\n * @return {string | undefined} The translated maneuver modifier string, or undefined if the modifier is falsy.\n */\nexport function translateManeuverModifier(\n  maneuverModifier: ManeuverModifier,\n  languageService: LanguageService\n): string {\n  const translate = languageService.translate;\n  return maneuverModifier\n    ? translate.instant(\n        `igo.geo.directions.results.maneuverModifier.${maneuverModifier}`\n      )\n    : undefined;\n}\n\n/**\n * Translates the given bearing value into a human-readable direction using the provided language service.\n *\n * @param {number} bearing - The bearing value to be translated.\n * @param {LanguageService} languageService - The language service used for translation.\n * @return {string} The translated direction corresponding to the given bearing value.\n */\nexport function translateManeuverBearing(\n  bearing: number,\n  languageService: LanguageService\n): string {\n  const translate: TranslateService = languageService.translate;\n  const directions: string[] = ['n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw'];\n\n  const directionIndex: number = Math.round(bearing / 45) % 8;\n\n  return translate.instant(\n    `igo.geo.directions.results.direction.${directions[directionIndex]}`\n  );\n}\n"]}

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

@@ -0,0 +1,6 @@
+export * from './directions.service';
+export * from './directions.enum';
+export * from './directions.interface';
+export * from './directions.utils';
+export * from './store';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kaXJlY3Rpb25zL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaXJlY3Rpb25zLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3Rpb25zLmVudW0nO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3Rpb25zLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGlvbnMudXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdG9yZSc7XG4iXX0=

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

@@ -0,0 +1,21 @@
+import { EntityStore } from '@igo2/common/entity';
+import { BehaviorSubject } from 'rxjs';
+import { FeatureStore } from '../../feature/shared/store';
+/**
+ * The class is a specialized version of an EntityStore that stores
+ * stops.
+ */
+export class StopsStore extends EntityStore {
+    storeInitialized$ = new BehaviorSubject(false);
+    clearStops() {
+        this.storeInitialized$.next(false);
+        this.clear();
+    }
+}
+export class StopsFeatureStore extends FeatureStore {
+}
+export class RoutesFeatureStore extends FeatureStore {
+}
+export class StepsFeatureStore extends FeatureStore {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kaXJlY3Rpb25zL3NoYXJlZC9zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFbEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUV2QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFRMUQ7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLFVBQVcsU0FBUSxXQUFpQjtJQUN4QyxpQkFBaUIsR0FBRyxJQUFJLGVBQWUsQ0FBVSxLQUFLLENBQUMsQ0FBQztJQUV4RCxVQUFVO1FBQ2YsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNuQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDZixDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8saUJBQWtCLFNBQVEsWUFBNkI7Q0FBRztBQUN2RSxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsWUFBbUM7Q0FBRztBQUM5RSxNQUFNLE9BQU8saUJBQWtCLFNBQVEsWUFBNkI7Q0FBRyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVudGl0eVN0b3JlIH0gZnJvbSAnQGlnbzIvY29tbW9uL2VudGl0eSc7XG5cbmltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgeyBGZWF0dXJlU3RvcmUgfSBmcm9tICcuLi8uLi9mZWF0dXJlL3NoYXJlZC9zdG9yZSc7XG5pbXBvcnQge1xuICBGZWF0dXJlV2l0aERpcmVjdGlvbnMsXG4gIEZlYXR1cmVXaXRoU3RlcCxcbiAgRmVhdHVyZVdpdGhTdG9wLFxuICBTdG9wXG59IGZyb20gJy4vZGlyZWN0aW9ucy5pbnRlcmZhY2UnO1xuXG4vKipcbiAqIFRoZSBjbGFzcyBpcyBhIHNwZWNpYWxpemVkIHZlcnNpb24gb2YgYW4gRW50aXR5U3RvcmUgdGhhdCBzdG9yZXNcbiAqIHN0b3BzLlxuICovXG5leHBvcnQgY2xhc3MgU3RvcHNTdG9yZSBleHRlbmRzIEVudGl0eVN0b3JlPFN0b3A+IHtcbiAgcHVibGljIHN0b3JlSW5pdGlhbGl6ZWQkID0gbmV3IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPihmYWxzZSk7XG5cbiAgcHVibGljIGNsZWFyU3RvcHMoKSB7XG4gICAgdGhpcy5zdG9yZUluaXRpYWxpemVkJC5uZXh0KGZhbHNlKTtcbiAgICB0aGlzLmNsZWFyKCk7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIFN0b3BzRmVhdHVyZVN0b3JlIGV4dGVuZHMgRmVhdHVyZVN0b3JlPEZlYXR1cmVXaXRoU3RvcD4ge31cbmV4cG9ydCBjbGFzcyBSb3V0ZXNGZWF0dXJlU3RvcmUgZXh0ZW5kcyBGZWF0dXJlU3RvcmU8RmVhdHVyZVdpdGhEaXJlY3Rpb25zPiB7fVxuZXhwb3J0IGNsYXNzIFN0ZXBzRmVhdHVyZVN0b3JlIGV4dGVuZHMgRmVhdHVyZVN0b3JlPEZlYXR1cmVXaXRoU3RlcD4ge31cbiJdfQ==