proximiio-js-library 1.7.0 → 1.8.1

package/README.md

@@ -125,15 +125,27 @@ const map = new Proximiio.Map({
     animatedRoute: false // optional, default: false, EXPERIMENTAL, if enabled animated dot will be displayed along the route,
     useRasterTiles: false, // optional, default: false, this will add raster tile source and layer with defined options from rasterTilesOptions
     rasterTilesOptions: {
-        tilesUrl: string[], mandatory
-        tileSize: number, optional, default: 256,
-        minZoom: number, optional, default: 15,
-        maxZoom: number, optional, default: 22,
-        beforeLayer: string, optional, default: 'proximiio-shop',
-        attribution: string, optional
+        tilesUrl: string[], // mandatory
+        tileSize: number, // optional, default: 256,
+        minZoom: number, // optional, default: 15,
+        maxZoom: number, // optional, default: 22,
+        beforeLayer: string, // optional, default: 'proximiio-shop',
+        attribution: string, // optional
     },
+    handleUrlParams: false, // optional, default: false, if enabled you can define place, start and destination features for routing in url params and library will handle those, you can change param names via urlParams option listed below
+    urlParams: {
+      startFeature: string, // optional, default: 'startFeature', library will search for the start feature by it's id or title defined within provided param
+      destinationFeature: string, // optional, default: 'destinationFeature', library will search for the destination feature by it's id or title defined within provided param
+      defaultPlace: string, // optional, default: 'defaultPlace', library will search for the place by it's id or title defined within provided param
+    }
+    useGpsLocation: false, // optional, default: false, if enabled your location will be detected with geolocation API and used as a starting point for routing
 });
 ```
+#### Initiating with url params
+Library can handle some params from url in case you will enable `handleUrlParams` in map constructor. There's nothing else special required, just provide them in browser url like this as default:
+
+`http://your-server/?startFeature=featureIdOrTitle&destinationFeature=featureIdOrTitle&defaultPlace=placeIdOrTitle`
+
 #### Required Data for 3D Polygons
 As first there must be a MultiPolygon feature created which will be a polygon itself, it's also nice to have a label-line property in properties set. Label-line is just imaginary line alongside which poi title will be drawn. At last, you have to connect poi to polygon via adding its id to poi metadata like polygon_id property.
 

package/assets/wayfinding.js

@@ -466,38 +466,42 @@ export class Wayfinding {
             }
 
             levelChanger.properties.fixedPointMap = new Map();
