@furkot/directions 1.5.1

package/lib/service/status.js

@@ -0,0 +1,6 @@
+module.exports = {
+  success: 'success', // success
+  failure: 'failure', // ultimate failure
+  error: 'error', // temporary error
+  empty: 'empty' // no result
+};

package/lib/service/util.js

@@ -0,0 +1,101 @@
+const LatLon = require('geodesy/latlon-spherical');
+const polyline = require('@pirxpilot/google-polyline');
+
+module.exports = {
+  concat,
+  decode,
+  defaults,
+  distance,
+  indexAt,
+  isFuture,
+  join,
+  last,
+  metersInKm: 1000,
+  metersInMile: 1609.34,
+  split2object,
+  splitPoints
+};
+
+function concat(result, path) {
+  if (path) {
+    Array.prototype.push.apply(result, path);
+  }
+  return result;
+}
+
+function decode(poly, factor) {
+  return poly && polyline.decode(poly, factor);
+}
+
+function defaults(obj, source) {
+  return Object.assign({}, source, obj);
+}
+
+function toLatLon(p) {
+  return new LatLon(p[1], p[0]);
+}
+
+function distance(p1, p2) {
+  return toLatLon(p1).distanceTo(toLatLon(p2));
+}
+
+function indexAt(path, distance) {
+  let index = 1;
+  let p1 = toLatLon(path[0]);
+  let d = 0;
+  let p2;
+  while (index < path.length) {
+    p2 = toLatLon(path[index]);
+    d += p1.distanceTo(p2);
+    if (d > distance) {
+      break;
+    }
+    p1 = p2;
+    index += 1;
+  }
+  return index;
+}
+
+function isFuture(time) {
+  time = time && Date.parse(time);
+  return time && time >= Date.now();
+}
+
+// like normal join but with optional filter fn
+function join(arr, conn, fn) {
+  fn = fn || function (it) { return it; };
+  return arr.filter(fn).join(conn);
+}
+
+function last(arr) {
+  return arr[arr.length - 1];
+}
+
+function split2object(str, conn, obj) {
+  return str.split(conn || '-').reduce(function (result, word) {
+    result[word] = word;
+    return result;
+  }, obj || {});
+}
+
+function splitPoints(query, maxPoints) {
+  let i;
+  let segments;
+  if (!(query.points && query.points.length > 1)) {
+    return;
+  }
+  if (query.points.length <= maxPoints) {
+    return query;
+  }
+  segments = [];
+  for (i = 0; i < query.points.length - 1; i += maxPoints - 1) {
+    segments.push(defaults({
+      points: query.points.slice(i, i + maxPoints),
+      stats: []
+    }, query));
+  }
+  if (last(segments).points.length === 1) {
+    last(segments).points.unshift(segments[segments.length - 2].points.pop());
+  }
+  return segments;
+}

package/lib/service/valhalla/index.js

