proximiio-js-library 1.2.0

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

@@ -0,0 +1,134 @@
+declare const _default: {
+    'proximiio:languages': {
+        en: {
+            title: string;
+            level: {
+                zero: string;
+                one: string;
+                two: string;
+                few: string;
+                many: string;
+                other: string;
+            };
+            meter: {
+                zero: string;
+                one: string;
+                two: string;
+                few: string;
+                many: string;
+                other: string;
+            };
+            turn_before: string;
+            turn_prepare: string;
+            turn_now: string;
+            continue: string;
+            levelchange: string;
+            turn_left_hard: string;
+            turn_left: string;
+            turn_left_slight: string;
+            turn_straight: string;
+            turn_right_slight: string;
+            turn_right: string;
+            turn_right_hard: string;
+            turn_around: string;
+            destination_nearing: string;
+            destination_reached: string;
+            canceled: string;
+            calculating: string;
+            recalculating: string;
+            path_not_found: string;
+            level_change_down: string;
+            level_change_up: string;
+            passing_poi: string;
+            left: string;
+            right: string;
+        };
+        fi: {
+            title: string;
+            level: {
+                zero: string;
+                one: string;
+                two: string;
+                few: string;
+                many: string;
+                other: string;
+            };
+            meter: {
+                zero: string;
+                one: string;
+                two: string;
+                few: string;
+                many: string;
+                other: string;
+            };
+            turn_before: string;
+            turn_prepare: string;
+            turn_now: string;
+            continue: string;
+            levelchange: string;
+            turn_left_hard: string;
+            turn_left: string;
+            turn_left_slight: string;
+            turn_straight: string;
+            turn_right_slight: string;
+            turn_right: string;
+            turn_right_hard: string;
+            turn_around: string;
+            destination_nearing: string;
+            destination_reached: string;
+            canceled: string;
+            calculating: string;
+            recalculating: string;
+            path_not_found: string;
+            level_change_down: string;
+            level_change_up: string;
+            passing_poi: string;
+            left: string;
+            right: string;
+        };
+    };
+    en: {
+        title: string;
+        level: {
+            zero: string;
+            one: string;
+            two: string;
+            few: string;
+            many: string;
+            other: string;
+        };
+        meter: {
+            zero: string;
+            one: string;
+            two: string;
+            few: string;
+            many: string;
+            other: string;
+        };
+        turn_before: string;
+        turn_prepare: string;
+        turn_now: string;
+        continue: string;
+        levelchange: string;
+        turn_left_hard: string;
+        turn_left: string;
+        turn_left_slight: string;
+        turn_straight: string;
+        turn_right_slight: string;
+        turn_right: string;
+        turn_right_hard: string;
+        turn_around: string;
+        destination_nearing: string;
+        destination_reached: string;
+        canceled: string;
+        calculating: string;
+        recalculating: string;
+        path_not_found: string;
+        level_change_down: string;
+        level_change_up: string;
+        passing_poi: string;
+        left: string;
+        right: string;
+    };
+};
+export default _default;

