@wemap/geo 4.0.13 → 5.0.0

package/src/graph/ItineraryInfo.js

@@ -1,29 +0,0 @@
-import Projection from './Projection.js';
-import Step from './Step.js';
-
-class ItineraryInfo {
-
-    /** @type {Step} */
-    nextStep;
-
-    /** @type {Step} */
-    previousStep;
-
-    /** @type {Projection} */
-    projection;
-
-    /** @type {number} */
-    traveledDistance;
-
-    /** @type {number} */
-    traveledPercentage;
-
-    /** @type {number} */
-    remainingDistance;
-
-    /** @type {number} */
-    remainingPercentage;
-
-}
-
-export default ItineraryInfo;

package/src/graph/LevelChange.js

@@ -1,43 +0,0 @@
-import Level from '../coordinates/Level.js';
-import Network from './Network.js';
-import Node from './Node.js';
-
-class LevelChange {
-
-    /** @type {String} [up|down] */
-    direction;
-
-    /** @type {number} [-2, -1, 1, ...] */
-    difference;
-
-    /** @type {string} [elevator|conveyor|stairs] */
-    type = null;
-
-    /**
-     * @param {Node} firstNode
-     * @param {Node} secondNode
-     * @returns {LevelChange}
-     */
-    static fromTwoNodes(firstNode, secondNode) {
-
-        const levelChange = new LevelChange();
-
-        const edge = Network.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
-
-        if (edge.isElevator) {
-            levelChange.type = 'elevator';
-        } else if (edge.isConveying) {
-            levelChange.type = 'conveyor';
-        } else if (edge.isStairs) {
-            levelChange.type = 'stairs';
-        }
-
-        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
-        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
-
-        return levelChange;
-    }
-
-}
-
-export default LevelChange;

package/src/graph/Node.spec.js