@@ -0,0 +1,230 @@
+// https://github.com/valhalla/valhalla-docs
+
+const LatLon = require('geodesy/latlon-spherical');
+const { pathType, travelMode } = require("../../model");
+const status = require('../status');
+const util = require('../util');
+
+module.exports = init;
+
+const units = {
+  km: 'kilometers',
+  m: 'miles'
+};
+const costing = {
+  1: 'bicycle',
+  2: 'pedestrian',
+  5: 'truck'
+};
+const defaultCosting = 'auto';
+const costingOptions = {
+  5: {
+    // default restriction for trucks/RVs
+    hazmat: true
+  }
+};
+const minSpeed = 15 * 1000 / 3600; // bump speed when it is absurdly low
+const turnDistance = 100; // don't adjust speed of turns
+
+const maneuver = {
+  ferryEnter: 28,
+  ferryExit: 29
+};
+
+function prepareWaypoint(p) {
+  // waypoint format is { lat, lon, type } where type is either 'break' (default) or 'through'
+  return {
+    lon: p[0],
+    lat: p[1],
+    type: 'break'
+  };
+}
+
+function extractSegment(result, {
+  type,
+  begin_shape_index,
+  end_shape_index,
+  instruction,
+  length,
+  time,
+  rough,
+  travel_mode
+}) {
+  const { directions: { segments, routes }, unitMultiplier, path } = result;
+  const distance = Math.round((length || 0) * unitMultiplier);
+  let duration = time;
+  // for some reason Valhalla calculates absurdly low speed on some dirt roads
+  if (rough && duration && travel_mode === 'drive' && distance > turnDistance && distance / duration < minSpeed) {
+    duration = Math.round(distance / minSpeed);
+  }
+  result.legDuration += duration;
+  const seg = {
+    duration,
+    distance,
+    path: path && path.slice(begin_shape_index, end_shape_index),
+    instructions: instruction
+  };
+  if (type === maneuver.ferryExit) {
+    if (result.ferry) {
+      delete result.ferry;
+    } else if (segments.length) {
+      // route started on the ferry
+      util.last(segments).mode = travelMode.ferry;
+      util.last(routes).ferry = true;
+    }
+  } else if (type === maneuver.ferryEnter || result.ferry) {
+    seg.mode = travelMode.ferry;
+    result.ferry = util.last(routes).ferry = true;
+  }
+  segments.push(seg);
+  return result;
+}
+
+function extractDirections(result, leg) {
+  const { directions } = result;
+  result.path = util.decode(leg.shape, { factor: 1e6 });
+  const route = {
+    duration: (leg.summary && leg.summary.time) || 0,
+    distance: Math.round(((leg.summary && leg.summary.length) || 0) * result.unitMultiplier)
+  };
+  if (result.fullPath) {
+    route.path = result.path;
+  }
+  if (directions.segments) {
+    route.segmentIndex = directions.segments.length;
+  }
+  directions.routes.push(route);
+  if (directions.segments && leg.maneuvers) {
+    result.legDuration = 0;
+    leg.maneuvers.reduce(extractSegment, result);
+    route.duration = result.legDuration;
+    if (directions.segments.length) {
+      util.last(directions.segments).path.push(util.last(result.path));
+    }
+  }
+  return result;
+}
+
+function toLatLon(p) {
+  return new LatLon(p.lat, p.lon);
+}
+
+function minDistance(locations, units) {
+  units = units === 'miles' ? util.metersInMile : util.metersInKm;
+  return 0.9 * toLatLon(locations[0]).distanceTo(toLatLon(util.last(locations))) / units;
+}
+
+function getStatus(err, response) {
+  let st = response && response.status_code;
+  if (!response) {
+    return;
+  }
+  // 403 Forbidden, 429 Too Many Requests
+  if (st === 403 || st === 429) {
+    // we exceeded the limit
+    return status.failure;
+  }
+  if (st === 400) {
+    // no route
+    return status.empty;
+  }
+  st = response.trip && response.trip.status;
+  if (st === 0) {
+    if (response.trip.legs && response.trip.legs.length &&
+      // make sure points are not too far from roads
+      response.trip.summary.length > minDistance(response.trip.locations, response.trip.units)) {
+      return status.success;
+    }
+    delete response.trip.legs;
+    return status.empty;
+  }
+}
+
+function vehicleSize(query, options) {
+  const { mode, vehicle } = query;
+  if (!(vehicle && mode === 5)) {
+    return;
+  }
+  Object.assign(options, vehicle);
+}
+
+function init(options) {
+
+  function prepareRequest(query) {
+    let req = {
+      locations: query.points.map(prepareWaypoint),
+      costing: costing[query.mode] || defaultCosting,
+      costing_options: {},
+      directions_options: {
+        units: units[query.units] || units.m
+      }
+    };
+    req.costing_options[req.costing] = Object.assign({}, costingOptions[query.mode]);
+    if (query.avoidTolls) {
+      req.costing_options[req.costing].toll_booth_penalty = 1000.0;
+      req.costing_options[req.costing].use_tolls = 0;
+    } else {
+      req.costing_options[req.costing].use_tolls = 1;
+    }
+    if (query.avoidHighways) {
+      req.costing_options[req.costing].use_highways = 0;
+    } else {
+      req.costing_options[req.costing].use_highways = 1;
+    }
+    vehicleSize(query, req.costing_options[req.costing]);
+
+    if (query.begin) {
+      req.date_time = {
+        type: 1,
+        value: query.begin
+      };
+    }
+
+    req = {
+      json: JSON.stringify(req)
+    };
+    if (options.valhalla_key) {
+      req.api_key = options.valhalla_key;
+    }
+    return req;
+  }
+
+  function processResponse(response, query) {
+    const trip = response && response.trip;
+    if (trip && trip.legs && trip.legs.length) {
+      const directions = {
+        query,
+        provider: options.name,
+        routes: []
+      };
+      if (query.turnbyturn || query.path === pathType.smooth || query.path === pathType.coarse) {
+        directions.segments = [];
+      }
+      const fullPath = query.path === pathType.full;
+      trip.legs.reduce(extractDirections, {
+        directions,
+        unitMultiplier: query.units !== 'km' ? util.metersInMile : util.metersInKm,
+        fullPath
+      });
+      if (fullPath) {
+        // path is already prepared - no need to do it again from segments
+        directions.pathReady = true;
+      }
+      return directions;
+    }
+  }
+
+  options = util.defaults(options, {
+    // Mapzen says 2 request per second: https://mapzen.com/documentation/overview/#mapzen-turn-by-turn
+    // but if we get below 560 millis it starts returning 429 (Too Many Requests)
+    interval: 560,
+    // max 20 points for automobile and 50 for bicycle and pedestrian
+    maxPoints: options.valhalla_max_points || 2,
+    url: options.valhalla_url,
+    body: true,
+    status: getStatus,
+    prepareRequest,
+    processResponse
+  });
+  return require('..')(options);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@furkot/directions",
+  "version": "1.5.1",
+  "description": "Directions service for Furkot",
+  "author": {
+    "name": "Damian Krzeminski",
+    "email": "pirxpilot@furkot.com",
+    "url": "https://pirxpilot.me"
+  },
+  "repository": "furkot/directions",
+  "license": "MIT",
+  "keywords": [
+    "furkot-directions",
+    "furkot",
+    "directions"
+  ],
+  "dependencies": {
+    "@pirxpilot/google-polyline": "^3.0.0",
+    "debug": "~2 || ~3 || ~4",
+    "fetchagent": "~2",
+    "geodesy": "^1.1.1",
+    "limiter-component": "^1.0.0",
+    "run-series": "^1.1.4",
+    "run-waterfall-until": "~1",
+    "vis-why": "^1.2.2"
+  },
+  "devDependencies": {
+    "jshint": "~2",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.clonedeepwith": "^4.5.0",
+    "mocha": "~10",
+    "should": "~13",
+    "sinon": "~14"
+  },
+  "scripts": {
+    "test": "make check"
+  },
+  "files": [
+    "index.js",
+    "lib"
+  ]
+}