package/lib/components/map/metadata.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    'proximiio:languages': {
+        en: {
+            title: 'English',
+            level: {
+                zero: 'levels',
+                one: 'level',
+                two: 'levels',
+                few: 'levels',
+                many: 'levels',
+                other: 'levels',
+            },
+            meter: {
+                zero: 'meters',
+                one: 'meter',
+                two: 'meters',
+                few: 'meters',
+                many: 'meters',
+                other: 'meters',
+            },
+            turn_before: 'In %d %s %s.',
+            turn_prepare: 'Prepare to %s in %d %s.',
+            turn_now: '%s.',
+            continue: 'Continue %d %s.',
+            levelchange: 'Use %s to get to %d %s.',
+            turn_left_hard: 'turn hard left',
+            turn_left: 'turn left',
+            turn_left_slight: 'turn slight left',
+            turn_straight: 'continue straight',
+            turn_right_slight: 'turn slight right',
+            turn_right: 'turn right',
+            turn_right_hard: 'turn right',
+            turn_around: 'turn around',
+            destination_nearing: 'In %d %s you will arrive at your destination.',
+            destination_reached: 'You have reached your destination',
+            canceled: 'Navigation was canceled.',
+            calculating: 'Calculating route...',
+            recalculating: 'Recalculating route...',
+            path_not_found: 'Unable to find path.',
+            level_change_down: 'go %d %s up to %s %d.',
+            level_change_up: 'go %d %s up to %s %d.',
+            passing_poi: 'Passing %s on your %s',
+            left: 'left',
+            right: 'right',
+        },
+        fi: {
+            title: 'English',
+            level: {
+                zero: 'levels',
+                one: 'level',
+                two: 'levels',
+                few: 'levels',
+                many: 'levels',
+                other: 'levels',
+            },
+            meter: {
+                zero: 'meters',
+                one: 'meter',
+                two: 'meters',
+                few: 'meters',
+                many: 'meters',
+                other: 'meters',
+            },
+            turn_before: 'In %d %s %s.',
+            turn_prepare: 'Prepare to %s in %d %s.',
+            turn_now: '%s.',
+            continue: 'Continue %d %s.',
+            levelchange: 'Use %s to get to %d %s.',
+            turn_left_hard: 'turn hard left',
+            turn_left: 'turn left',
+            turn_left_slight: 'turn slight left',
+            turn_straight: 'continue straight',
+            turn_right_slight: 'turn slight right',
+            turn_right: 'turn right',
+            turn_right_hard: 'turn right',
+            turn_around: 'turn around',
+            destination_nearing: 'In %d %s you will arrive at your destination.',
+            destination_reached: 'You have reached your destination',
+            canceled: 'Navigation was canceled.',
+            calculating: 'Calculating route...',
+            recalculating: 'Recalculating route...',
+            path_not_found: 'Unable to find path.',
+            level_change_down: 'go %d %s up to %s %d.',
+            level_change_up: 'go %d %s up to %s %d.',
+            passing_poi: 'Passing %s on your %s',
+            left: 'left',
+            right: 'right',
+        },
+    },
+    en: {
+        title: 'English',
+        level: {
+            zero: 'levels',
+            one: 'level',
+            two: 'levels',
+            few: 'levels',
+            many: 'levels',
+            other: 'levels',
+        },
+        meter: {
+            zero: 'meters',
+            one: 'meter',
+            two: 'meters',
+            few: 'meters',
+            many: 'meters',
+            other: 'meters',
+        },
+        turn_before: 'In %d %s %s.',
+        turn_prepare: 'Prepare to %s in %d %s.',
+        turn_now: '%s.',
+        continue: 'Continue %d %s.',
+        levelchange: 'Use %s to get to %d %s.',
+        turn_left_hard: 'turn hard left',
+        turn_left: 'turn left',
+        turn_left_slight: 'turn slight left',
+        turn_straight: 'continue straight',
+        turn_right_slight: 'turn slight right',
+        turn_right: 'turn right',
+        turn_right_hard: 'turn right',
+        turn_around: 'turn around',
+        destination_nearing: 'In %d %s you will arrive at your destination.',
+        destination_reached: 'You have reached your destination',
+        canceled: 'Navigation was canceled.',
+        calculating: 'Calculating route...',
+        recalculating: 'Recalculating route...',
+        path_not_found: 'Unable to find path.',
+        level_change_down: 'go %d %s up to %s %d.',
+        level_change_up: 'go %d %s up to %s %d.',
+        passing_poi: 'Passing %s on your %s',
+        left: 'left',
+        right: 'right',
+    },
+};

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

@@ -0,0 +1,12 @@
+import Feature, { FeatureCollection } from '../../models/feature';
+export default class Routing {
+    data: FeatureCollection;
+    wayfinding: any;
+    constructor();
+    setData(collection: FeatureCollection): void;
+    toggleOnlyAccessible(onlyAccessible: any): void;
+    route(start: Feature, finish: Feature): {
+        levelPaths: any;
+        points: any;
+    };
+}

