incyclist-services 1.3.19 → 1.3.21

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

@@ -0,0 +1,6 @@
+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;";

package/lib/maps/ways/consts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;';

package/lib/maps/ways/service.d.ts

@@ -0,0 +1,51 @@
+import { EventLogger } from "gd-eventlog";
+import { OverpassApi } from "../../api";
+import { LatLng } from "../../utils/geo";
+import { Boundary, FreeRideDataSet, IncyclistWaySplit, IncyclistWay, IncyclistNode } from "./types";
+export declare class MapAreaService {
+    protected static consts: {
+        DEFAULT_RADIUS: number;
+        DEFAULT_MIN_WAYS: number;
+        DEFAULT_MAX_WAYS: number;
+        MAX_DISTANCE_FROM_PATH: number;
+        GET_WAYS_IN_AREA: string;
+    };
+    protected static _instances: {};
+    static getInstance(id?: string): any;
+    protected overpass: OverpassApi;
+    protected logger: EventLogger;
+    protected minWays: number;
+    protected maxWays: number;
+    protected radius: number;
+    protected data: FreeRideDataSet;
+    protected boundary: Boundary;
+    protected location: IncyclistNode;
+    protected query: string;
+    protected queryLocation: IncyclistNode;
+    protected openmapData: JSON | string;
+    protected loaded: 'success' | 'failure' | 'unknown';
+    protected filter: any;
+    constructor(props?: any);
+    setLocation(location: any, reload: any, onLoaded: any): void;
+    splitAtFirstBranch(way: IncyclistWay): IncyclistWaySplit;
+    getNextOptions(way?: IncyclistWay, way1?: IncyclistWay, reload?: boolean, props?: {
+        mapReload: boolean;
+    }): Promise<unknown>;
+    isWithinBoundary(location: LatLng): boolean;
+    protected init(props: any): void;
+    protected load(callback: any): Promise<void>;
+    protected setData(openmapData: any, callback: any): void;
+    protected _getNextOptions(loc: any, way: any, way1: any): any[];
+    protected collectRoundabout(way: any): any[];
+    protected replaceWayID(way: IncyclistWay, newId: string, replaceLookup?: boolean): IncyclistWay;
+    protected checkRoundabouts(): void;
+    protected getWay(props: string | IncyclistWay): IncyclistWay;
+    protected getNode(props?: string | IncyclistNode): IncyclistNode;
+    protected copyWay(wayFrom: IncyclistWay, id?: string): {
+        w: IncyclistWay;
+        roundabout: boolean;
+    };
+    protected checkOptionsOnCurrentWay(location: IncyclistNode, way: IncyclistWay, options: any): void;
+    protected checkOptionsOnDifferentWay(location: any, w: any, options: any): any;
+}
+export declare const useMapArea: (id: any) => any;

package/lib/maps/ways/service.js

