proximiio-js-library 1.12.78 → 1.12.80

package/lib/components/map/guidanceStepsGenerator.js

@@ -168,6 +168,9 @@ export default class GuidanceStepsGenerator {
         if (!nextPoint) {
             return Direction.Finish;
         }
+        if (currentPoint.isPoi && nextPoint.isPoi && currentPoint.id === nextPoint.id) {
+            return Direction.Finish;
+        }
         if (currentPoint.isLevelChanger && nextPoint.properties.level > currentPoint.properties.level) {
             return `${Direction.Up}_${LevelChangerTypes[currentPoint.properties.type]}`;
         }

package/lib/components/map/main.d.ts

@@ -212,6 +212,7 @@ export declare class Map {
     private onPoiClickListener;
     private onPersonUpdateListener;
     private onStepSetListener;
+    private onStopSetListener;
     private defaultOptions;
     private routeFactory;
     private startPoint?;
@@ -227,6 +228,7 @@ export declare class Map {
     private hoveredPolygon;
     private selectedPolygons;
     private currentStep;
+    private currentStop;
     private kioskPopup;
     private mainSourceLoaded;
     private pmTilesInstance;
@@ -537,11 +539,11 @@ export declare class Map {
      */
     findRouteToNearestFeature(amenityId: string, idFrom?: string, accessibleRoute?: boolean, wayfindingConfig?: WayfindingConfigModel, addToMap?: boolean): void;
     /**
-     * This method will generate route based on selected features by their ids
+     * This method will generate city route
      *  @memberof Map
      *  @name findCityRoute
-     *  @param start {string} finish feature id
-     *  @param destination {string} start feature id, optional for kiosk
+     *  @param start {lat: number, lng: number} start coordinates
+     *  @param destination {lat: number, lng: number} destination coordinates
      *  @param autoStart {boolean} default true, if set to false route will not start automatically
      *  @example
      *  const map = new Proximiio.Map();
@@ -570,6 +572,30 @@ export declare class Map {
         };
         autoStart?: boolean;
     }): void;
+    /**
+     * This method will generate route based on selected features by their ids
+     *  @memberof Map
+     *  @name findMultipointRoute
+     *  @param start {string} start feature id
+     *  @param stops [{string}] array of destination feature ids
+     *  @param wayfindingConfig {WayfindingConfigModel} wayfinding configuration, optional
+     *  @param autoStart {boolean} default true, if set to false route will not be added to map
+     *  @example
+     *  const map = new Proximiio.Map();
+     *  map.getMapReadyListener().subscribe(ready => {
+     *    console.log('map ready', ready);
+     *    map.findMultipointRoute({
+     *      start: 'startId',
+     *      stops: ['stop1Id', 'stop2Id']
+     *    });
+     *  });
+     */
+    findMultipointRoute({ start, stops, wayfindingConfig, autoStart, }: {
+        start: string;
+        stops: string[];
+        wayfindingConfig?: WayfindingConfigModel;
+        autoStart?: boolean;
+    }): void;
     /**
      * This method will cancel generated route
      *  @memberof Map
@@ -607,6 +633,31 @@ export declare class Map {
      *  });
      */
     getNavStepSetListener(): CustomSubject<number>;
+    /**
+     * This method will set the current stop for multipoint route navigation so map can focus on a proper path part
+     *  @memberof Map
+     *  @name setStop
+     *  @param stop { number | 'next' | 'previous' } Number of route part to focus on or string next or previous
+     *  @returns active stop
+     *  @example
+     *  const map = new Proximiio.Map();
+     *  map.getMapReadyListener().subscribe(ready => {
+     *    console.log('map ready', ready);
+     *    map.setStop(0);
+     *  });
+     */
+    setStop(stop: number | 'next' | 'previous'): number;
+    /**
+     *  @memberof Map
+     *  @name getStopSetListener
+     *  @returns returns stop set listener
+     *  @example
+     *  const map = new Proximiio.Map();
+     *  map.getStopSetListener().subscribe(stop => {
+     *    console.log('new stop has been set', stop);
+     *  });
+     */
+    getStopSetListener(): CustomSubject<number>;
     /**
      * This method will return turn by turn text navigation object.
      *  @memberof Map

package/lib/components/map/main.js

@@ -87,6 +87,7 @@ export class Map {
         this.onPoiClickListener = new CustomSubject();
         this.onPersonUpdateListener = new CustomSubject();
         this.onStepSetListener = new CustomSubject();
+        this.onStopSetListener = new CustomSubject();
         this.defaultOptions = {
             selector: 'proximiioMap',
             allowNewFeatureModal: false,
@@ -228,6 +229,7 @@ export class Map {
         this.amenityCategories = {};
         this.selectedPolygons = [];
         this.currentStep = 0;
+        this.currentStop = 0;
         this.mainSourceLoaded = false;
         this.pointIconMarker = {};
         this.routeStartMarker = {};
@@ -1648,7 +1650,10 @@ export class Map {
             this.centerToFeature(destinationFeature.id);
         }
         if (startFeature && destinationFeature) {
-            this.onRouteUpdate(startFeature, destinationFeature);
+            this.onRouteUpdate({
+                start: startFeature,
+                finish: destinationFeature,
+            });
         }
     }
     featureDialog(e) {
@@ -2203,6 +2208,8 @@ export class Map {
         this.map.getSource('main').setData(mainSourceData);
     }
     onSetHiddenAmenities(amenities) {
+        this.defaultOptions.hiddenAmenities = [...this.defaultOptions.hiddenAmenities, ...amenities];
+        this.defaultOptions.hiddenAmenities = [...new Set(this.defaultOptions.hiddenAmenities)];
         // @ts-ignore
         const mainSourceData = this.map.getSource('main')._data;
         mainSourceData.features = mainSourceData.features.map((f) => {
@@ -2673,12 +2680,12 @@ export class Map {
         this.updateCluster();
         this.onFloorSelectListener.next(floor);
     }
-    onRouteUpdate(start, finish) {
+    onRouteUpdate({ start, finish, stops }) {
         this.startPoint = start;
-        this.endPoint = finish;
+        this.endPoint = stops ? stops[stops.length - 1] : finish;
         try {
-            if (finish && this.defaultOptions.initPolygons) {
-                this.handlePolygonSelection(finish);
+            if (this.defaultOptions.initPolygons) {
+                this.handlePolygonSelection([...stops, finish, start]);
             }
             if (finish && this.defaultOptions.animatedRoute) {
                 if (this.defaultOptions.animatedRoute) {
@@ -2686,17 +2693,20 @@ export class Map {
                 }
                 cancelAnimationFrame(this.animationFrame);
             }
-            this.routingSource.update({ start, finish, language: this.defaultOptions.language });
+            this.routingSource.update({ start, finish, stops, language: this.defaultOptions.language });
         }
         catch (e) {
             console.log('catched', e);
         }
         this.state = Object.assign(Object.assign({}, this.state), { style: this.state.style });
     }
-    onRoutePreview(start, finish) {
+    onRoutePreview({ start, finish, stops }) {
         this.startPoint = start;
-        this.endPoint = finish;
-        this.routingSource.update({ start, finish, preview: true, language: this.defaultOptions.language });
+        this.endPoint = stops ? stops[stops.length - 1] : finish;
+        if (this.defaultOptions.initPolygons) {
+            this.handlePolygonSelection([...stops, finish, start]);
+        }
+        this.routingSource.update({ start, finish, stops, preview: true, language: this.defaultOptions.language });
     }
     onRouteCancel() {
         this.state = Object.assign(Object.assign({}, this.state), { textNavigation: null });
@@ -3390,10 +3400,16 @@ export class Map {
             this.routingSource.setConfig(wayfindingConfig);
         }
         if (addToMap !== false) {
-            this.onRouteUpdate(fromFeature, toFeature);
+            this.onRouteUpdate({
+                start: fromFeature,
+                finish: toFeature,
+            });
         }
         else {
-            this.onRoutePreview(fromFeature, toFeature);
+            this.onRoutePreview({
+                start: fromFeature,
+                finish: toFeature,
+            });
         }
     }
     /**
@@ -3422,10 +3438,16 @@ export class Map {
             this.routingSource.setConfig(wayfindingConfig);
         }
         if (addToMap !== false) {
-            this.onRouteUpdate(fromFeature, toFeature);
+            this.onRouteUpdate({
+                start: fromFeature,
+                finish: toFeature,
+            });
         }
         else {
-            this.onRoutePreview(fromFeature, toFeature);
+            this.onRoutePreview({
+                start: fromFeature,
+                finish: toFeature,
+            });
         }
     }
     /**
@@ -3458,10 +3480,16 @@ export class Map {
             this.routingSource.setConfig(wayfindingConfig);
         }
         if (addToMap !== false) {
-            this.onRouteUpdate(fromFeature, toFeature);
+            this.onRouteUpdate({
+                start: fromFeature,
+                finish: toFeature,
+            });
         }
         else {
-            this.onRoutePreview(fromFeature, toFeature);
+            this.onRoutePreview({
+                start: fromFeature,
+                finish: toFeature,
+            });
         }
     }
     /**
@@ -3491,10 +3519,16 @@ export class Map {
                 this.routingSource.setConfig(wayfindingConfig);
             }
             if (addToMap !== false) {
-                this.onRouteUpdate(fromFeature, toFeature);
+                this.onRouteUpdate({
+                    start: fromFeature,
+                    finish: toFeature,
+                });
             }
             else {
-                this.onRoutePreview(fromFeature, toFeature);
+                this.onRoutePreview({
+                    start: fromFeature,
+                    finish: toFeature,
+                });
             }
         }
         else {
@@ -3502,11 +3536,11 @@ export class Map {
         }
     }
     /**
-     * This method will generate route based on selected features by their ids
+     * This method will generate city route
      *  @memberof Map
      *  @name findCityRoute
-     *  @param start {string} finish feature id
-     *  @param destination {string} start feature id, optional for kiosk
+     *  @param start {lat: number, lng: number} start coordinates
+     *  @param destination {lat: number, lng: number} destination coordinates
      *  @param autoStart {boolean} default true, if set to false route will not start automatically
      *  @example
      *  const map = new Proximiio.Map();
@@ -3529,10 +3563,57 @@ export class Map {
         const destinationFeature = feature({ type: 'Point', coordinates: [destination.lng, destination.lat] }, { level: 0 });
         this.routingSource.setNavigationType('city');
         if (autoStart !== false) {
-            this.onRouteUpdate(startFeature, destinationFeature);
+            this.onRouteUpdate({
+                start: startFeature,
+                finish: destinationFeature,
+            });
         }
         else {
-            this.onRoutePreview(startFeature, destinationFeature);
+            this.onRoutePreview({
+                start: startFeature,
+                finish: destinationFeature,
+            });
+        }
+    }
+    /**
+     * This method will generate route based on selected features by their ids
+     *  @memberof Map
+     *  @name findMultipointRoute
+     *  @param start {string} start feature id
+     *  @param stops [{string}] array of destination feature ids
+     *  @param wayfindingConfig {WayfindingConfigModel} wayfinding configuration, optional
+     *  @param autoStart {boolean} default true, if set to false route will not be added to map
+     *  @example
+     *  const map = new Proximiio.Map();
+     *  map.getMapReadyListener().subscribe(ready => {
+     *    console.log('map ready', ready);
+     *    map.findMultipointRoute({
+     *      start: 'startId',
+     *      stops: ['stop1Id', 'stop2Id']
+     *    });
+     *  });
+     */
+    findMultipointRoute({ start, stops, wayfindingConfig, autoStart = true, }) {
+        const fromFeature = start
+            ? this.state.allFeatures.features.find((f) => f.id === start || f.properties.id === start)
+            : this.startPoint;
+        const destinationFeatures = stops.map((id) => {
+            return this.state.allFeatures.features.find((f) => f.id === id || f.properties.id === id);
+        });
+        if (wayfindingConfig) {
+            this.routingSource.setConfig(wayfindingConfig);
+        }
+        if (autoStart !== false) {
+            this.onRouteUpdate({
+                start: fromFeature,
+                stops: destinationFeatures,
+            });
+        }
+        else {
+            this.onRoutePreview({
+                start: fromFeature,
+                stops: destinationFeatures,
+            });
         }
     }
     /**
@@ -3563,6 +3644,7 @@ export class Map {
      *  });
      */
     setNavStep(step) {
+        var _a, _b, _c;
         let newStep = 0;
         if (isNumber(step)) {
             newStep = +step;
@@ -3587,9 +3669,16 @@ export class Map {
                 this.animateRoute();
             }
             else {
+                if (this.routingSource.isMultipoint) {
+                    this.animateRoute();
+                }
                 this.centerOnRoute(this.routingSource.route[`path-part-${newStep}`]);
             }
             this.onStepSetListener.next(this.currentStep);
+            if (isNumber((_a = this.routingSource.route[`path-part-${newStep}`].properties) === null || _a === void 0 ? void 0 : _a.stop) &&
+                ((_b = this.routingSource.route[`path-part-${newStep}`].properties) === null || _b === void 0 ? void 0 : _b.stop) >= 0) {
+                this.setStop((_c = this.routingSource.route[`path-part-${newStep}`].properties) === null || _c === void 0 ? void 0 : _c.stop);
+            }
             return step;
         }
         else {
@@ -3609,6 +3698,63 @@ export class Map {
     getNavStepSetListener() {
         return this.onStepSetListener;
     }
+    /**
+     * This method will set the current stop for multipoint route navigation so map can focus on a proper path part
+     *  @memberof Map
+     *  @name setStop
+     *  @param stop { number | 'next' | 'previous' } Number of route part to focus on or string next or previous
+     *  @returns active stop
+     *  @example
+     *  const map = new Proximiio.Map();
+     *  map.getMapReadyListener().subscribe(ready => {
+     *    console.log('map ready', ready);
+     *    map.setStop(0);
+     *  });
+     */
+    setStop(stop) {
+        var _a, _b;
+        let newStop = 0;
+        if (isNumber(stop)) {
+            newStop = +stop;
+        }
+        if (stop === 'next') {
+            newStop = this.currentStop + 1;
+        }
+        if (stop === 'next' && this.routingSource.stops && this.routingSource.stops.length - 1 === this.currentStop) {
+            newStop = 0;
+        }
+        if (stop === 'previous' && this.currentStop > 0) {
+            newStop = this.currentStop - 1;
+        }
+        if (newStop === this.currentStop) {
+            return;
+        }
+        const newStopRoute = (_b = (_a = this.routingSource) === null || _a === void 0 ? void 0 : _a.lines) === null || _b === void 0 ? void 0 : _b.find((i) => i.properties.stop === newStop);
+        if (newStopRoute) {
+            this.currentStop = newStop;
+            this.animateRoute();
+            this.centerOnRoute(newStopRoute);
+            this.onStopSetListener.next(this.currentStop);
+            this.setNavStep(newStopRoute.properties.step);
+            return this.currentStop;
+        }
+        else {
+            console.error(`Route not found`);
+        }
+    }
+    /**
+     *  @memberof Map
+     *  @name getStopSetListener
+     *  @returns returns stop set listener
+     *  @example
+     *  const map = new Proximiio.Map();
+     *  map.getStopSetListener().subscribe(stop => {
+     *    console.log('new stop has been set', stop);
+     *  });
+     */
+    getStopSetListener() {
+        return this.onStopSetListener;
+    }
     /**
      * This method will return turn by turn text navigation object.
      *  @memberof Map

package/lib/components/map/routing.d.ts

@@ -9,7 +9,11 @@ export default class Routing {
     setData(collection: FeatureCollection): void;
     toggleOnlyAccessible(onlyAccessible: any): void;
     setConfig(config: WayfindingConfigModel): void;
-    route(start: Feature, finish: Feature): {
+    route({ start, finish, stops }: {
+        start: Feature;
+        finish?: Feature;
+        stops?: Feature[];
+    }): {
         paths: any;
         points: any;
         route: {};

package/lib/components/map/routing.js

@@ -60,19 +60,50 @@ export default class Routing {
     setConfig(config) {
         this.wayfinding.setConfiguration(config);
     }
-    route(start, finish) {
+    route({ start, finish, stops }) {
+        const isMultipoint = stops && stops.length > 1;
         let points = null;
         let details = null;
-        if (this.routeWithDetails) {
-            const res = this.wayfinding.runAStarWithDetails(start, finish);
-            points = res.path;
-            details = {
-                distance: res.distance,
-                duration: res.duration,
-            };
+        if (isMultipoint) {
+            for (const [index, stop] of stops.entries()) {
+                const isFirstStop = index === 0;
+                if (this.routeWithDetails) {
+                    const res = this.wayfinding.runAStarWithDetails(isFirstStop ? start : stops[index - 1], stop);
+                    points = points ? points.concat(res.path) : res.path;
+                    if (!details) {
+                        details = {
+                            distance: res.distance,
+                            duration: res.duration,
+                        };
+                    }
+                    else {
+                        details.distance += res.distance;
+                        details.duration.elevator += res.duration.elevator;
+                        details.duration.escalator += res.duration.escalator;
+                        details.duration.staircase += res.duration.staircase;
+                        details.duration.realistic += res.duration.realistic;
+                        details.duration.shortest += res.duration.shortest;
+                    }
+                }
+                else {
+                    points = points
+                        ? points.concat(this.wayfinding.runAStar(start, stop))
+                        : this.wayfinding.runAStar(isFirstStop ? start : stops[index - 1], stop);
+                }
+            }
         }
         else {
-            points = this.wayfinding.runAStar(start, finish);
+            if (this.routeWithDetails) {
+                const res = this.wayfinding.runAStarWithDetails(start, finish);
+                points = res.path;
+                details = {
+                    distance: res.distance,
+                    duration: res.duration,
+                };
+            }
+            else {
+                points = this.wayfinding.runAStar(start, finish);
+            }
         }
         if (!points) {
             return null;
@@ -83,6 +114,7 @@ export default class Routing {
         const pathPoints = {};
         let pathPartIndex = 0;
         points.forEach((p, index) => {
+            var _a;
             if (this.forceFloorLevel !== null && this.forceFloorLevel !== undefined) {
                 if (typeof pathPoints['path-part-'.concat(pathPartIndex)] === 'undefined') {
                     pathPoints['path-part-'.concat(pathPartIndex)] = [];
@@ -100,9 +132,13 @@ export default class Routing {
                 if (p.isLevelChanger && p.properties.level !== points[index + 1].properties.level) {
                     pathPartIndex++;
                 }
+                else if (p.isPoi && p.id === ((_a = points[index + 1]) === null || _a === void 0 ? void 0 : _a.id)) {
+                    pathPartIndex++;
+                }
             }
         });
         const paths = {};
+        let stopIndex = 0;
         for (const [key, pointsList] of Object.entries(pathPoints)) {
             if (this.forceFloorLevel !== null && this.forceFloorLevel !== undefined) {
                 // @ts-ignore
@@ -126,12 +162,20 @@ export default class Routing {
                     paths[key] = new Feature(point(pointsList[0].geometry.coordinates));
                 }
             }
+            if (isMultipoint &&
+                pointsList[0].isPoi &&
+                pointsList[0].id &&
+                stops.findIndex((i) => i.id === pointsList[0].id) !== -1) {
+                stopIndex++;
+            }
             paths[key].id = key;
             // @ts-ignore
             paths[key].properties = {
                 // @ts-ignore
                 level: pointsList[pointsList.length - 1].properties.level,
                 amenity: 'chevron_right',
+                step: +key.split('-')[2],
+                stop: stopIndex,
             };
         }
         const levelPaths = {};

package/lib/components/map/sources/routing_source.d.ts

@@ -10,6 +10,7 @@ export default class RoutingSource extends DataSource {
     isEditable: boolean;
     start?: Feature;
     finish?: Feature;
+    stops?: Feature[];
     lines?: Feature[];
     changes: ChangeContainer[];
     route: any;
@@ -32,13 +33,15 @@ export default class RoutingSource extends DataSource {
     language: string;
     navigationType: 'mall' | 'city';
     fullPath?: Feature;
+    isMultipoint: boolean;
     constructor();
     toggleAccessible(value: any): void;
     setConfig(config: WayfindingConfigModel): void;
     setNavigationType(type: 'mall' | 'city'): void;
-    update({ start, finish, preview, language, }: {
+    update({ start, finish, stops, preview, language, }: {
         start?: Feature;
         finish?: Feature;
+        stops?: Feature[];
         preview?: boolean;
         language: string;
     }): Promise<void>;

package/lib/components/map/sources/routing_source.js

@@ -15,6 +15,7 @@ export default class RoutingSource extends DataSource {
     constructor() {
         super('route');
         this.isEditable = false;
+        this.isMultipoint = false;
         this.changes = [];
         this.routing = new Routing();
         this.navigationType = 'mall';
@@ -28,10 +29,13 @@ export default class RoutingSource extends DataSource {
     setNavigationType(type) {
         this.navigationType = type;
     }
-    update({ start, finish, preview, language, }) {
+    update({ start, finish, stops, preview, language, }) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.isMultipoint = stops && stops.length > 1;
+            finish = this.isMultipoint ? stops[stops.length - 1] : finish;
             this.start = start;
             this.finish = finish;
+            this.stops = stops;
             this.preview = preview;
             this.language = language;
             this.data = new FeatureCollection({
@@ -42,7 +46,7 @@ export default class RoutingSource extends DataSource {
                 this.notify('loading-start');
                 const route = this.navigationType === 'city'
                     ? yield this.routing.cityRoute({ start, finish, language: this.language })
-                    : this.routing.route(start, finish);
+                    : this.routing.route({ start, finish, stops });
                 // @ts-ignore
                 const paths = route === null || route === void 0 ? void 0 : route.paths;
                 // @ts-ignore

package/lib/models/feature.d.ts

@@ -35,6 +35,7 @@ export default class Feature extends BaseModel {
     get isStairCase(): boolean;
     get isRamp(): boolean;
     get isLevelChanger(): boolean;
+    get isPoi(): boolean;
     get isText(): boolean;
     get isSynthetic(): boolean;
     get isRoom(): any;

package/lib/models/feature.js

@@ -91,6 +91,9 @@ export default class Feature extends BaseModel {
     get isLevelChanger() {
         return this.isElevator || this.isEscalator || this.isStairCase || this.isRamp;
     }
+    get isPoi() {
+        return this.properties.type === POI_TYPE.POI;
+    }
     get isText() {
         return this.properties.type === 'text';
     }