-            levelChanger.properties.levels.forEach(level => {
-                let point = this._copyPoint(levelChanger);
-                point.properties.level = level;
-                let fixedPoint = this._getFixPointInArea(point);
-                fixedPoint.id = levelChanger.id;
-                fixedPoint.properties.amenity = levelChanger.properties.amenity;
-                fixedPoint.properties.direction = levelChanger.properties.direction;
-                fixedPoint.properties.id = levelChanger.properties.id;
-                fixedPoint.properties.level = level;
-                fixedPoint.properties.type = levelChanger.properties.type;
-                if (fixedPoint.properties.neighbours === undefined) fixedPoint.properties.neighbours = [];
-
-                // Do not fix level changers that are further than 5 meters from any path or area
-                if (this._distance(point, fixedPoint) > 5) {
-                    return;
-                }
-
-                // Store fixed point into the level changer
-                levelChanger.properties.fixedPointMap.set(level, fixedPoint);
-
-                // Add neighbourhood for corridor
-                if (fixedPoint.properties.onCorridor) {
-                    // fixedPoint.properties.neighbours = [...this.corridorLinePointPairs[fixedPoint.properties.corridorIndex], ...segmentIntersectionPointMap.get(fixedPoint.properties.corridorIndex)];
-                    if (fixedPoint.properties.neighboursLeadingTo !== undefined) {
-                        fixedPoint.properties.neighboursLeadingTo.forEach(neighbour => {
-                            if (neighbour.properties.neighbours === undefined) neighbour.properties.neighbours = [];
-                            neighbour.properties.neighbours.push(fixedPoint);
-                        });
-                        this.corridorLineFeatures[fixedPoint.properties.corridorIndex].properties.intersectionPointList.push(fixedPoint);
+            if (levelChanger.properties.levels) {
+                levelChanger.properties.levels.forEach(level => {
+                    let point = this._copyPoint(levelChanger);
+                    point.properties.level = level;
+                    let fixedPoint = this._getFixPointInArea(point);
+                    if (fixedPoint) {
+                        fixedPoint.id = levelChanger.id;
+                        fixedPoint.properties.amenity = levelChanger.properties.amenity;
+                        fixedPoint.properties.direction = levelChanger.properties.direction;
+                        fixedPoint.properties.id = levelChanger.properties.id;
+                        fixedPoint.properties.level = level;
+                        fixedPoint.properties.type = levelChanger.properties.type;
+                        if (fixedPoint.properties.neighbours === undefined) fixedPoint.properties.neighbours = [];
+    
+                        // Do not fix level changers that are further than 5 meters from any path or area
+                        if (this._distance(point, fixedPoint) > 5) {
+                            return;
+                        }
+    
+                        // Store fixed point into the level changer
+                        levelChanger.properties.fixedPointMap.set(level, fixedPoint);
+    
+                        // Add neighbourhood for corridor
+                        if (fixedPoint.properties.onCorridor) {
+                            // fixedPoint.properties.neighbours = [...this.corridorLinePointPairs[fixedPoint.properties.corridorIndex], ...segmentIntersectionPointMap.get(fixedPoint.properties.corridorIndex)];
+                            if (fixedPoint.properties.neighboursLeadingTo !== undefined) {
+                                fixedPoint.properties.neighboursLeadingTo.forEach(neighbour => {
+                                    if (neighbour.properties.neighbours === undefined) neighbour.properties.neighbours = [];
+                                    neighbour.properties.neighbours.push(fixedPoint);
+                                });
+                                this.corridorLineFeatures[fixedPoint.properties.corridorIndex].properties.intersectionPointList.push(fixedPoint);
+                            }
+                        }
                     }
-                }
-            });
+                });
+            }
         });
 
         levelChangerGroupMap.forEach( (lcList, groupId) => {
@@ -1447,100 +1451,101 @@ export class Wayfinding {
 
     _getFixPointInArea(point) {
         let floorData = this.floorData.get(point.properties.level);
-
-        // If point is located without accessible area, do nothing
-        let areaList  = floorData.areas;
-        for (let index in areaList) {
-            let polygon = areaList[index];
-            if (turf.booleanContains(polygon, point)) {
-                return point;
+        if (floorData) {
+            // If point is located without accessible area, do nothing
+            let areaList  = floorData.areas;
+            for (let index in areaList) {
+                let polygon = areaList[index];
+                if (turf.booleanContains(polygon, point)) {
+                    return point;
+                }
             }
-        }
 
-        // Find nearest wall to stick to
-        let bestWall = null;
-        let bestWallDistance = Infinity;
-        floorData.wallFeatures.forEach(wall => {
-            let distance = turf.pointToLineDistance(point.geometry.coordinates, wall, {units: 'meters'});
-            if (distance < bestWallDistance) {
-                bestWall = wall;
-                bestWallDistance = distance;
-            }
-        });
+            // Find nearest wall to stick to
+            let bestWall = null;
+            let bestWallDistance = Infinity;
+            floorData.wallFeatures.forEach(wall => {
+                let distance = turf.pointToLineDistance(point.geometry.coordinates, wall, {units: 'meters'});
+                if (distance < bestWallDistance) {
+                    bestWall = wall;
+                    bestWallDistance = distance;
+                }
+            });
 
-        let levelCorridorFeatures = this.corridorLineFeatures.filter(corridorLine => corridorLine.properties.level === point.properties.level);
-        let bestCorridorIndex = null;
-        let bestCorridorDistance = Infinity;
-        levelCorridorFeatures.forEach(corridor => {
-            let corridorIndex = this.corridorLineFeatures.indexOf(corridor);
-            let corridorDistance = turf.pointToLineDistance(point.geometry.coordinates, corridor, {units: 'meters'});
-            if (corridorDistance < bestCorridorDistance) {
-                bestCorridorIndex = corridorIndex;
-                bestCorridorDistance = corridorDistance;
-            }
-        });
+            let levelCorridorFeatures = this.corridorLineFeatures.filter(corridorLine => corridorLine.properties.level === point.properties.level);
+            let bestCorridorIndex = null;
+            let bestCorridorDistance = Infinity;
+            levelCorridorFeatures.forEach(corridor => {
+                let corridorIndex = this.corridorLineFeatures.indexOf(corridor);
+                let corridorDistance = turf.pointToLineDistance(point.geometry.coordinates, corridor, {units: 'meters'});
+                if (corridorDistance < bestCorridorDistance) {
+                    bestCorridorIndex = corridorIndex;
+                    bestCorridorDistance = corridorDistance;
+                }
+            });
 
-        // Test if area or corridor is closer, create appropriate fixed point
-        if (bestWall === null && bestCorridorIndex === null) {
-            // could not find neither close area or corridor
-            return point;
-        } else {
-            let fixedPoint;
+            // Test if area or corridor is closer, create appropriate fixed point
+            if (bestWall === null && bestCorridorIndex === null) {
+                // could not find neither close area or corridor
+                return point;
+            } else {
+                let fixedPoint;
 
-            // Corridor is closer
-            if (bestCorridorIndex !== undefined && bestCorridorDistance < bestWallDistance) {
+                // Corridor is closer
+                if (bestCorridorIndex !== undefined && bestCorridorDistance < bestWallDistance) {
 
-                // Create fixed point on line itself
-                let line = this.corridorLineFeatures[bestCorridorIndex];
-                fixedPoint = turf.nearestPointOnLine(line, point);
+                    // Create fixed point on line itself
+                    let line = this.corridorLineFeatures[bestCorridorIndex];
+                    fixedPoint = turf.nearestPointOnLine(line, point);
 
-                // Mark this fixed point is on corridor, preset neighbours
-                fixedPoint.properties.onCorridor = true;
-                fixedPoint.properties.corridorIndex = bestCorridorIndex;
-                if (!fixedPoint.properties.neighbours) {
-                    fixedPoint.properties.neighbours = [];
-                }
-                if (this.corridorLineFeatures[bestCorridorIndex].properties.bidirectional != false) {
-                    fixedPoint.properties.neighbours.push(this.corridorLinePointPairs[bestCorridorIndex][0], this.corridorLinePointPairs[bestCorridorIndex][1]);
-                    fixedPoint.properties.neighbours.push(...line.properties.intersectionPointList);
-                    fixedPoint.properties.neighboursLeadingTo = [
-                        this.corridorLinePointPairs[bestCorridorIndex][0],
-                        this.corridorLinePointPairs[bestCorridorIndex][1],
-                        ...line.properties.intersectionPointList
-                    ];
-                } else if (this.corridorLineFeatures[bestCorridorIndex].properties.swapDirection != true) {
-                    fixedPoint.properties.neighbours.push(this.corridorLinePointPairs[bestCorridorIndex][0]);
-                    // include only intersection points after this point
-                    let distance = this._distance(fixedPoint, this.corridorLinePointPairs[bestCorridorIndex][0]);
-                    let pointsBefore = line.properties.intersectionPointList.filter(point => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) < distance);
-                    let pointsAfter = line.properties.intersectionPointList.filter(point => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) >= distance);
-                    fixedPoint.properties.neighbours.push(...pointsAfter);
-                    fixedPoint.properties.neighboursLeadingTo = pointsBefore;
-                } else {
-                    fixedPoint.properties.neighbours.push(this.corridorLinePointPairs[bestCorridorIndex][1]);
-                    // include only intersection points before this point
-                    let distance = this._distance(fixedPoint, this.corridorLinePointPairs[bestCorridorIndex][0]);
-                    let pointsBefore = line.properties.intersectionPointList.filter(point => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) <= distance);
-                    let pointsAfter = line.properties.intersectionPointList.filter(point => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) > distance);
-                    fixedPoint.properties.neighbours.push(...pointsBefore);
-                    fixedPoint.properties.neighboursLeadingTo = pointsAfter;
-                }
+                    // Mark this fixed point is on corridor, preset neighbours
+                    fixedPoint.properties.onCorridor = true;
+                    fixedPoint.properties.corridorIndex = bestCorridorIndex;
+                    if (!fixedPoint.properties.neighbours) {
+                        fixedPoint.properties.neighbours = [];
+                    }
+                    if (this.corridorLineFeatures[bestCorridorIndex].properties.bidirectional != false) {
+                        fixedPoint.properties.neighbours.push(this.corridorLinePointPairs[bestCorridorIndex][0], this.corridorLinePointPairs[bestCorridorIndex][1]);
+                        fixedPoint.properties.neighbours.push(...line.properties.intersectionPointList);
+                        fixedPoint.properties.neighboursLeadingTo = [
+                            this.corridorLinePointPairs[bestCorridorIndex][0],
+                            this.corridorLinePointPairs[bestCorridorIndex][1],
+                            ...line.properties.intersectionPointList
+                        ];
+                    } else if (this.corridorLineFeatures[bestCorridorIndex].properties.swapDirection != true) {
+                        fixedPoint.properties.neighbours.push(this.corridorLinePointPairs[bestCorridorIndex][0]);
+                        // include only intersection points after this point
+                        let distance = this._distance(fixedPoint, this.corridorLinePointPairs[bestCorridorIndex][0]);
+                        let pointsBefore = line.properties.intersectionPointList.filter(point => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) < distance);
+                        let pointsAfter = line.properties.intersectionPointList.filter(point => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) >= distance);
+                        fixedPoint.properties.neighbours.push(...pointsAfter);
+                        fixedPoint.properties.neighboursLeadingTo = pointsBefore;
+                    } else {
+                        fixedPoint.properties.neighbours.push(this.corridorLinePointPairs[bestCorridorIndex][1]);
+                        // include only intersection points before this point
+                        let distance = this._distance(fixedPoint, this.corridorLinePointPairs[bestCorridorIndex][0]);
+                        let pointsBefore = line.properties.intersectionPointList.filter(point => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) <= distance);
+                        let pointsAfter = line.properties.intersectionPointList.filter(point => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) > distance);
+                        fixedPoint.properties.neighbours.push(...pointsBefore);
+                        fixedPoint.properties.neighboursLeadingTo = pointsAfter;
+                    }
 
-                // Wall is closer
-            } else if (bestWall !== null) {
+                    // Wall is closer
+                } else if (bestWall !== null) {
 
-                // Create fixed point inside area
-                let nearestPoint = turf.nearestPointOnLine(bestWall, point);
-                let bearing = turf.bearing(point, nearestPoint);
-                fixedPoint =  turf.destination(point.geometry.coordinates, bestWallDistance + 0.05, bearing, {units: 'meters'});
-            }
+                    // Create fixed point inside area
+                    let nearestPoint = turf.nearestPointOnLine(bestWall, point);
+                    let bearing = turf.bearing(point, nearestPoint);
+                    fixedPoint =  turf.destination(point.geometry.coordinates, bestWallDistance + 0.05, bearing, {units: 'meters'});
+                }
 