@@ -1,227 +0,0 @@
-/* eslint-disable no-new */
-import chai from 'chai';
-
-import Logger from '@wemap/logger';
-
-import Coordinates from '../coordinates/Coordinates.js';
-import Level from '../coordinates/Level.js';
-
-import Node from './Node.js';
-import Edge from './Edge.js';
-
-Logger.enable(false);
-
-const { expect } = chai;
-
-describe('Node', () => {
-
-    it('creation', () => {
-
-        expect(() => new Node()).throw(Error);
-        expect(() => new Node({
-            lat: 45,
-            lng: 5
-        })).throw(Error);
-        expect(() => new Node(new Coordinates(0, 0))).not.throw(Error);
-
-    });
-
-
-    const pos1 = new Coordinates(45, 5);
-    const pos2 = new Coordinates(46, 5);
-    const node1 = new Node(pos1);
-    const node2 = new Node(pos2);
-
-    it('distanceTo', () => {
-        expect(node1.distanceTo(node2)).equals(pos1.distanceTo(pos2));
-    });
-
-    it('bearingTo', () => {
-        expect(node1.bearingTo(node2)).equals(pos1.bearingTo(pos2));
-    });
-
-    it('equalsTo', () => {
-        expect(node1.equalsTo(node2)).equals(pos1.equalsTo(pos2));
-
-        const fullNode = new Node(pos1);
-        fullNode.name = 'foobar';
-
-        const testedNode = new Node(pos1);
-
-        expect(testedNode.equalsTo(node1)).true;
-        expect(testedNode.equalsTo(fullNode)).false;
-
-        testedNode.name = 'foobar';
-        expect(testedNode.equalsTo(node1)).false;
-        expect(testedNode.equalsTo(fullNode)).true;
-    });
-
-    it('clone', () => {
-
-        const node = new Node(pos1);
-
-        let nodeBis = node.clone();
-        expect(nodeBis.coords.equalsTo(node.coords)).true;
-        expect(nodeBis.name).equal(node.name);
-
-        node.name = 'foobar';
-        nodeBis = node.clone();
-        expect(nodeBis.coords.equalsTo(node.coords)).true;
-        expect(nodeBis.name).equal(node.name);
-    });
-
-    it('toJson / fromJson', () => {
-
-        const node = new Node(pos1);
-
-        let jsonNode = node.toJson();
-        expect(jsonNode.coords).deep.equals([45, 5]);
-        expect(jsonNode.name).is.undefined;
-
-        let nodeBis = Node.fromJson(jsonNode);
-        expect(nodeBis.coords.equalsTo(node.coords)).true;
-        expect(nodeBis.name).equal(node.name);
-
-        node.name = 'foobar';
-
-        jsonNode = node.toJson();
-        expect(jsonNode.coords).deep.equals([45, 5]);
-        expect(jsonNode.name).equal('foobar');
-
-        nodeBis = Node.fromJson(jsonNode);
-        expect(nodeBis.coords.equalsTo(node.coords)).true;
-        expect(nodeBis.name).equal(node.name);
-    });
-
-    // eslint-disable-next-line max-statements
-    it('generateNodesLevels', () => {
-
-        const cleanNodes = count => [...Array(count)].map((_ignore, idx) => new Node(new Coordinates(0, 0), 'n' + idx));
-        const cleanNodesWithAdjEdges = (...levelEdges) => {
-            const _nodes = cleanNodes(levelEdges.length + 1);
-            levelEdges.forEach((level, idx) => new Edge(_nodes[0], _nodes[idx + 1], level));
-            return _nodes;
-        };
-
-        let nodes;
-
-        /**
-         * Simple case with only adjacent nodes
-         */
-
-        nodes = cleanNodesWithAdjEdges(new Level(1), new Level(0));
-        expect(Node.generateNodesLevels(nodes)).false;
-        expect(nodes[0].coords.level).is.null;
-
-        nodes = cleanNodesWithAdjEdges(new Level(1), new Level(1));
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
-
-        nodes = cleanNodesWithAdjEdges(new Level(1), new Level(1, 2));
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
-
-        nodes = cleanNodesWithAdjEdges(new Level(0, 1), new Level(1, 2));
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
-
-        nodes = cleanNodesWithAdjEdges(new Level(0, 1));
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(0, 1))).true;
-
-        /**
-         * More complex cases with no adjacent edges
-         */
-
-        nodes = cleanNodes(4);
-        new Edge(nodes[0], nodes[1], new Level(1), 'e0');
-        new Edge(nodes[1], nodes[2], new Level(1, 2), 'e1');
-        new Edge(nodes[2], nodes[3], new Level(1, 2), 'e2');
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[1].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[2].coords.level, new Level(1, 2))).true;
-        expect(Level.equalsTo(nodes[3].coords.level, new Level(2))).true;
-
-
-        nodes = cleanNodes(5);
-        new Edge(nodes[0], nodes[1], new Level(1), 'e0');
-        new Edge(nodes[1], nodes[2], new Level(1, 2), 'e1');
-        new Edge(nodes[2], nodes[3], new Level(1, 2), 'e2');
-        new Edge(nodes[2], nodes[4], null, 'e3');
-        expect(Node.generateNodesLevels(nodes)).true;
-
-
-        nodes = cleanNodes(4);
-        new Edge(nodes[0], nodes[1], new Level(1), 'e0');
-        new Edge(nodes[1], nodes[2], new Level(0, 1), 'e1');
-        new Edge(nodes[2], nodes[3], new Level(0, 1), 'e2');
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[1].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[2].coords.level, new Level(0, 1))).true;
-        expect(Level.equalsTo(nodes[3].coords.level, new Level(0))).true;
-
-
-        nodes = cleanNodes(4);
-        new Edge(nodes[0], nodes[1], new Level(1), 'e0');
-        new Edge(nodes[1], nodes[2], new Level(1, 2), 'e1');
-        new Edge(nodes[2], nodes[3], new Level(1, 2), 'e2');
-        new Edge(nodes[1], nodes[3], new Level(1), 'e3');
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[1].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[2].coords.level, new Level(2))).true;
-        expect(Level.equalsTo(nodes[3].coords.level, new Level(1))).true;
-
-
-        nodes = cleanNodes(4);
-        new Edge(nodes[0], nodes[1], new Level(1), 'e0');
-        new Edge(nodes[1], nodes[2], new Level(0, 1), 'e1');
-        new Edge(nodes[2], nodes[3], new Level(0, 1), 'e2');
-        new Edge(nodes[1], nodes[3], new Level(1), 'e3');
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[1].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[2].coords.level, new Level(0))).true;
-        expect(Level.equalsTo(nodes[3].coords.level, new Level(1))).true;
-
-
-        nodes = cleanNodes(6);
-        new Edge(nodes[0], nodes[1], new Level(1), 'e0');
-        new Edge(nodes[1], nodes[2], new Level(1, 2), 'e1');
-        new Edge(nodes[2], nodes[3], new Level(1, 2), 'e2');
-        new Edge(nodes[2], nodes[4], new Level(1, 2), 'e3');
-        new Edge(nodes[4], nodes[5], new Level(2), 'e4');
-        expect(Node.generateNodesLevels(nodes)).false;
-
-
-        nodes = cleanNodes(5);
-        new Edge(nodes[0], nodes[1], new Level(1, 2));
-        new Edge(nodes[1], nodes[2], new Level(1, 2));
-        new Edge(nodes[2], nodes[3], new Level(1, 2));
-        new Edge(nodes[3], nodes[4], new Level(1));
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, new Level(2))).true;
-        expect(Level.equalsTo(nodes[1].coords.level, new Level(1, 2))).true;
-        expect(Level.equalsTo(nodes[2].coords.level, new Level(1, 2))).true;
-        expect(Level.equalsTo(nodes[3].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[4].coords.level, new Level(1))).true;
-
-
-        nodes = cleanNodes(6);
-        new Edge(nodes[0], nodes[1], new Level(0), 'e0');
-        new Edge(nodes[1], nodes[2], new Level(0, 1), 'e1');
-        new Edge(nodes[2], nodes[3], new Level(0, 1), 'e2');
-        new Edge(nodes[3], nodes[4], new Level(0, 1), 'e3');
-        new Edge(nodes[4], nodes[5], new Level(1), 'e4');
-        expect(Node.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[1].coords.level, new Level(0))).true;
-        expect(Level.equalsTo(nodes[1].coords.level, new Level(0))).true;
-        expect(Level.equalsTo(nodes[2].coords.level, new Level(0, 1))).true;
-        expect(Level.equalsTo(nodes[3].coords.level, new Level(0, 1))).true;
-        expect(Level.equalsTo(nodes[4].coords.level, new Level(1))).true;
-        expect(Level.equalsTo(nodes[5].coords.level, new Level(1))).true;
-    });
-
-});