package/lib/components/map/routing.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+var wayfinding_1 = require("../../../assets/wayfinding");
+var feature_1 = require("../../models/feature");
+var helpers_1 = require("@turf/helpers");
+var Routing = /** @class */ (function () {
+    function Routing() {
+        this.data = new feature_1.FeatureCollection({});
+    }
+    Routing.prototype.setData = function (collection) {
+        this.data = collection;
+        this.wayfinding = new wayfinding_1.Wayfinding(this.data);
+        this.wayfinding.preprocess();
+        // pathfinding.load(neighbourList, wallOffsets);
+        // this.pathFinder.setConfiguration({
+        // avoidEscalators: true,
+        // avoidNarrowPaths: true,
+        // avoidRevolvingDoors: true
+        // });
+    };
+    Routing.prototype.toggleOnlyAccessible = function (onlyAccessible) {
+        if (onlyAccessible) {
+            this.wayfinding.setConfiguration({
+                avoidStaircases: true,
+                avoidBarriers: true,
+                avoidNarrowPaths: true,
+                avoidRevolvingDoors: true,
+                avoidTicketGates: true,
+            });
+        }
+        else {
+            this.wayfinding.setConfiguration({
+                avoidElevators: false,
+                avoidEscalators: false,
+                avoidStaircases: false,
+                avoidRamps: false,
+                avoidNarrowPaths: false,
+                avoidRevolvingDoors: false,
+                avoidTicketGates: false,
+                avoidBarriers: false,
+            });
+        }
+    };
+    Routing.prototype.route = function (start, finish) {
+        var points = this.wayfinding.runAStar(start, finish);
+        if (!points) {
+            return null;
+        }
+        var levelPoints = {};
+        // tslint:disable-next-line:no-shadowed-variable
+        points.forEach(function (point) {
+            if (typeof levelPoints[point.properties.level] === 'undefined') {
+                levelPoints[point.properties.level] = [];
+            }
+            levelPoints[point.properties.level].push(point);
+        });
+        var levels = Object.keys(levelPoints);
+        var levelPaths = {};
+        levels.forEach(function (level) {
+            if (levelPoints[level].length > 1) {
+                // tslint:disable-next-line:no-shadowed-variable
+                levelPaths[level] = new feature_1.default(helpers_1.lineString(levelPoints[level].map(function (point) { return point.geometry.coordinates; })));
+            }
+            else {
+                // tslint:disable-next-line:no-shadowed-variable
+                levelPaths[level] = new feature_1.default(helpers_1.point(levelPoints[level].map(function (point) { return point.geometry.coordinates; })));
+            }
+        });
+        return { levelPaths: levelPaths, points: points };
+    };
+    return Routing;
+}());
+exports.default = Routing;

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

@@ -0,0 +1,10 @@
+import { Eventable } from '../../../eventable';
+export declare type BaseSourceType = 'vector' | 'raster' | 'raster-dem' | 'geojson' | 'image' | 'video';
+export default class BaseSource extends Eventable {
+    id: string;
+    type: BaseSourceType;
+    constructor(id: string, type: BaseSourceType);
+    get source(): {
+        type: BaseSourceType;
+    };
+}

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