-            // Mark level of fixed point
-            fixedPoint.properties.level = point.properties.level;
+                // Mark level of fixed point
+                fixedPoint.properties.level = point.properties.level;
 
-            // Return created point
-            return fixedPoint;
+                // Return created point
+                return fixedPoint;
 
+            }
         }
     }
 

package/lib/components/logger/base.d.ts

@@ -0,0 +1,8 @@
+export default class BaseLogger {
+    id: string;
+    organization_id: string;
+    organization_name?: string;
+    visitor_id: string;
+    createdAt: Date;
+    constructor(data: any);
+}

package/lib/components/logger/base.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var uuid_1 = require("uuid");
+var BaseLogger = /** @class */ (function () {
+    function BaseLogger(data) {
+        this.id = data.id ? data.id : uuid_1.v4() + ":" + uuid_1.v4();
+        this.organization_id = data.organization_id;
+        this.organization_name = data.organization_name;
+        this.visitor_id = data.visitor_id ? data.visitor_id : uuid_1.v4();
+        this.createdAt = data.createdAt ? data.createdAt : new Date();
+    }
+    return BaseLogger;
+}());
+exports.default = BaseLogger;

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

@@ -0,0 +1,8 @@
+export default class BaseLogger {
+    id: string;
+    organization_id: string;
+    organization_name?: string;
+    visitor_id: string;
+    createdAt: Date;
+    constructor(data: any);
+}