package/src/graph/Step.js

@@ -1,99 +0,0 @@
-import Coordinates from '../coordinates/Coordinates.js';
-
-import Edge from './Edge.js';
-import LevelChange from './LevelChange.js';
-import Node from './Node.js';
-import { getDurationFromLength } from './Utils.js';
-
-class Step {
-
-    /** @type {number} */
-    number;
-
-    /** @type {Node[]} */
-    nodes = [];
-
-    /** @type {Edge[]} */
-    edges = [];
-
-    /** @type {number} */
-    angle;
-
-    /** @type {number} */
-    previousBearing;
-
-    /** @type {number} */
-    nextBearing;
-
-    /** @type {boolean} */
-    firstStep = false;
-
-    /** @type {boolean} */
-    lastStep = false;
-
-    /** @type {LevelChange} */
-    levelChange = null;
-
-    /** @type {number} */
-    _length = 0;
-
-
-    /**
-     * @param {object} obj
-     */
-    constructor(obj) {
-        if (typeof obj === 'object') {
-            Object.assign(this, obj);
-        }
-    }
-
-    /** @type {Node} */
-    get node() {
-        return this.nodes[0];
-    }
-
-    /** @type {Edge} */
-    get nextEdge() {
-        if (this.edges.length === 0) {
-            return null;
-        }
-        return this.edges[0];
-    }
-
-    /**
-     * Get route length
-     * @type {number}
-     */
-    get length() {
-        if (!this._length) {
-            this._length = this.edges.reduce((acc, edge) => acc + edge.length, 0);
-        }
-        return this._length;
-    }
-
-    /**
-     * Get route duration with default speed
-     * @type {number}
-     */
-    get duration() {
-        return this.getDuration();
-    }
-
-    /**
-     * Get route duration
-     * @param {number} speed in km/h
-     */
-    getDuration(speed) {
-        return getDurationFromLength(this.length, speed);
-    }
-
-    /**
-     * Get step location
-     * @type {!Coordinates}
-     */
-    get location() {
-        return this.nodes[0].coords;
-    }
-}
-
-export default Step;