@@ -0,0 +1,38 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var eventable_1 = require("../../../eventable");
+var BaseSource = /** @class */ (function (_super) {
+    __extends(BaseSource, _super);
+    function BaseSource(id, type) {
+        var _this = _super.call(this) || this;
+        _this.id = id;
+        _this.type = type;
+        return _this;
+    }
+    Object.defineProperty(BaseSource.prototype, "source", {
+        get: function () {
+            return {
+                type: this.type,
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BaseSource;
+}(eventable_1.Eventable));
+exports.default = BaseSource;

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

@@ -0,0 +1,7 @@
+import DataSource from './data_source';
+import { FeatureCollection } from '../../../models/feature';
+export default class ClusterSource extends DataSource {
+    cluster: boolean;
+    data: FeatureCollection;
+    constructor();
+}

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

@@ -0,0 +1,30 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var data_source_1 = require("./data_source");
+var feature_1 = require("../../../models/feature");
+var ClusterSource = /** @class */ (function (_super) {
+    __extends(ClusterSource, _super);
+    function ClusterSource() {
+        var _this = _super.call(this, 'clusters') || this;
+        _this.cluster = true;
+        _this.data = new feature_1.FeatureCollection({});
+        return _this;
+    }
+    return ClusterSource;
+}(data_source_1.default));
+exports.default = ClusterSource;

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

@@ -0,0 +1,17 @@
+import BaseSource from './base_source';
+import { FeatureCollection } from '../../../models/feature';
+export default class DataSource extends BaseSource {
+    data: FeatureCollection;
+    cluster: boolean;
+    clusterRadius: number;
+    clusterMaxZoom: number;
+    isEditable: boolean;
+    constructor(id: string, data?: FeatureCollection);
+    get source(): {
+        type: import("./base_source").BaseSourceType;
+        data: FeatureCollection;
+        cluster: boolean;
+        clusterMaxZoom: number;
+        clusterRadius: number;
+    };
+}

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

@@ -0,0 +1,46 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var base_source_1 = require("./base_source");
+var feature_1 = require("../../../models/feature");
+var DataSource = /** @class */ (function (_super) {
+    __extends(DataSource, _super);
+    function DataSource(id, data) {
+        var _this = _super.call(this, id, 'geojson') || this;
+        _this.cluster = false;
+        _this.clusterRadius = 50;
+        _this.clusterMaxZoom = 19;
+        _this.isEditable = true;
+        _this.data = data || new feature_1.FeatureCollection({});
+        return _this;
+    }
+    Object.defineProperty(DataSource.prototype, "source", {
+        get: function () {
+            return {
+                type: this.type,
+                data: this.data,
+                cluster: this.cluster,
+                clusterMaxZoom: this.clusterMaxZoom,
+                clusterRadius: this.clusterRadius,
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DataSource;
+}(base_source_1.default));
+exports.default = DataSource;

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

@@ -0,0 +1,16 @@
+import DataSource from './data_source';
+import Feature, { FeatureCollection } from '../../../models/feature';
+export default class GeoJSONSource extends DataSource {
+    language: string;
+    constructor(features: FeatureCollection);
+    fetch(data: any): void;
+    create(feature: Feature): void;
+    update(feature: Feature): void;
+    delete(id: string): void;
+    mapLanguage(): void;
+    mapFeatureLanguage(feature: Feature, language: string): void;
+    query(query: string, level?: number): Feature[];
+    get(id: string): Feature;
+    getInternal(id: string): Feature;
+    get collection(): FeatureCollection;
+}

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

@@ -0,0 +1,77 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var data_source_1 = require("./data_source");
+var feature_1 = require("../../../models/feature");
+var GeoJSONSource = /** @class */ (function (_super) {
+    __extends(GeoJSONSource, _super);
+    function GeoJSONSource(features) {
+        var _this = _super.call(this, 'main') || this;
+        _this.language = 'en';
+        return _this;
+    }
+    GeoJSONSource.prototype.fetch = function (data) {
+        this.data = new feature_1.FeatureCollection(data);
+        this.mapLanguage();
+    };
+    GeoJSONSource.prototype.create = function (feature) {
+        this.data.features.push(feature);
+    };
+    GeoJSONSource.prototype.update = function (feature) {
+        var foundIndex = this.data.features.findIndex(function (x) { return x.id === feature.id || x.properties.id === feature.id; });
+        this.data.features[foundIndex] = feature;
+    };
+    GeoJSONSource.prototype.delete = function (id) {
+        var foundIndex = this.data.features.findIndex(function (x) { return x.id === id || x.properties.id === id; });
+        this.data.features.splice(foundIndex, 1);
+    };
+    GeoJSONSource.prototype.mapLanguage = function () {
+        var _this = this;
+        var features = this.data.features.filter(function (f) { return typeof f.properties.title_i18n === 'object'; });
+        features.forEach(function (feature) { return _this.mapFeatureLanguage(feature, _this.language); });
+    };
+    GeoJSONSource.prototype.mapFeatureLanguage = function (feature, language) {
+        if (typeof feature.properties.title_i18n === 'string') {
+            feature.properties.title_i18n = JSON.parse(feature.properties.title_i18n);
+        }
+        if (typeof feature.properties.title_i18n === 'object') {
+            feature.properties.title = feature.properties.title_i18n[language];
+        }
+    };
+    GeoJSONSource.prototype.query = function (query, level) {
+        if (level === void 0) { level = 0; }
+        return this.data.features.filter(function (f) { return f.properties.title && f.properties.title.toLowerCase().match(query.toLowerCase()); });
+    };
+    GeoJSONSource.prototype.get = function (id) {
+        return this.data.features.find(function (f) { return f.id === id; });
+    };
+    GeoJSONSource.prototype.getInternal = function (id) {
+        return this.data.features.find(function (f) { return f.properties.id === id; });
+    };
+    Object.defineProperty(GeoJSONSource.prototype, "collection", {
+        get: function () {
+            return {
+                type: 'FeatureCollection',
+                features: this.data.features.map(function (f) { return f.json; }),
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return GeoJSONSource;
+}(data_source_1.default));
+exports.default = GeoJSONSource;

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

@@ -0,0 +1,16 @@
+/// <reference types="mapbox-gl" />
+import { Eventable } from '../../../eventable';
+import { FloorModel } from '../../../models/floor';
+export default class ImageSourceManager extends Eventable {
+    sources: string[];
+    layers: string[];
+    floors: {
+        data: FloorModel[];
+        total: number;
+    };
+    belowLayer: string;
+    enabled: boolean;
+    constructor();
+    initialize(): Promise<void>;
+    setLevel(map: mapboxgl.Map, level: number): void;
+}