@@ -0,0 +1,561 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMapArea = exports.MapAreaService = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const api_1 = require("../../api");
+const clone_1 = __importDefault(require("../../utils/clone"));
+const utils_1 = require("./utils");
+const consts_1 = require("./consts");
+class MapAreaService {
+    static getInstance(id = 'default') {
+        if (!MapAreaService._instances[id])
+            MapAreaService._instances[id] = new MapAreaService();
+        return MapAreaService._instances[id];
+    }
+    constructor(props) {
+        this.loaded = 'unknown';
+        this.overpass = new api_1.OverpassApi();
+        this.logger = new gd_eventlog_1.EventLogger('MapArea');
+        this.init(props);
+    }
+    setLocation(location, reload, onLoaded) {
+        this.location = location;
+        if (location === undefined) {
+            if (onLoaded)
+                onLoaded('failure', this.data.ways, this.openmapData);
+            return;
+        }
+        if (reload) {
+            this.boundary = (0, utils_1.getBounds)(this.location.lat, this.location.lng, this.radius);
+            this.load(onLoaded);
+        }
+        else {
+            if (onLoaded)
+                onLoaded('success', this.data.ways, this.openmapData);
+        }
+    }
+    splitAtFirstBranch(way) {
+        if (way === undefined || way.path === undefined)
+            return;
+        let result = {
+            way: { id: way.id, path: [] },
+            branches: []
+        };
+        try {
+            let pointInfo = (0, utils_1.getFirstBranch)(way);
+            if (pointInfo !== undefined) {
+                let paths = (0, utils_1.splitAtPointInfo)(way, pointInfo);
+                result.way.path = paths[0];
+                let branch = { id: way.id, path: paths[1] };
+                if (branch.path.length > 1)
+                    result.branches.push(branch);
+                pointInfo.point.ways.forEach((wid) => {
+                    let w = (0, clone_1.default)(this.data.waysLookup[wid]);
+                    if (w !== undefined && w.id !== way.id) {
+                        if (w.path[0].id === pointInfo.point.id) {
+                            branch = (0, utils_1.getUntilFirstBranch)(w, { ignore: way.id });
+                            if (branch.path.length > 1)
+                                result.branches.push(branch);
+                        }
+                        else if (w.path[w.path.length - 1].id === pointInfo.point.id) {
+                            w.path.reverse();
+                            branch = (0, utils_1.getUntilFirstBranch)(w, { ignore: way.id });
+                            if (branch.path.length > 1)
+                                result.branches.push(branch);
+                        }
+                        else {
+                            let branches = (0, utils_1.splitAtPoint)(w, pointInfo.point);
+                            branch = (0, utils_1.getUntilFirstBranch)(branches[0], { ignore: way.id });
+                            if (branch.path.length > 1)
+                                result.branches.push(branch);
+                            branch = (0, utils_1.getUntilFirstBranch)(branches[1], { ignore: way.id });
+                            if (branch.path.length > 1)
+                                result.branches.push(branch);
+                        }
+                    }
+                });
+            }
+            else {
+                result.way.path = [...way.path];
+            }
+        }
+        catch (error) {
+            this.logger.logEvent({ message: 'error', fn: 'splitAtFirstBranch()', way, error: error.message, stack: error.stack });
+            result = undefined;
+        }
+        return result;
+    }
+    getNextOptions(way, way1 = undefined, reload = false, props) {
+        return new Promise((resolve, reject) => {
+            if (way === undefined || way.id === undefined || way.path === undefined || way.path.length < 1)
+                return reject({ retry: false, message: 'invalid arguments' });
+            let location = way.path[way.path.length - 1];
+            if (location.id === undefined) {
+                if (way.path.length > 1)
+                    location = way.path[way.path.length - 2];
+                else {
+                    return resolve([]);
+                }
+            }
+            let currentWay = { w: way, roundabout: false };
+            if (way.path[0].id === undefined) {
+                currentWay = this.copyWay(way);
+            }
+            if (props && props.mapReload === false) {
+                resolve(this._getNextOptions(location, currentWay, way1));
+            }
+            else {
+                this.setLocation(location, reload, (status, ways, data) => {
+                    if (status !== 'success') {
+                        reject({ retry: true, code: 1, message: 'could not load data' });
+                    }
+                    resolve(this._getNextOptions(location, currentWay, way1));
+                });
+            }
+        });
+    }
+    isWithinBoundary(location) {
+        return (0, utils_1.isWithinBoundary)(location, this.boundary);
+    }
+    init(props) {
+        this.minWays = consts_1.DEFAULT_MIN_WAYS;
+        this.maxWays = consts_1.DEFAULT_MAX_WAYS;
+        this.radius = consts_1.DEFAULT_RADIUS;
+        this.data = undefined;
+        if (props === undefined)
+            return;
+        if (props.onLoaded)
+            this.onLoaded = props.onLoaded;
+        if (props.minWays)
+            this.minWays = props.minWays;
+        if (props.maxWays)
+            this.maxWays = props.maxWays;
+        if (props.radius)
+            this.radius = props.radius;
+        if (props.filter)
+            this.filter = props.filter;
+        if (props.location) {
+            this.setLocation(props.location, true, this.onLoaded);
+        }
+    }
+    load(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const onLoaded = callback ? callback : this.onLoaded;
+            let ts, ts1;
+            try {
+                this.query = (0, utils_1.buildQuery)(consts_1.GET_WAYS_IN_AREA, this.boundary);
+                this.queryLocation = this.location;
+                const { id, lat, lng } = this.location;
+                this.logger.logEvent({ message: 'overpass query', query: this.query, location: { id, lat, lng }, radius: this.radius });
+                ts = Date.now();
+                let openmapData = yield this.overpass.query(this.query);
+                ts1 = Date.now();
+                this.logger.logEvent({ message: 'overpass query result', status: 'success', duration: (ts1 - ts) });
+                this.setData(openmapData, onLoaded);
+            }
+            catch (error) {
+                ts1 = Date.now();
+                this.logger.logEvent({ message: 'overpass query result', status: 'failure', error: { code: error.code, response: error.response }, duration: (ts1 - ts) });
+                if (onLoaded !== undefined)
+                    onLoaded('failure', (_a = this.data) === null || _a === void 0 ? void 0 : _a.ways, this.openmapData);
+            }
+        });
+    }
+    setData(openmapData, callback) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const onLoaded = callback ? callback : this.onLoaded;
+        let ts = Date.now();
+        this.data = (0, utils_1.parseMapData)(openmapData, this.filter);
+        let ts1 = Date.now();
+        this.logger.logEvent({ message: 'Parse', duration: (ts1 - ts),
+            ways: (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.ways.length) !== null && _b !== void 0 ? _b : 0,
+            nodes: Object.keys((_d = (_c = this.data) === null || _c === void 0 ? void 0 : _c.nodesLookup) !== null && _d !== void 0 ? _d : {}).length,
+            typeStats: (_e = this.data) === null || _e === void 0 ? void 0 : _e.typeStats
+        });
+        if (this.data !== undefined) {
+            this.openmapData = openmapData;
+            this.checkRoundabouts();
+            this.loaded = 'success';
+            if (((_f = this.data) === null || _f === void 0 ? void 0 : _f.ways.length) < this.minWays) {
+                if (((_g = this.data) === null || _g === void 0 ? void 0 : _g.ways.length) > 0) {
+                    let gap = this.minWays / ((_h = this.data) === null || _h === void 0 ? void 0 : _h.ways.length);
+                    this.radius = this.radius * Math.sqrt(gap);
+                }
+                else {
+                    this.radius = this.radius * 2;
+                }
+            }
+            else if (((_j = this.data) === null || _j === void 0 ? void 0 : _j.ways.length) > this.maxWays) {
+                let gap = ((_k = this.data) === null || _k === void 0 ? void 0 : _k.ways.length) / this.maxWays;
+                this.radius = this.radius / Math.sqrt(gap);
+            }
+        }
+        else {
+            this.loaded = 'failure';
+        }
+        if (onLoaded !== undefined) {
+            onLoaded(this.loaded, (_l = this.data) === null || _l === void 0 ? void 0 : _l.ways, this.openmapData);
+        }
+    }
+    _getNextOptions(loc, way, way1) {
+        let location = this.getNode(loc);
+        let options = [];
+        if (location !== undefined) {
+            location.ways.forEach((wid, idx) => {
+                if (wid === way.id) {
+                    this.checkOptionsOnCurrentWay(location, way, options);
+                }
+                else if (way1 !== undefined && wid === way1.id) {
+                }
+                else {
+                    let w = this.getWay(wid);
+                    options = this.checkOptionsOnDifferentWay(location, w, options);
+                }
+            });
+        }
+        return options;
+    }
+    collectRoundabout(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) => {
+            way.path.forEach((n, idx) => {
+                if (idx > 0) {
+                    n.ways.forEach(wid => {
+                        var _a;
+                        let w = (_a = this.data) === null || _a === void 0 ? void 0 : _a.waysLookup[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;
+    }
+    ;
+    replaceWayID(way, newId, replaceLookup = true) {
+        var _a;
+        if (way === undefined || newId === undefined || way.id === undefined || way.path === undefined || !this.data)
+            return;
+        let oldId = way.id;
+        let w = (_a = this.data) === null || _a === void 0 ? void 0 : _a.waysLookup[oldId];
+        w.originalId = w.id;
+        w.id = newId;
+        w.path.forEach((nx, j) => {
+            var _a;
+            w.path[j] = (_a = this.data) === null || _a === void 0 ? void 0 : _a.nodesLookup[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;
+    }
+    ;
+    checkRoundabouts() {
+        var _a;
+        let roundaboutsStrict = [];
+        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.collectRoundabout(way);
+                    let id = (0, utils_1.generateID)(ways);
+                    let found = roundaboutsStrict.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)
+                        roundaboutsStrict.push({ id, ways });
+                }
+                else if ((0, utils_1.isRoundabout)(way, false)) {
+                    roundaboutsImplicit.push(way);
+                }
+            });
+            this.logger.debug('_checkRoundabouts: found roundabouts:', roundaboutsStrict);
+            roundaboutsStrict.forEach(ri => {
+                var _a;
+                let originalNodes = [];
+                ri.ways.forEach((wid, i) => {
+                    var _a;
+                    let way = (_a = this.data) === null || _a === void 0 ? void 0 : _a.waysLookup[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) => {
+                    var _a;
+                    let way = (_a = this.data) === null || _a === void 0 ? void 0 : _a.waysLookup[wid];
+                    this.replaceWayID(way, ri.id, i === 0);
+                });
+                let roundabout = (_a = this.data) === null || _a === void 0 ? void 0 : _a.waysLookup[ri.id];
+                roundabout.path = [];
+                originalNodes.forEach(nid => {
+                    var _a;
+                    let node = (_a = this.data) === null || _a === void 0 ? void 0 : _a.nodesLookup[nid];
+                    roundabout.path.push(node);
+                });
+                roundabout.tags.roundabout = 'yes';
+            });
+            roundaboutsImplicit.forEach(roundabout => {
+                if (roundabout.tags === undefined)
+                    roundabout.tags = {};
+                roundabout.tags.roundabout = 'yes';
+            });
+        }
+        catch (error) {
+            this.logger.logEvent({ message: 'Error', error });
+        }
+    }
+    getWay(props) {
+        var _a, _b;
+        if (!props)
+            return;
+        if (typeof props === 'string') {
+            return (0, clone_1.default)((_a = this.data) === null || _a === void 0 ? void 0 : _a.waysLookup[props]);
+        }
+        if (props.id !== undefined)
+            return (0, clone_1.default)((_b = this.data) === null || _b === void 0 ? void 0 : _b.waysLookup[props.id]);
+    }
+    getNode(props) {
+        var _a, _b;
+        if (!props)
+            return this.location;
+        if (typeof props === 'string') {
+            return (0, clone_1.default)((_a = this.data) === null || _a === void 0 ? void 0 : _a.nodesLookup[props]);
+        }
+        if (typeof props === 'object' && props.id === undefined && props.lat !== undefined && props.lng !== undefined && props.ways !== undefined) {
+            return (0, clone_1.default)(props);
+        }
+        if (props.id !== undefined) {
+            return (0, clone_1.default)((_b = this.data) === null || _b === void 0 ? void 0 : _b.nodesLookup[props.id]);
+        }
+    }
+    copyWay(wayFrom, id) {
+        let w;
+        w = (id === undefined) ? this.getWay(wayFrom) : this.getWay(id);
+        let path = w.path;
+        let roundabout = (0, utils_1.isRoundabout)(w);
+        if (!roundabout && wayFrom !== undefined && wayFrom.id === w.id) {
+            let idxPrev = undefined;
+            let idx = undefined;
+            let point = wayFrom.path[wayFrom.path.length - 1];
+            let prev = wayFrom.path[wayFrom.path.length - 2];
+            path.forEach((p, i) => {
+                if (idx === undefined || idxPrev === undefined) {
+                    if ((0, utils_1.pointEquals)(p, point))
+                        idx = i;
+                    if ((0, utils_1.pointEquals)(p, prev))
+                        idxPrev = i;
+                }
+            });
+            if (idx !== undefined && idxPrev !== undefined) {
+                if (idxPrev < idx)
+                    w.path = path.filter((n, i) => i >= idx);
+                if (idxPrev > idx) {
+                    w.path = path.filter((n, i) => i <= idx);
+                    w.path.reverse();
+                }
+            }
+        }
+        return { w, roundabout };
+    }
+    checkOptionsOnCurrentWay(location, way, options) {
+        try {
+            if (way.path.length > 1) {
+                let prev = way.path[way.path.length - 2];
+                let { w, roundabout } = this.copyWay(way);
+                if (roundabout) {
+                    let branches = (0, utils_1.splitAtPoint)(w, location);
+                    branches.forEach(b => {
+                        if (b.path.length > 1 && b.path[1].id !== prev.id) {
+                            options.push(b);
+                        }
+                    });
+                }
+                else {
+                    if (w.path.length > 1) {
+                        let result = this.splitAtFirstBranch(w);
+                        options.push(result.way);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    checkOptionsOnDifferentWay(location, w, options) {
+        if (!w || !w.path || !location)
+            return;
+        let result;
+        let roundabout = (0, utils_1.isRoundabout)(w);
+        let self = this;
+        if (!roundabout) {
+            if (w.path[0].id === location.id) {
+                result = this.splitAtFirstBranch(w);
+                let expand = false;
+                if (result.way.path.length === w.path.length) {
+                    const pLast = w.path[w.path.length - 1];
+                    if (pLast.ways.length === 2) {
+                        const wIdNext = pLast.ways.find(wid => wid !== w.id);
+                        const wNext = this.getWay({ id: wIdNext });
+                        if (!(0, utils_1.isRoundabout)(wNext)) {
+                            const pNextStart = wNext.path[0];
+                            const pNextEnd = wNext.path[wNext.path.length - 1];
+                            if (pNextStart.id === pLast.id) {
+                                expand = true;
+                                const segment = this.splitAtFirstBranch(wNext);
+                                const combined = {
+                                    id: segment.way.id,
+                                    path: w.path.concat(segment.way.path.slice(1))
+                                };
+                                options.push(combined);
+                            }
+                            else if (pNextEnd.id === pLast.id) {
+                                const wReverse = this.copyWay(wNext);
+                                if (wReverse && wReverse.path) {
+                                    wReverse.path = wReverse.path.reverse();
+                                    const segment = this.splitAtFirstBranch(wNext);
+                                    const combined = {
+                                        id: segment.way.id,
+                                        path: w.path.concat(segment.way.path.slice(1))
+                                    };
+                                    options.push(combined);
+                                }
+                                else {
+                                    console.log(' ~~~~ unexpected', wNext, wReverse);
+                                }
+                            }
+                            else {
+                                const idxSplit = wNext.path.findIndex((p) => p.id === pLast.id);
+                                if (idxSplit !== 1) {
+                                    const nextPaths = splitAtIndex(wNext, idxSplit);
+                                    nextPaths.forEach((p) => {
+                                        if (p[0].ways.find(wid => wid === w.id)) {
+                                            expand = true;
+                                            const wFull = {
+                                                id: wIdNext,
+                                                path: p.slice(1)
+                                            };
+                                            const segment = this.splitAtFirstBranch(wFull);
+                                            const combined = {
+                                                id: segment.way.id,
+                                                path: w.path.concat(segment.way.path.slice(1))
+                                            };
+                                            options.push(combined);
+                                        }
+                                        else if (p[p.length - 1].ways.find(wid => wid === w.id)) {
+                                            expand = true;
+                                            const wFull = {
+                                                id: wIdNext,
+                                                path: p.reverse()
+                                            };
+                                            const segment = this.splitAtFirstBranch(wFull);
+                                            const combined = {
+                                                id: segment.way.id,
+                                                path: w.path.concat(segment.way.path.slice(1))
+                                            };
+                                            options.push(combined);
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                if (!expand)
+                    options.push(result.way);
+            }
+            else if (w.path[w.path.length - 1].id === location.id) {
+                w.path.reverse();
+                result = this.splitAtFirstBranch(w);
+                if ((0, utils_1.isOneWay)(w))
+                    result.way.onewayReverse = true;
+                options.push(result.way);
+            }
+            else {
+                let ways = (0, utils_1.splitAtPoint)(w, location);
+                if (!ways[0].onewayReverse) {
+                    result = this.splitAtFirstBranch(ways[0]);
+                    options.push(result.way);
+                }
+                if (!ways[1].onewayReverse) {
+                    result = this.splitAtFirstBranch(ways[1]);
+                    options.push(result.way);
+                }
+            }
+        }
+        else {
+            let r = (0, utils_1.splitAtPoint)(w, location);
+            if (!r || r.length === 0)
+                return;
+            let path = [];
+            r[0].path.forEach((p, idx) => {
+                if (idx === 0) {
+                    path.push(p);
+                    return;
+                }
+                if (p.ways.length > 1) {
+                    p.ways.forEach(owid => {
+                        if (owid !== w.id) {
+                            let ow = (0, clone_1.default)(this.waysLookup[owid]);
+                            if (ow !== undefined) {
+                                if (!(0, utils_1.isAllowed)(ow, p))
+                                    return;
+                                if (ow.path[ow.path.length - 1].id === p.id)
+                                    ow.path.reverse();
+                                let optPath1 = self.splitAtFirstBranch(ow);
+                                let optPath = [...path];
+                                optPath.push(...optPath1.way.path);
+                                let o = {
+                                    roundabout: w.id,
+                                    id: ow.id,
+                                    path: optPath
+                                };
+                                options.push(o);
+                            }
+                        }
+                    });
+                }
+                path.push(p);
+            });
+        }
+        return (0, utils_1.removeDuplicates)(options);
+    }
+}
+exports.MapAreaService = MapAreaService;
+MapAreaService.consts = { DEFAULT_RADIUS: consts_1.DEFAULT_RADIUS, DEFAULT_MIN_WAYS: consts_1.DEFAULT_MIN_WAYS, DEFAULT_MAX_WAYS: consts_1.DEFAULT_MAX_WAYS, MAX_DISTANCE_FROM_PATH: consts_1.MAX_DISTANCE_FROM_PATH, GET_WAYS_IN_AREA: consts_1.GET_WAYS_IN_AREA };
+MapAreaService._instances = {};
+const useMapArea = (id) => MapAreaService.getInstance(id);
+exports.useMapArea = useMapArea;