incyclist-services 1.5.7 → 1.5.8

package/lib/free-ride/service.d.ts

@@ -0,0 +1,25 @@
+import { IncyclistService } from "../base/service";
+import { Observer } from "../base/types";
+import { FreeRideContinuation, IMapArea, IncyclistNode } from "../maps/MapArea/types";
+import { FreeRideOption } from "../routes/list/types";
+import { LatLng } from "../utils/geo";
+export declare class FreeRideService extends IncyclistService {
+    protected observer: Observer;
+    protected startPosition: IncyclistNode;
+    protected startOptions: FreeRideContinuation[];
+    protected selectedOption: FreeRideOption;
+    constructor();
+    startRouteDefinition(initialPosition?: LatLng): Observer;
+    changeStartPosition(position: LatLng, initial?: boolean): Promise<void>;
+    select(option: FreeRideOption): void;
+    getRouteDefinitionDisplayProps(): {
+        position: IncyclistNode;
+        options: FreeRideOption[];
+    };
+    protected buildFreeRideOptions(): FreeRideOption[];
+    protected getStartOptions(map: IMapArea, initial?: boolean): Promise<void>;
+    protected setStartPosition(position?: LatLng): void;
+    protected getDefaultStartPosition(): IncyclistNode;
+    protected getMapArea(): import("../maps/MapArea/service").MapAreaService;
+    protected getUserSettings(): import("../settings").UserSettingsService;
+}

package/lib/free-ride/service.js