package/lib/components/logger/main.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var common_1 = require("../../common");
+var BaseLogger = /** @class */ (function () {
+    function BaseLogger(data) {
+        this.id = data.id ? data.id : common_1.uuidv4 + ":" + common_1.uuidv4;
+        this.organization_id = data.organization_id;
+        this.organization_name = data.organization_name;
+        this.visitor_id = data.visitor_id ? data.visitor_id : "" + common_1.uuidv4;
+        this.createdAt = data.createdAt ? data.createdAt : new Date();
+    }
+    return BaseLogger;
+}());
+exports.default = BaseLogger;

package/lib/components/logger/wayfinding.d.ts

@@ -0,0 +1,25 @@
+import BaseLogger from './base';
+export default class WayfindingLogger extends BaseLogger {
+    startLngLat: [number, number];
+    startLevel: number;
+    startSegmentId?: string;
+    startSegmentName?: string;
+    startGeofenceId?: string;
+    startGeofenceName?: string;
+    destinationFeatureId?: string;
+    destinationName?: string;
+    destinationLngLat: [number, number];
+    destinationLevel: number;
+    foundPath: boolean;
+    optionAvoidBarrier: boolean;
+    optionAvoidElevators: boolean;
+    optionAvoidEscalators: boolean;
+    optionAvoidNarrowPaths: boolean;
+    optionAvoidRamps: boolean;
+    optionAvoidStaircases: boolean;
+    optionAvoidTicketGates: boolean;
+    route: [number, number, number][];
+    rerouted?: boolean;
+    constructor(data: any);
+    save(): Promise<void>;
+}