package/src/graph/StepsGeneration.js

@@ -1,119 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-import {
-    diffAngle, deg2rad
-} from '@wemap/maths';
-
-import Coordinates from '../coordinates/Coordinates.js';
-import Itinerary from './Itinerary.js';
-import LevelChange from './LevelChange.js';
-
-import Step from './Step.js';
-
-const SKIP_STEP_ANGLE_MAX = deg2rad(20);
-
-class StepsGeneration {
-
-    /**
-     * @param {Itinerary} itinerary
-     * @returns {object}
-     */
-    static fromItinerary(itinerary) {
-
-        const steps = [];
-        const nextStepsIndexes = [];
-
-        let indexOfCurrentStep;
-        let numberOfNodesToFill;
-
-        let currentStep, previousStep;
-        let previousBearing = itinerary.start.bearingTo(itinerary.nodes[0].coords);
-
-        for (let i = 0; i < itinerary.nodes.length - 1; i++) {
-
-            const isFirstStep = !currentStep;
-
-            const node = itinerary.nodes[i];
-            const nextNode = itinerary.nodes[i + 1];
-            const edge = itinerary.edges[i];
-
-            const bearing = edge.bearing + (edge.node1 !== node ? Math.PI : 0);
-            const angle = diffAngle(previousBearing, bearing + Math.PI);
-
-            if (!isFirstStep) {
-                currentStep.nodes.push(node);
-            }
-
-            let splitByAngle = Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
-
-            const splitByLevel = edge.level && edge.level.isRange
-                && node.coords.level && !node.coords.level.isRange;
-            splitByAngle = splitByAngle && !(node.coords.level && node.coords.level.isRange);
-
-            const splitStepCondition = splitByAngle || splitByLevel;
-
-            // New step creation
-            if (isFirstStep || splitStepCondition || node.subwayEntrance) {
-
-                previousStep = currentStep;
-
-                currentStep = new Step();
-                currentStep.number = steps.length + 1;
-                currentStep.angle = angle;
-                currentStep.previousBearing = previousBearing;
-                currentStep.nextBearing = bearing;
-
-                if (splitByLevel) {
-                    currentStep.levelChange = LevelChange.fromTwoNodes(node, nextNode);
-                }
-
-                currentStep.nodes.push(node);
-                steps.push(currentStep);
-
-                if (!previousStep) {
-                    currentStep.firstStep = true;
-                }
-
-                indexOfCurrentStep = steps.length - 1;
-                numberOfNodesToFill = previousStep ? previousStep.nodes.length - 1 : 1;
-                for (let j = 0; j < numberOfNodesToFill; j++) {
-                    nextStepsIndexes.push(indexOfCurrentStep);
-                }
-            }
-
-            currentStep.edges.push(edge);
-
-            if (i === itinerary.nodes.length - 2) {
-                currentStep.nodes.push(nextNode);
-            }
-
-            previousBearing = bearing;
-        }
-
-        const lastNode = itinerary.nodes[itinerary.nodes.length - 1];
-        const lastStep = new Step();
-        lastStep.number = steps.length + 1;
-        lastStep._length = 0;
-        lastStep.previousBearing = previousBearing;
-        if (!Coordinates.equalsTo(lastNode.coords, itinerary.end)) {
-            lastStep.nextBearing = lastNode.coords.bearingTo(itinerary.end);
-            lastStep.angle = diffAngle(lastStep.previousBearing, lastStep.nextBearing + Math.PI);
-        }
-        lastStep.lastStep = true;
-        lastStep.nodes.push(lastNode);
-        steps.push(lastStep);
-
-        indexOfCurrentStep = steps.length - 1;
-        numberOfNodesToFill = itinerary.nodes.length - nextStepsIndexes.length;
-        for (let j = 0; j < numberOfNodesToFill; j++) {
-            nextStepsIndexes.push(indexOfCurrentStep);
-        }
-
-        return {
-            steps,
-            nextStepsIndexes
-        };
-    }
-
-}
-export default StepsGeneration;

package/src/graph/Utils.js

@@ -1,7 +0,0 @@
-/**
- * Get route duration
- * @param {Number} speed in km/h
- */
-export function getDurationFromLength(length, speed = 5) {
-    return length / (speed * 1000 / 3600);
-}