@@ -0,0 +1,163 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+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 __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeRideService = void 0;
+const decorators_1 = require("../base/decorators");
+const service_1 = require("../base/service");
+const types_1 = require("../base/types");
+const consts_1 = require("../maps/MapArea/consts");
+const service_2 = require("../maps/MapArea/service");
+const utils_1 = require("../maps/MapArea/utils");
+const settings_1 = require("../settings");
+let FreeRideService = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = service_1.IncyclistService;
+    let _instanceExtraInitializers = [];
+    let _getMapArea_decorators;
+    let _getUserSettings_decorators;
+    var FreeRideService = _classThis = class extends _classSuper {
+        constructor() {
+            super('FreeRide');
+            this.observer = __runInitializers(this, _instanceExtraInitializers);
+        }
+        startRouteDefinition(initialPosition) {
+            if (this.observer)
+                this.observer.stop();
+            this.observer = new types_1.Observer();
+            this.changeStartPosition(initialPosition, true);
+            return this.observer;
+        }
+        changeStartPosition(position_1) {
+            return __awaiter(this, arguments, void 0, function* (position, initial = false) {
+                this.setStartPosition(position);
+                const map = yield this.getMapArea().load(this.startPosition);
+                yield this.getStartOptions(map, true);
+                this.observer.emit(initial ? 'loaded' : 'updated');
+            });
+        }
+        select(option) {
+            this.selectedOption = option;
+        }
+        getRouteDefinitionDisplayProps() {
+            const options = this.buildFreeRideOptions();
+            return { position: this.startPosition, options };
+        }
+        buildFreeRideOptions() {
+            var _a;
+            const opts = (_a = this.startOptions) !== null && _a !== void 0 ? _a : [];
+            return opts.map(o => (Object.assign({}, o)));
+        }
+        getStartOptions(map_1) {
+            return __awaiter(this, arguments, void 0, function* (map, initial = false) {
+                var _a;
+                this.startOptions = [];
+                if (!map)
+                    return;
+                const { way } = (_a = map.getNearestPath(this.startPosition)) !== null && _a !== void 0 ? _a : {};
+                if (!way) {
+                    const { lat, lng } = this.startPosition;
+                    this.logEvent({ message: 'no options found for', lat, lng, reason: 'off track' });
+                    return;
+                }
+                const crossing = (0, utils_1.getPointCrossingPath)(this.startPosition, way.path, true);
+                if (!crossing) {
+                    if (way.path.length > 1)
+                        this.startOptions = [{ path: way.path }];
+                    return;
+                }
+                this.setStartPosition(crossing.point);
+                const optionManager = (0, service_2.useMapArea)().getOptionManager();
+                optionManager.setMap(map);
+                const options = yield optionManager.getStartOptions(way, crossing);
+                this.startOptions.push(...options);
+            });
+        }
+        setStartPosition(position) {
+            try {
+                this.startPosition = position !== null && position !== void 0 ? position : this.getDefaultStartPosition();
+                this.getUserSettings().set('preferences.routeSelection.freeRide.position', this.startPosition);
+            }
+            catch (err) {
+                this.logError(err, 'setStartPosition');
+            }
+        }
+        getDefaultStartPosition() {
+            try {
+                return this.getUserSettings().get('preferences.routeSelection.freeRide.position', consts_1.DEFAULT_POSITION);
+            }
+            catch (_a) {
+                return consts_1.DEFAULT_POSITION;
+            }
+        }
+        getMapArea() {
+            return (0, service_2.useMapArea)();
+        }
+        getUserSettings() {
+            return (0, settings_1.useUserSettings)();
+        }
+    };
+    __setFunctionName(_classThis, "FreeRideService");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        _getMapArea_decorators = [decorators_1.Injectable];
+        _getUserSettings_decorators = [decorators_1.Injectable];
+        __esDecorate(_classThis, null, _getMapArea_decorators, { kind: "method", name: "getMapArea", static: false, private: false, access: { has: obj => "getMapArea" in obj, get: obj => obj.getMapArea }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _getUserSettings_decorators, { kind: "method", name: "getUserSettings", static: false, private: false, access: { has: obj => "getUserSettings" in obj, get: obj => obj.getUserSettings }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        FreeRideService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return FreeRideService = _classThis;
+})();
+exports.FreeRideService = FreeRideService;

package/lib/maps/MapArea/MapArea.d.ts

@@ -0,0 +1,31 @@
+import { EventLogger } from "gd-eventlog";
+import { LatLng } from "../../utils/geo";
+import { Boundary, FreeRideDataSet, IMapArea, IncyclistNode, IncyclistWay, IncyclistWaySplit, NearestPathInfo, PathCrossingInfo, SegmentInfo, SplitPointInfo, WayInfo } from "./types";
+export declare class MapArea implements IMapArea {
+    protected data: FreeRideDataSet;
+    protected queryLocation: IncyclistNode;
+    protected bounds: Boundary;
+    protected logger: EventLogger;
+    constructor(data: FreeRideDataSet, queryLocation: IncyclistNode, bounds: Boundary);
+    getQueryLocation(): IncyclistNode;
+    getBoundary(): Boundary;
+    getWays(): IncyclistWay[];
+    getWay(id: string): IncyclistWay;
+    getNode(id: string): IncyclistNode;
+    getStats(): Record<string, number>;
+    isWithinBoundary(location: LatLng): boolean;
+    getNearestPath(point: IncyclistNode): NearestPathInfo;
+    getFirstBranch(way: WayInfo, ignore?: string): SplitPointInfo;
+    splitAtFirstBranch(way: WayInfo): IncyclistWaySplit;
+    splitAtCrossingPoint(way: IncyclistWay, crossing: PathCrossingInfo): Array<IncyclistWaySplit>;
+    buildSegmentInfo(from: IncyclistWay, parts: Array<IncyclistWaySplit>): SegmentInfo;
+    protected correctRoundabouts(): void;
+    protected collectRoundaboutWays(way: IncyclistWay): Array<string>;
+    protected getBranch(crossing: SplitPointInfo, wayId: string, targetId: string): IncyclistWay;
+    protected replaceWayID(way: IncyclistWay, newId: string, replaceLookup?: boolean): IncyclistWay;
+    protected getUntilFirstBranch(w: WayInfo, props?: {
+        reverse?: boolean;
+        ignore?: string;
+    }): IncyclistWay;
+    protected logError(err: Error, fn: string, args?: any): void;
+}

package/lib/maps/MapArea/MapArea.js

@@ -0,0 +1,338 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapArea = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("./utils");
+const clone_1 = __importDefault(require("../../utils/clone"));
+class MapArea {
+    constructor(data, queryLocation, bounds) {
+        this.data = data;
+        this.queryLocation = queryLocation;
+        this.bounds = bounds;
+        this.logger = new gd_eventlog_1.EventLogger('MapArea');
+        this.correctRoundabouts();
+    }
+    getQueryLocation() {
+        return this.queryLocation;
+    }
+    getBoundary() {
+        return this.bounds;
+    }
+    getWays() {
+        return this.data.ways;
+    }
+    getWay(id) {
+        return this.data.waysLookup[id];
+    }
+    getNode(id) {
+        return this.data.nodesLookup[id];
+    }
+    getStats() {
+        return this.data.typeStats;
+    }
+    isWithinBoundary(location) {
+        return (0, utils_1.isWithinBoundary)(location, this.bounds);
+    }
+    getNearestPath(point) {
+        var _a, _b;
+        const ways = (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.ways) !== null && _b !== void 0 ? _b : [];
+        if (!(ways === null || ways === void 0 ? void 0 : ways.length))
+            return;
+        let w;
+        let min = { path: undefined, distance: undefined, way: undefined };
+        for (w of ways) {
+            let distance = (0, utils_1.distanceToPath)(point, w);
+            if (distance !== undefined && (min.distance === undefined || distance < min.distance)) {
+                min.distance = distance;
+                min.path = w.path;
+                min.way = w;
+            }
+        }
+        return min;
+    }
+    getFirstBranch(way, ignore) {
+        if ((way === null || way === void 0 ? void 0 : way.path) === undefined)
+            return;
+        let pFound = undefined;
+        way.path.forEach((node, idx) => {
+            var _a, _b;
+            if (idx === 0 || ((_a = node === null || node === void 0 ? void 0 : node.ways) === null || _a === void 0 ? void 0 : _a.length) < 2 || pFound)
+                return;
+            const branches = [];
+            (_b = node.ways) === null || _b === void 0 ? void 0 : _b.forEach((wid) => {
+                if (wid === way.id)
+                    return;
+                const branch = this.getWay(wid);
+                if ((0, utils_1.isOneWay)(branch) && branch.path[branch.path.length - 1].id === node.id)
+                    return;
+                if (ignore && wid === ignore)
+                    return;
+                branches.push(wid);
+            });
+            pFound = branches.length > 0 ? { point: node, idx, branches } : undefined;
+        });
+        return pFound;
+    }
+    splitAtFirstBranch(way) {
+        if ((way === null || way === void 0 ? void 0 : way.path) === undefined)
+            return;
+        const path = [...way.path];
+        const original = (0, clone_1.default)(way);
+        const crossing = this.getFirstBranch(way);
+        if (!crossing) {
+            return {
+                wayId: original.id,
+                path,
+                branches: []
+            };
+        }
+        let result = {
+            wayId: way.id,
+            branches: []
+        };
+        const [before, after] = (0, utils_1.splitAtPointInfo)(way, crossing);
+        result.path = before;
+        const prefered = { id: way.id, path: after };
+        if (prefered.path.length > 1)
+            result.branches.push(prefered);
+        crossing.point.ways.forEach((wid) => {
+            const option = this.getBranch(crossing, way.id, wid);
+            if (option)
+                result.branches.push(option);
+        });
+        return result;
+    }
+    splitAtCrossingPoint(way, crossing) {
+        if ((way === null || way === void 0 ? void 0 : way.path) === undefined || (crossing === null || crossing === void 0 ? void 0 : crossing.idx) === undefined || (crossing === null || crossing === void 0 ? void 0 : crossing.point) === undefined)
+            return;
+        const { point, idx: crossingIdx } = crossing;
+        const addWaysCrossing = (res) => {
+            let optWay = way;
+            point.ways.forEach(optId => {
+                var _a;
+                if (optId === way.id)
+                    return;
+                optWay = this.getWay(optId);
+                if (!((_a = optWay === null || optWay === void 0 ? void 0 : optWay.path) === null || _a === void 0 ? void 0 : _a.length))
+                    return;
+                if (optWay.path[optWay.path.length - 1].id === point.id)
+                    optWay.path.reverse();
+                else if (optWay.path[0].id !== point.id) {
+                    const parts = (0, utils_1.splitAtPoint)(optWay, point).filter(p => p.path.length > 1 && !p.onewayReverse);
+                    parts.forEach(p => res.push({ wayId: p.id, path: p.path }));
+                    return;
+                }
+                if (optWay.path.length > 1)
+                    res.push({ wayId: optWay.id, path: optWay.path });
+            });
+        };
+        const addOption = (newPath, res, reverse) => {
+            let optWay = way;
+            let path = [];
+            if (newPath.length === 1) {
+                addWaysCrossing(res);
+            }
+            else if (newPath.length > 1) {
+                path = newPath;
+                if (reverse)
+                    path.reverse();
+                res.push({ wayId: optWay.id, path });
+            }
+        };
+        const res = [];
+        let newPath = [];
+        if (!point.ways)
+            point.ways = [way.id];
+        way.path.forEach((p, i) => {
+            if (i < crossingIdx || i > crossingIdx) {
+                newPath.push(p);
+            }
+            else {
+                if ((newPath === null || newPath === void 0 ? void 0 : newPath.length) > 0 && point.id !== newPath[newPath.length - 1].id)
+                    newPath.push(point);
+                if (!(0, utils_1.isOneWay)(way)) {
+                    addOption(newPath, res, true);
+                }
+                newPath = [];
+                newPath.push(point);
+                if (point.id !== p.id)
+                    newPath.push(p);
+            }
+        });
+        addOption(newPath, res, false);
+        return res;
+    }
+    buildSegmentInfo(from, parts) {
+        const segments = [];
+        const points = [];
+        parts.forEach((option, i) => {
+            const { wayId, path } = option;
+            const wayOriginal = this.getWay(wayId !== null && wayId !== void 0 ? wayId : from.id);
+            if (path) {
+                const wayOption = Object.assign(Object.assign({}, wayOriginal), { path });
+                let res = this.splitAtFirstBranch(wayOption);
+                segments.push({ id: res.wayId, path: res.path });
+                points.push(...res.path);
+            }
+        });
+        return { segments, points };
+    }
+    correctRoundabouts() {
+        var _a;
+        let multiWayRoundabouts = [];
+        let roundaboutsImplicit = [];
+        try {
+            (_a = this.data) === null || _a === void 0 ? void 0 : _a.ways.forEach(way => {
+                if ((0, utils_1.isRoundabout)(way, true)) {
+                    let ways = this.collectRoundaboutWays(way);
+                    let id = (0, utils_1.generateID)(ways);
+                    let found = multiWayRoundabouts.find(e => e.id === id);
+                    if (!found) {
+                        found = (way.path[0].id === way.path[way.path.length - 1].id);
+                        if (found) {
+                            roundaboutsImplicit.push(way);
+                        }
+                    }
+                    if (!found)
+                        multiWayRoundabouts.push({ id, ways });
+                }
+                else if ((0, utils_1.isRoundabout)(way, false)) {
+                    roundaboutsImplicit.push(way);
+                }
+            });
+            multiWayRoundabouts.forEach(ri => {
+                let originalNodes = [];
+                ri.ways.forEach((wid, i) => {
+                    let way = this.getWay(wid);
+                    let path = way.path;
+                    path.forEach(n => {
+                        if (originalNodes.length === 0 ||
+                            originalNodes[originalNodes.length - 1] !== n.id)
+                            originalNodes.push(n.id);
+                    });
+                });
+                ri.ways.forEach((wid, i) => {
+                    let way = this.getWay(wid);
+                    this.replaceWayID(way, ri.id, i === 0);
+                });
+                let roundabout = this.getWay(ri.id);
+                roundabout.path = [];
+                originalNodes.forEach(nid => {
+                    let node = this.getNode(nid);
+                    roundabout.path.push(node);
+                });
+                roundabout.tags.roundabout = 'yes';
+            });
+            roundaboutsImplicit.forEach(roundabout => {
+                if (roundabout.tags === undefined)
+                    roundabout.tags = {};
+                roundabout.tags.roundabout = 'yes';
+            });
+        }
+        catch (err) {
+            this.logError(err, 'correctRoundabouts');
+        }
+    }
+    collectRoundaboutWays(way) {
+        if (!(0, utils_1.isRoundabout)(way, true))
+            return undefined;
+        const contains = (ways, wid) => {
+            let found = ways.find(id => id === wid);
+            return found !== undefined;
+        };
+        const addNodes = (ways, way) => {
+            const crossings = way.path.filter((n, idx) => { var _a; return idx !== 0 && ((_a = n.ways) === null || _a === void 0 ? void 0 : _a.length) > 1; });
+            crossings.forEach(n => {
+                n.ways.forEach(wid => {
+                    let w = this.getWay(wid);
+                    if ((0, utils_1.isRoundabout)(w, true) && wid !== way.id && !contains(ways, wid)) {
+                        ways.push(wid);
+                        addNodes(ways, w);
+                    }
+                });
+            });
+        };
+        let ways = [way.id];
+        addNodes(ways, way);
+        return ways;
+    }
+    ;
+    getBranch(crossing, wayId, targetId) {
+        let w = (0, clone_1.default)(this.getWay(targetId));
+        if ((w === null || w === void 0 ? void 0 : w.id) === wayId)
+            return;
+        if (w.path[0].id === crossing.point.id) {
+            const res = this.getUntilFirstBranch(w, { ignore: wayId });
+            if (res.path.length > 1)
+                return res;
+        }
+        else if (w.path[w.path.length - 1].id === crossing.point.id) {
+            w.path.reverse();
+            const res = this.getUntilFirstBranch(w, { ignore: wayId });
+            if (res.path.length > 1)
+                return res;
+        }
+        else {
+            let branches = (0, utils_1.splitAtPoint)(w, crossing.point);
+            let res = this.getUntilFirstBranch(branches[0], { ignore: wayId });
+            if (res.path.length > 1)
+                return res;
+            res = this.getUntilFirstBranch(branches[1], { ignore: wayId });
+            if (res.path.length > 1)
+                return res;
+        }
+    }
+    replaceWayID(way, newId, replaceLookup = true) {
+        if (way === undefined || newId === undefined || way.id === undefined || way.path === undefined || !this.data)
+            return;
+        let oldId = way.id;
+        let w = this.getWay(oldId);
+        w.originalId = w.id;
+        w.id = newId;
+        w.path.forEach((nx, j) => {
+            w.path[j] = this.getNode(nx.id);
+            let n = w.path[j];
+            n.ways.forEach((wid, i) => { if (wid === oldId)
+                n.ways[i] = newId; });
+            n.ways = [...new Set(n.ways)];
+        });
+        if (replaceLookup)
+            this.data.waysLookup[newId] = w;
+        delete this.data.waysLookup[oldId];
+        return w;
+    }
+    ;
+    getUntilFirstBranch(w, props) {
+        if (!w)
+            return;
+        const reverse = (props !== undefined) ? props.reverse : false;
+        const ignore = (props !== undefined) ? props.ignore : undefined;
+        let branch;
+        let path = w.path;
+        if (reverse) {
+            w.path = [...path];
+            w.path.reverse();
+            path = w.path;
+        }
+        let piBranch = this.getFirstBranch(w, ignore);
+        if (piBranch !== undefined) {
+            branch = { id: w.id, path: [] };
+            path.forEach((p, idx) => {
+                if (idx <= piBranch.idx)
+                    branch.path.push(p);
+            });
+        }
+        else {
+            branch = { id: w.id, path: w.path };
+        }
+        return branch;
+    }
+    logError(err, fn, args) {
+        const logInfo = args !== null && args !== void 0 ? args : {};
+        this.logger.logEvent(Object.assign(Object.assign({ message: 'Error', fn }, logInfo), { error: err.message, stack: err.stack }));
+    }
+}
+exports.MapArea = MapArea;

package/lib/maps/MapArea/consts.d.ts

@@ -0,0 +1,11 @@
+export declare const RADIUS_EARTH = 6378.1;
+export declare const DEFAULT_RADIUS = 1000;
+export declare const DEFAULT_MIN_WAYS = 70;
+export declare const DEFAULT_MAX_WAYS = 300;
+export declare const MAX_DISTANCE_FROM_PATH = 5;
+export declare const GET_WAYS_IN_AREA = "[out:json];way[highway](__boundary__);(._;>;);out geom;";
+export declare const DEFAULT_FILTER: string[];
+export declare const DEFAULT_POSITION: {
+    lat: number;
+    lng: number;
+};

package/lib/maps/MapArea/consts.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_POSITION = exports.DEFAULT_FILTER = exports.GET_WAYS_IN_AREA = exports.MAX_DISTANCE_FROM_PATH = exports.DEFAULT_MAX_WAYS = exports.DEFAULT_MIN_WAYS = exports.DEFAULT_RADIUS = exports.RADIUS_EARTH = void 0;
+exports.RADIUS_EARTH = 6378.1;
+exports.DEFAULT_RADIUS = 1000;
+exports.DEFAULT_MIN_WAYS = 70;
+exports.DEFAULT_MAX_WAYS = 300;
+exports.MAX_DISTANCE_FROM_PATH = 5;
+exports.GET_WAYS_IN_AREA = '[out:json];way[highway](__boundary__);(._;>;);out geom;';
+exports.DEFAULT_FILTER = ['construction', 'footway', 'service', 'pedestrian', 'path', 'cycleway', 'elevator', 'steps', 'track', 'escape', 'bus_guideway', 'busway', 'bridleway', 'corridor', 'via_ferrata'];
+exports.DEFAULT_POSITION = { lat: 26.68537966608196, lng: -80.03481961660725 };

package/lib/maps/MapArea/options.d.ts

@@ -0,0 +1,21 @@
+import { EventLogger } from "gd-eventlog";
+import { FreeRideContinuation, IMapArea, IMapAreaService, IncyclistNode, IncyclistWay, PathCrossingInfo, WayInfo } from "./types";
+export declare class OptionManager {
+    protected service: IMapAreaService;
+    protected map?: IMapArea;
+    protected logger: EventLogger;
+    constructor(service: IMapAreaService, map?: IMapArea);
+    setMap(map: IMapArea): void;
+    getStartOptions(way: IncyclistWay, crossing: PathCrossingInfo): Promise<Array<FreeRideContinuation>>;
+    getNextOptions(from?: WayInfo | FreeRideContinuation): Promise<Array<FreeRideContinuation>>;
+    protected checkOptionsOnDifferentWay(location: IncyclistNode, w: IncyclistWay, options: FreeRideContinuation[]): FreeRideContinuation[];
+    protected getOptionsFirstPoint(location: IncyclistNode, w: IncyclistWay, options: FreeRideContinuation[]): void;
+    protected getOptionsLastPoint(location: IncyclistNode, w: IncyclistWay, options: FreeRideContinuation[]): void;
+    protected getOptionsMiddle(location: IncyclistNode, w: IncyclistWay, options: FreeRideContinuation[]): void;
+    protected getOptionsRoundabout(location: IncyclistNode, w: IncyclistWay, options: FreeRideContinuation[]): any;
+    protected getWay(props: string | IncyclistWay): IncyclistWay;
+    protected getNode(props?: string | IncyclistNode): IncyclistNode;
+    getRemaining(partial: IncyclistWay): IncyclistWay;
+    getOptionsOnCurrentWay(location: IncyclistNode, way: IncyclistWay, options: Array<FreeRideContinuation>): Array<FreeRideContinuation>;
+    protected logError(err: Error, fn: string, args?: any): void;
+}