package/lib/components/logger/wayfinding.js

@@ -0,0 +1,104 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var common_1 = require("../../common");
+var base_1 = require("./base");
+var WayfindingLogger = /** @class */ (function (_super) {
+    __extends(WayfindingLogger, _super);
+    function WayfindingLogger(data) {
+        var _this = _super.call(this, data) || this;
+        _this.startLngLat = data.startLngLat;
+        _this.startLevel = data.startLevel;
+        _this.startSegmentId = data.startSegmentId;
+        _this.startSegmentName = data.startSegmentName;
+        _this.startGeofenceId = data.startGeofenceId;
+        _this.startGeofenceName = data.startGeofenceName;
+        _this.destinationFeatureId = data.destinationFeatureId;
+        _this.destinationName = data.destinationName;
+        _this.destinationLngLat = data.destinationLngLat;
+        _this.destinationLevel = data.destinationLevel;
+        _this.foundPath = data.foundPath;
+        _this.optionAvoidBarrier = data.optionAvoidBarrier;
+        _this.optionAvoidElevators = data.optionAvoidElevators;
+        _this.optionAvoidEscalators = data.optionAvoidEscalators;
+        _this.optionAvoidNarrowPaths = data.optionAvoidNarrowPaths;
+        _this.optionAvoidRamps = data.optionAvoidRamps;
+        _this.optionAvoidStaircases = data.optionAvoidStaircases;
+        _this.optionAvoidTicketGates = data.optionAvoidTicketGates;
+        _this.route = data.route;
+        _this.rerouted = data.rerouted;
+        return _this;
+    }
+    WayfindingLogger.prototype.save = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, common_1.axios.post("v6/geo/wayfinding_logs", [this])];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        e_1 = _a.sent();
+                        console.log("Log saving failed, " + e_1.message);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return WayfindingLogger;
+}(base_1.default));
+exports.default = WayfindingLogger;

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

@@ -25,6 +25,7 @@ interface State {
     readonly noPlaces: boolean;
     readonly textNavigation: any;
     readonly persons: PersonModel[];
+    readonly user: any;
 }
 interface Options {
     selector?: string;
@@ -56,6 +57,13 @@ interface Options {
         beforeLayer?: string;
         attribution?: string;
     };
+    handleUrlParams?: boolean;
+    urlParams?: {
+        startFeauture?: string;
+        destinationFeature?: string;
+        defaultPlace?: string;
+    };
+    useGpsLocation?: boolean;
 }
 interface PaddingOptions {
     bottom: number;
@@ -104,6 +112,7 @@ export declare class Map {
     private onMapReady;
     private initKiosk;
     private onSetKiosk;
+    private initGeoLocation;
     private initDirectionIcon;
     private initAnimatedRoute;
     private initRasterTiles;
@@ -113,6 +122,7 @@ export declare class Map {
     private onShopMouseEnter;
     private onShopMouseMove;
     private onShopMouseLeave;
+    private initUrlParams;
     private featureDialog;
     private onAddNewFeature;
     private onUpdateFeature;