@furkot/directions 2.1.1 → 2.1.3

package/Readme.md

@@ -28,7 +28,7 @@ MIT © [Damian Krzeminski](https://pirxpilot.me)
 [npm-url]: https://npmjs.org/package/@furkot/directions
 
 [build-url]: https://github.com/furkot/directions/actions/workflows/check.yaml
-[build-image]: https://img.shields.io/github/workflow/status/furkot/directions/check
+[build-image]: https://img.shields.io/github/actions/workflow/status/furkot/directions/check.yaml?branch=main
 
 [deps-image]: https://img.shields.io/librariesio/release/npm/@furkot/directions
 [deps-url]: https://libraries.io/npm/@furkot%2Fdirections

package/lib/directions.js

@@ -1,5 +1,6 @@
 const travelMode = require('./model').travelMode;
-const { defaults: defaults, withTimeout } = require('./service/util');
+const { defaults, withTimeout } = require('./service/util');
+const prepareQuery = require('./profile');
 
 module.exports = furkotDirections;
 
@@ -41,40 +42,41 @@ const services = {
 const defaultTimeout = 20 * 1000;
 
 function furkotDirections(options) {
-
   options = {
     timeout: defaultTimeout,
     order: ['osrm', 'mapquest', 'valhalla', 'graphhopper', 'openroute'],
     ...options
   };
   if (!options.services) {
-    options.services = options.order.map(name => {
-      const service = services[options[name] || name];
-      if (!service) {
-        return;
-      }
-      const enable = options[`${name}_enable`];
-      if (!enable) {
-        return;
-      }
-      // object representing actual parameters for a service
-      const serviceOptions = {
-        name,
-        limiter: options[`${name}_limiter`],
-        enable,
-        skip: service.skip
-      };
-      if (options[name]) {
-        Object.keys(options).reduce(mapOptions, {
-          options,
+    options.services = options.order
+      .map(name => {
+        const service = services[options[name] || name];
+        if (!service) {
+          return;
+        }
+        const enable = options[`${name}_enable`];
+        if (!enable) {
+          return;
+        }
+        // object representing actual parameters for a service
+        const serviceOptions = {
           name,
-          optName: options[name],
-          serviceOptions
-        });
-      }
-      // we are adding options that has not been copied to serviceOptions yet
-      return service.service(defaults(serviceOptions, options));
-    }).filter(Boolean);
+          limiter: options[`${name}_limiter`],
+          enable,
+          skip: service.skip
+        };
+        if (options[name]) {
+          Object.keys(options).reduce(mapOptions, {
+            options,
+            name,
+            optName: options[name],
+            serviceOptions
+          });
+        }
+        // we are adding options that has not been copied to serviceOptions yet
+        return service.service(defaults(serviceOptions, options));
+      })
+      .filter(Boolean);
   }
 
   directions.options = options;
@@ -86,7 +88,7 @@ function furkotDirections(options) {
    */
   function directions(query, { signal } = {}) {
     if (query?.points?.length > 1) {
-      return requestDirections(query, options.timeout);
+      return requestDirections(prepareQuery(query), options.timeout);
     }
 
     async function requestDirections(query, timeout) {
@@ -111,10 +113,13 @@ function furkotDirections(options) {
           break;
         }
         if (query.points.length > 2) {
-          return requestDirections({
-            ...query,
-            points: query.points.slice(0, 2)
-          }, timeout);
+          return requestDirections(
+            {
+              ...query,
+              points: query.points.slice(0, 2)
+            },
+            timeout
+          );
         }
       }
       return {

package/lib/model.js

@@ -22,9 +22,7 @@ const directionsQuery = {
   avoidHighways: false, // true to avoid highways
   avoidTolls: false, // true to avoid toll roads
   units: 'm', // m - miles, km - kilometers
-  points: [
-    [0, 0]
-  ], // array of consecutive series of points; each point is [lon, lat]
+  points: [[0, 0]], // array of consecutive series of points; each point is [lon, lat]
   isInChina: false, // points are in China (some services need this information)
   begin: '', // date/time for the begin of route as 'YYYY-MM-DDThh:mm'
   turnbyturn: false, // provide detailed turn-by-turn instructions (segments in directionsResult)
@@ -39,19 +37,25 @@ const directionsResult = {
   query: directionsQuery, // query parameters
   places: [], // addresses or place names corresponding to points (if directions service performs reverse geocoding)
   name: '', // human-readable name of directions (if available)
-  routes: [{ // routes; one for each point with a successor in the query.points
-    duration: 0, // route duration in seconds
-    distance: 0, // route distance in meters
-    path: [], // simplified series of interim points; each point is [lon, lat]
-    seasonal: false, // indicates a road that is seasonally closed
-    segmentIndex: 0 // index of the turn-by-turn directions segment
-  }],
-  segments: [{ // turn-by-turn directions
-    duration: 0, // segment duration in seconds
-    distance: 0, // segment distance in meters
-    path: [], // series of interim points; each point is [lon, lat]
-    instructions: '' // textual instructions for this segment
-  }],
+  routes: [
+    {
+      // routes; one for each point with a successor in the query.points
+      duration: 0, // route duration in seconds
+      distance: 0, // route distance in meters
+      path: [], // simplified series of interim points; each point is [lon, lat]
+      seasonal: false, // indicates a road that is seasonally closed
+      segmentIndex: 0 // index of the turn-by-turn directions segment
+    }
+  ],
+  segments: [
+    {
+      // turn-by-turn directions
+      duration: 0, // segment duration in seconds
+      distance: 0, // segment distance in meters
+      path: [], // series of interim points; each point is [lon, lat]
+      instructions: '' // textual instructions for this segment
+    }
+  ],
   stats: [], // list of providers that requests have been sent to to obtain directions
   provider: '' // identifies service providing the directions
 };

package/lib/profile/index.js

@@ -0,0 +1,15 @@
+const profiles = {
+  5: require('./rv')
+};
+
+module.exports = prepareQuery;
+
+/**
+ * Prepares query depending on the mode.
+ * @param {Object} query - The query object.
+ * @returns {Object} The prepared query.
+ */
+function prepareQuery(query) {
+  const { mode } = query;
+  return profiles[mode]?.(query) || query;
+}

package/lib/profile/rv/dimensions.js

@@ -0,0 +1,24 @@
+/**
+ * Default RV dimensions based on Valhalla defaults for truck:
+ * https://valhalla.github.io/valhalla/api/turn-by-turn/api-reference/#automobile-and-bus-costing-options
+ */
+const defaultRV = {
+  axle_load: 9.07,
+  hazmat: true,
+  height: 4.11,
+  length: 21.64,
+  weight: 21.77,
+  width: 2.6
+};
+
+const passengerCar = {
+  height: 3.8,
+  length: 8,
+  weight: 6,
+  width: 2.5
+};
+
+module.exports = {
+  defaultRV,
+  passengerCar
+};

package/lib/profile/rv/index.js

@@ -0,0 +1,71 @@
+const { passengerCar, defaultRV } = require('./dimensions');
+const passengerCarEntries = Object.entries(passengerCar);
+
+module.exports = prepareQuery;
+
+/**
+ * Treat RV as passenger car when it doesn't carry hazmat and all its dimensions
+ * that are present fall within the passenger car limits.
+ * @param {Object} vehicle - The vehicle object.
+ * @returns {boolean} Whether to treat RV as passenger car.
+ */
+function isPassengerCar(vehicle) {
+  return !vehicle.hazmat && passengerCarEntries.every(([k, v]) => vehicle[k] <= v);
+}
+
+/**
+ * Treat RV as non commercial truck when it doesn't carry hazmat and its
+ * weight and length are below truck limits.
+ * @param {Object} vehicle - The vehicle object.
+ * @returns {boolean} Whether to treat RV as non commercial truck.
+ */
+function isNonCommercialTruck(vehicle) {
+  return !vehicle.hazmat && vehicle.length < defaultRV.length && vehicle.weight < defaultRV.weight;
+}
+
+/**
+ * Prepares vehicle size for the query.
+ * @param {Object} query - The query object.
+ * @returns {Object} The prepared query with vehicle size.
+ */
+function prepareVehicle(vehicle) {
+  if (!vehicle) {
+    // treat as a standard truck
+    return {
+      vehicle: defaultRV
+    };
+  }
+  if (isPassengerCar(vehicle)) {
+    // treat as a regular passenger car
+    return {
+      mode: 0
+    };
+  }
+  vehicle = Object.assign({}, defaultRV, vehicle);
+  let proposedMode;
+  if (isNonCommercialTruck(vehicle)) {
+    // treat as a passenger car if at least height and width can be enforced
+    proposedMode = 0;
+  }
+  return {
+    proposedMode,
+    vehicle
+  };
+}
+
+/**
+ * Prepares query.
+ * @param {Object} query - The query object.
+ * @returns {Object} The prepared query.
+ */
+function prepareQuery(query) {
+  const { mode: initialMode, vehicle: initialVehicle } = query;
+  return Object.assign(
+    {
+      initialMode,
+      initialVehicle
+    },
+    query,
+    prepareVehicle(query.vehicle)
+  );
+}

package/lib/service/graphhopper/index.js

@@ -1,7 +1,7 @@
 // https://docs.graphhopper.com/#tag/Routing-API
 // https://github.com/boldtrn/kurviger-api-documentation
 
-const { pathType, travelMode } = require("../../model");
+const { pathType, travelMode } = require('../../model');
 const status = require('../status');
 const tagRoute = require('../tag-route');
 const util = require('../util');
@@ -9,12 +9,11 @@ const util = require('../util');
 module.exports = init;
 
 const vehicle = {
-  '-1': 'car',
-  0: 'car',
   1: 'bike',
   2: 'foot',
   5: 'truck'
 };
+const defaultVehicle = 'car';
 
 const weighting = {
   true: 'curvature',
@@ -40,7 +39,10 @@ const tollTypes = {
 };
 
 function extractSegment(result, { distance, interval, text, time }) {
-  const { directions: { segments }, path } = result;
+  const {
+    directions: { segments },
+    path
+  } = result;
   const [from, to] = interval;
   segments.push({
     duration: Math.round((time || 0) / 1000),
@@ -64,7 +66,10 @@ function setTolls(seg) {
 }
 
 function extractDirections(result, { details, distance, instructions, points, time }) {
-  const { directions: { routes, segments }, fullPath } = result;
+  const {
+    directions: { routes, segments },
+    fullPath
+  } = result;
   result.path = util.decode(points);
   const route = {
     duration: Math.round((time || 0) / 1000),
@@ -111,7 +116,7 @@ function extractDirections(result, { details, distance, instructions, points, ti
 }
 
 function getStatus(st, response) {
-  st = st && st.status;
+  st = st?.status;
   if (!(st || response)) {
     return;
   }
@@ -130,9 +135,14 @@ function getStatus(st, response) {
   }
 }
 
+function vehicleType(query) {
+  const { mode, proposedMode } = query;
+  return vehicle[proposedMode ?? mode] || defaultVehicle;
+}
+
 function vehicleSize(query, options) {
-  const { mode, vehicle } = query;
-  if (!(vehicle && mode === travelMode.rv)) {
+  const { initialMode, mode, vehicle } = query;
+  if (!(vehicle && (initialMode ?? mode) === travelMode.rv)) {
     return;
   }
   const { hazmat } = vehicle;
@@ -142,7 +152,7 @@ function vehicleSize(query, options) {
       multiply_by: '0.0'
     });
   }
-  ['height', 'width', 'length', 'weight', 'axle_load'].forEach(p => {
+  ['height', 'width', 'length', 'weight'].forEach(p => {
     if (vehicle[p]) {
       options.push({
         if: `max_${p} < ${vehicle[p]}`,
@@ -153,19 +163,23 @@ function vehicleSize(query, options) {
 }
 
 function init(options) {
-
   function prepareUrl(url) {
     return `${url}?key=${options.graphhopper_key}`;
   }
 
   function prepareRequest(query) {
     const { avoidFerry, avoidHighways, avoidTolls, avoidUnpaved, curvy, mode, path, points, turnbyturn } = query;
-    if (options.parameters.max_curvy_distance && curvy && mode === -1 && points.length === 2 &&
-      util.distance(points[0], points[1]) > options.parameters.max_curvy_distance) {
+    if (
+      options.parameters.max_curvy_distance &&
+      curvy &&
+      mode === -1 &&
+      points.length === 2 &&
+      util.distance(points[0], points[1]) > options.parameters.max_curvy_distance
+    ) {
       return;
     }
-    let req = {
-      vehicle: vehicle[mode] || vehicle[0],
+    const req = {
+      vehicle: vehicleType(query),
       points,
       details: ['road_environment', 'toll']
     };
@@ -190,21 +204,24 @@ function init(options) {
       if (avoidUnpaved) {
         req.avoid_unpaved_roads = true;
       }
-    }
-    else {
+    } else {
       req.details.push('surface');
       req['ch.disable'] = true;
       req.custom_model = {
-        priority: [{
-          if: 'road_class == MOTORWAY',
-          multiply_by: avoidHighways ? '0.1' : '1.0'
-        }, {
-          if: 'toll == ALL',
-          multiply_by: avoidTolls ? '0.1' : '1.0'
-        }, {
-          if: 'road_environment == FERRY',
-          multiply_by: avoidFerry ? '0.1' : '1.0'
-        }]
+        priority: [
+          {
+            if: 'road_class == MOTORWAY',
+            multiply_by: avoidHighways ? '0.1' : '1.0'
+          },
+          {
+            if: 'toll == ALL',
+            multiply_by: avoidTolls ? '0.1' : '1.0'
+          },
+          {
+            if: 'road_environment == FERRY',
+            multiply_by: avoidFerry ? '0.1' : '1.0'
+          }
+        ]
       };
       if (avoidUnpaved) {
         req.custom_model.priority.push({
@@ -219,7 +236,6 @@ function init(options) {
   }
 
   function processResponse(response, query) {
-
     if (response && response.status >= 400) {
       // let it cascade to the next service
       return;
@@ -229,7 +245,7 @@ function init(options) {
       query,
       provider: options.name
     };
-    const paths = response && response.paths;
+    const paths = response?.paths;
     if (paths) {
       directions.routes = [];
       if (query.turnbyturn || query.path === pathType.smooth || query.path === pathType.coarse) {

package/lib/service/index.js

@@ -1,5 +1,5 @@
 const fetchagent = require('fetchagent');
-const { pathType } = require("../model");
+const { pathType } = require('../model');
 const makeLimiter = require('limiter-component');
 const status = require('./status');
 const makeSimplify = require('./simplify');
@@ -89,15 +89,14 @@ function init(options) {
 }
 
 async function request(url, req) {
-  const options = this;
   let fa = fetchagent;
-  if (options.post) {
+  if (this.post) {
     fa = fa.post(url).send(req);
   } else {
     fa = fa.get(url).query(req);
   }
-  if (options.authorization) {
-    fa.set('authorization', options.authorization);
+  if (this.authorization) {
+    fa.set('authorization', this.authorization);
   }
   const res = await fa.set('accept', 'application/json').end();
   let status;

package/lib/service/mapquest/index.js

@@ -1,4 +1,4 @@
-const { pathType } = require("../../model");
+const { pathType } = require('../../model');
 const status = require('../status');
 const util = require('../util');
 
@@ -39,7 +39,12 @@ function addPoint(result, p, i, points) {
 }
 
 function extractSegment(result, { distance, index, narrative, time }) {
-  const { directions: { segments }, maneuverIndexes: indexes, path, unitMultiplier } = result;
+  const {
+    directions: { segments },
+    maneuverIndexes: indexes,
+    path,
+    unitMultiplier
+  } = result;
   segments.push({
     duration: time,
     distance: Math.round((distance || 0) * unitMultiplier),
@@ -50,7 +55,11 @@ function extractSegment(result, { distance, index, narrative, time }) {
 }
 
 function extractDirections(result, leg) {
-  const { directions: { routes, segments }, legIndexes: indexes, path } = result;
+  const {
+    directions: { routes, segments },
+    legIndexes: indexes,
+    path
+  } = result;
   const route = {
     duration: leg.time || 0,
     distance: Math.round((leg.distance || 0) * result.unitMultiplier)
@@ -71,12 +80,12 @@ function extractDirections(result, leg) {
   return result;
 }
 
-function getStatus(err, response) {
+function getStatus(_err, response) {
   if (!response) {
     return;
   }
   const { info, route } = response;
-  const st = info && info.statuscode;
+  const st = info?.statuscode;
   if (st === 403 || st === 500) {
     // assume its because we exceeded the limit
     return status.failure;
@@ -94,7 +103,6 @@ function getStatus(err, response) {
 }
 
 function init(options) {
-
   function getProvider(query) {
     if (query.alternate) {
       return options.name;
@@ -103,8 +111,11 @@ function init(options) {
   }
 
   function getUrl(query) {
-    return options[getProvider(query) + '_url'] + '/directions/v2/' +
-      (query.alternate && query.points.length <= 2 ? 'alternateroutes' : 'route');
+    return (
+      options[getProvider(query) + '_url'] +
+      '/directions/v2/' +
+      (query.alternate && query.points.length <= 2 ? 'alternateroutes' : 'route')
+    );
   }
 
   function prepareRequest(query) {
@@ -146,8 +157,7 @@ function init(options) {
   }
 
   function processResponse(response, query) {
-
-    if (response && response.info) {
+    if (response?.info) {
       const { statuscode: st } = response.info;
       if (st === 402 || st > 600) {
         // let it cascade to the next service
@@ -155,8 +165,8 @@ function init(options) {
       }
     }
 
-    const route = response && response.route;
-    if (!(route && route.legs && route.legs.length)) {
+    const route = response?.route;
+    if (!route?.legs?.length) {
       // shouldn't happen
       return;
     }
@@ -175,9 +185,9 @@ function init(options) {
     route.legs.reduce(extractDirections, {
       directions,
       unitMultiplier: query.units === 'km' ? util.metersInKm : util.metersInMile,
-      maneuverIndexes: route.shape && route.shape.maneuverIndexes,
-      legIndexes: route.shape && route.shape.legIndexes,
-      path: route.shape && route.shape.shapePoints.reduce(addPoint, []),
+      maneuverIndexes: route.shape?.maneuverIndexes,
+      legIndexes: route.shape?.legIndexes,
+      path: route.shape?.shapePoints.reduce(addPoint, []),
       fullPath
     });
     if (fullPath) {

package/lib/service/openroute/index.js

@@ -1,7 +1,7 @@
 // https://openrouteservice.org/dev/#/api-docs/directions
 
 const LatLon = require('geodesy/latlon-spherical');
-const { pathType, travelMode } = require("../../model");
+const { pathType, travelMode } = require('../../model');
 const status = require('../status');
 const tagRoute = require('../tag-route');
 const util = require('../util');
@@ -26,27 +26,29 @@ const avoidFeatures = {
   avoidFerry: 'ferries'
 };
 const ferryTypes = {
-  '9': true
+  9: true
 };
 const roughTypes = {
-  '2': true, // Unpaved
-  '8': true, // Compacted Gravel
-  '9': true, // Fine Gravel
-  '10': true, // Gravel
-  '11': true, // Dirt
-  '12': true, // Ground
-  '15': true, // Sand
-  '17': true, // Grass
-  '18': true // Grass Paver
+  2: true, // Unpaved
+  8: true, // Compacted Gravel
+  9: true, // Fine Gravel
+  10: true, // Gravel
+  11: true, // Dirt
+  12: true, // Ground
+  15: true, // Sand
+  17: true, // Grass
+  18: true // Grass Paver
 };
 const tollTypes = {
-  '1': true
+  1: true
 };
 const maxRoundabout = 12 * 60 * 60; // 12 hours maximum for route that is 10 times longer than direct distance
 
-
 function extractStep(result, { distance, duration, instruction, way_points }) {
-  const { directions: { segments }, path } = result;
+  const {
+    directions: { segments },
+    path
+  } = result;
   const seg = {
     duration: Math.round(duration || 0),
     distance: Math.round(distance || 0),
@@ -70,13 +72,20 @@ function setTolls(seg) {
 }
 
 function extractDirections(result, { distance, duration, steps }, i) {
-  const { directions: { routes, segments }, path, surface, waypoints, waytypes, tollways } = result;
+  const {
+    directions: { routes, segments },
+    path,
+    surface,
+    waypoints,
+    waytypes,
+    tollways
+  } = result;
   const route = {
     duration: Math.round(duration || 0),
     distance: Math.round(distance || 0),
     path: path?.slice(waypoints[i], waypoints[i + 1] + 1)
   };
-  if (!(route.duration || route.distance || (route.path?.length > 1))) {
+  if (!(route.duration || route.distance || route.path?.length > 1)) {
     route.path = [];
   }
   if (segments) {
@@ -87,7 +96,7 @@ function extractDirections(result, { distance, duration, steps }, i) {
     steps.reduce(extractStep, result);
     if (segments.length === 1) {
       const seg = segments[0];
-      if (!(seg.duration || seg.distance || (seg.path?.length > 1))) {
+      if (!(seg.duration || seg.distance || seg.path?.length > 1)) {
         seg.path = [];
       }
     }
@@ -127,24 +136,30 @@ function toLatLon(p) {
 }
 
 function directDistance(locations) {
-  return locations.reduce((result, next) => {
-    next = toLatLon(next);
-    result.dist += result.ll.distanceTo(next);
-    result.ll = next;
-    return result;
-  }, {
-    dist: 0,
-    ll: toLatLon(locations[0])
-  }).dist;
+  return locations.reduce(
+    (result, next) => {
+      next = toLatLon(next);
+      result.dist += result.ll.distanceTo(next);
+      result.ll = next;
+      return result;
+    },
+    {
+      dist: 0,
+      ll: toLatLon(locations[0])
+    }
+  ).dist;
 }
 
 function getStatus(st, response) {
   if (!st && response?.routes?.length) {
-    const { distance, duration } = response.routes.reduce((result, { summary}) => {
-      result.distance += summary.distance;
-      result.duration += summary.duration;
-      return result;
-    }, { distance: 0, duration: 0 });
+    const { distance, duration } = response.routes.reduce(
+      (result, { summary }) => {
+        result.distance += summary.distance;
+        result.duration += summary.duration;
+        return result;
+      },
+      { distance: 0, duration: 0 }
+    );
     const coordinates = response.metadata?.query?.coordinates;
     const direct = coordinates ? directDistance(coordinates) : distance;
     if (distance < 5 * direct || duration < maxRoundabout) {
@@ -169,13 +184,8 @@ function vehicleSize(query, restrictions) {
 }
 
 function init(options) {
-
   function prepareUrl(query) {
-    return [
-      options.openroute_url,
-      profile[query.mode] || profile[0],
-      'json'
-    ].join('/');
+    return [options.openroute_url, profile[query.mode] || profile[0], 'json'].join('/');
   }
 
   function avoidFeature(result, flag) {
@@ -219,7 +229,6 @@ function init(options) {
   }
 
   function processResponse(response, query) {
-
     if (!response?.routes?.length) {
       // let it cascade to the next service
       return;

package/lib/service/osrm/index.js

@@ -1,4 +1,4 @@
-const { pathType } = require("../../model");
+const { pathType } = require('../../model');
 const status = require('../status');
 const util = require('../util');
 
@@ -45,8 +45,8 @@ function convertRoute({ legs }) {
 }
 
 // response codes: http://project-osrm.org/docs/v5.5.2/api/#responses
-function getStatus(err, response) {
-  const code = response && response.code;
+function getStatus(_err, response) {
+  const code = response?.code;
   if (!response) {
     return;
   }
@@ -75,26 +75,16 @@ const profile = {
 };
 
 function prepareUrl(baseUrl, query) {
-
   function coords2string(c) {
     return c[0].toFixed(5) + ',' + c[1].toFixed(5);
   }
 
+  const path = query.points.map(coords2string).join(';');
 
-  const path = query.points
-    .map(coords2string)
-    .join(';');
-
-  return [
-    baseUrl,
-    'route/v1',
-    profile[query.mode],
-    path
-  ].join('/');
+  return [baseUrl, 'route/v1', profile[query.mode], path].join('/');
 }
 
 function init(options) {
-
   function processResponse(response, query) {
     const directions = {
       query,
@@ -112,14 +102,14 @@ function init(options) {
         if (query.turnbyturn || query.path === pathType.smooth || query.path === pathType.coarse) {
           directions.segments = [];
           // copy segments from route to its own table
-          directions.routes.forEach(function (route) {
+          directions.routes.forEach(route => {
             route.segmentIndex = directions.segments.length;
             directions.segments = directions.segments.concat(route.segments);
             delete route.segments;
           });
         } else {
           // delete segments
-          directions.routes.forEach(function (route) {
+          directions.routes.forEach(route => {
             delete route.segments;
           });
         }

package/lib/service/partition.js

@@ -3,7 +3,7 @@ const util = require('./util');
 module.exports = partition;
 
 function distanceSquare(p1, p2) {
-  return Math.pow((p1[0] - p2[0]), 2) + Math.pow((p1[1] - p2[1]), 2);
+  return (p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2;
 }
 
 function pointOnLine(point, p1, p2) {

package/lib/service/simplify.js

@@ -1,4 +1,4 @@
-const pathType = require("../model").pathType;
+const pathType = require('../model').pathType;
 const util = require('./util');
 
 module.exports = init;
@@ -6,7 +6,7 @@ module.exports = init;
 function init(options) {
   options = options || {};
 
-  const algorithm = options.algorithm || require("vis-why");
+  const algorithm = options.algorithm || require('vis-why');
   const endPoints = options.endPoints || 25; // how many points keep at ends
   const maxPoints = options.pathPoints || 100; // maximum number of points kept per path
   const ed = maxPoints / endPoints;
@@ -53,8 +53,10 @@ function init(options) {
       }
     }
     if (first.split) {
-      util.concat(path, segments[i].path.slice(first.split,
-        (i === result.segmentIndex - 1 && last.split) ? last.split : undefined));
+      util.concat(
+        path,
+        segments[i].path.slice(first.split, i === result.segmentIndex - 1 && last.split ? last.split : undefined)
+      );
       i += 1;
     }
     for (; i < (last.split ? result.segmentIndex - 1 : result.segmentIndex); i += 1) {
@@ -64,7 +66,7 @@ function init(options) {
       util.concat(path, segments[i].path.slice(0, last.split));
     }
     result.segmentIndex = route.segmentIndex;
-    if (type === pathType.full || (first.length + path.length + last.length) <= maxPoints) {
+    if (type === pathType.full || first.length + path.length + last.length <= maxPoints) {
       if (endDistance) {
         route.path = util.concat(util.concat(first, path), last);
       } else {

package/lib/service/util.js

@@ -64,7 +64,7 @@ function isFuture(time) {
 
 // like normal join but with optional filter fn
 function join(arr, conn, fn) {
-  fn = fn || function (it) { return it; };
+  fn = fn || (it => it);
   return arr.filter(fn).join(conn);
 }
 
@@ -73,24 +73,27 @@ function last(arr) {
 }
 
 function split2object(str, conn, obj) {
-  return str.split(conn || '-').reduce(function (result, word) {
+  return str.split(conn || '-').reduce((result, word) => {
     result[word] = word;
     return result;
   }, obj || {});
 }
 
 function collateResults(results, query) {
-  return results.reduce((result, r) => {
-    concatArrayProp(result, r, 'segments');
-    concatArrayProp(result, r, 'places');
-    concatArrayProp(result, r, 'routes');
-    if (!result.name && r?.name) {
-      result.name = r.name;
+  return results.reduce(
+    (result, r) => {
+      concatArrayProp(result, r, 'segments');
+      concatArrayProp(result, r, 'places');
+      concatArrayProp(result, r, 'routes');
+      if (!result.name && r?.name) {
+        result.name = r.name;
+      }
+      return result;
+    },
+    {
+      query
     }
-    return result;
-  }, {
-    query
-  });
+  );
 
   function concatArrayProp(to, from, prop) {
     if (!from[prop]) {
@@ -110,12 +113,10 @@ function withTimeout(promise, millis, signal) {
   let reject;
 
   signal?.addEventListener('abort', onabort);
-  return Promise
-    .race([promise, new Promise(timeoutPromise)])
-    .finally(() => {
-      signal?.removeEventListener('abort', onabort);
-      clearTimeout(id);
-    });
+  return Promise.race([promise, new Promise(timeoutPromise)]).finally(() => {
+    signal?.removeEventListener('abort', onabort);
+    clearTimeout(id);
+  });
 
   function onabort() {
     reject(signal.reason);
@@ -124,10 +125,7 @@ function withTimeout(promise, millis, signal) {
   function timeoutPromise(_resolve, _reject) {
     resolve = _resolve;
     reject = _reject;
-    id = setTimeout(
-      () => resolve(),
-      millis
-    );
+    id = setTimeout(() => resolve(), millis);
   }
 }
 

package/lib/service/valhalla/index.js

@@ -1,7 +1,7 @@
 // https://github.com/valhalla/valhalla-docs
 
 const LatLon = require('geodesy/latlon-spherical');
-const { pathType, travelMode } = require("../../model");
+const { pathType, travelMode } = require('../../model');
 const status = require('../status');
 const util = require('../util');
 
@@ -23,7 +23,7 @@ const costingOptions = {
     hazmat: true
   }
 };
-const minSpeed = 15 * 1000 / 3600; // bump speed when it is absurdly low
+const minSpeed = (15 * 1000) / 3600; // bump speed when it is absurdly low
 const turnDistance = 100; // don't adjust speed of turns
 const maxRoundabout = 12 * 60 * 60; // 12 hours maximum for route that is 10 times longer than direct distance
 
@@ -41,18 +41,15 @@ function prepareWaypoint(p) {
   };
 }
 
-function extractSegment(result, {
-  type,
-  begin_shape_index,
-  end_shape_index,
-  instruction,
-  length,
-  time,
-  rough,
-  toll,
-  travel_mode
-}) {
-  const { directions: { segments, routes }, unitMultiplier, path } = result;
+function extractSegment(
+  result,
+  { type, begin_shape_index, end_shape_index, instruction, length, time, rough, toll, travel_mode }
+) {
+  const {
+    directions: { segments, routes },
+    unitMultiplier,
+    path
+  } = result;
   const distance = Math.round((length || 0) * unitMultiplier);
   let duration = time;
   if (rough) {
@@ -69,7 +66,7 @@ function extractSegment(result, {
   const seg = {
     duration,
     distance,
-    path: path && path.slice(begin_shape_index, end_shape_index),
+    path: path?.slice(begin_shape_index, end_shape_index),
     instructions: instruction
   };
   if (rough) {
@@ -98,8 +95,8 @@ 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)
+    duration: leg.summary?.time || 0,
+    distance: Math.round((leg.summary?.length || 0) * result.unitMultiplier)
   };
   if (result.fullPath) {
     route.path = result.path;
@@ -125,19 +122,24 @@ function toLatLon(p) {
 
 function directDistance(locations, units) {
   units = units === 'miles' ? util.metersInMile : util.metersInKm;
-  return locations.reduce((result, next) => {
-    next = toLatLon(next);
-    result.dist += result.ll.distanceTo(next);
-    result.ll = next;
-    return result;
-  }, {
-    dist: 0,
-    ll: toLatLon(locations[0])
-  }).dist / units;
+  return (
+    locations.reduce(
+      (result, next) => {
+        next = toLatLon(next);
+        result.dist += result.ll.distanceTo(next);
+        result.ll = next;
+        return result;
+      },
+      {
+        dist: 0,
+        ll: toLatLon(locations[0])
+      }
+    ).dist / units
+  );
 }
 
-function getStatus(err, response) {
-  let st = response && response.status_code;
+function getStatus(_err, response) {
+  let st = response?.status_code;
   if (!response) {
     return;
   }
@@ -150,14 +152,13 @@ function getStatus(err, response) {
     // no route
     return status.empty;
   }
-  st = response.trip && response.trip.status;
+  st = response.trip?.status;
   if (st === 0) {
-    if (response.trip.legs && response.trip.legs.length) {
+    if (response.trip.legs?.length) {
       const { length, time } = response.trip.summary;
       const distance = directDistance(response.trip.locations, response.trip.units);
       // make sure points are not too far from roads
-      if (length > 0.9 * distance &&
-          (length < 10 * distance || time < maxRoundabout)) {
+      if (length > 0.9 * distance && (length < 10 * distance || time < maxRoundabout)) {
         return status.success;
       }
     }
@@ -166,20 +167,24 @@ function getStatus(err, response) {
   }
 }
 
+function costingType(query) {
+  const { mode, proposedMode } = query;
+  return costing[proposedMode ?? mode] || defaultCosting;
+}
+
 function vehicleSize(query, options) {
-  const { mode, vehicle } = query;
-  if (!(vehicle && mode === travelMode.rv)) {
+  const { initialMode, mode, vehicle } = query;
+  if (!(vehicle && (initialMode ?? mode) === travelMode.rv)) {
     return;
   }
   Object.assign(options, vehicle);
 }
 
 function init(options) {
-
   function prepareRequest(query) {
     let req = {
       locations: query.points.map(prepareWaypoint),
-      costing: costing[query.mode] || defaultCosting,
+      costing: costingType(query),
       costing_options: {},
       directions_options: {
         units: units[query.units] || units.m
@@ -224,8 +229,8 @@ function init(options) {
   }
 
   function processResponse(response, query) {
-    const trip = response && response.trip;
-    if (trip && trip.legs && trip.legs.length) {
+    const trip = response?.trip;
+    if (trip?.legs?.length) {
       const directions = {
         query,
         provider: options.name,

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@furkot/directions",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "Directions service for Furkot",
   "author": {
     "name": "Damian Krzeminski",
     "email": "pirxpilot@furkot.com",
     "url": "https://pirxpilot.me"
   },
-  "repository": "furkot/directions",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/furkot/directions.git"
+  },
   "license": "MIT",
   "keywords": [
     "furkot-directions",
@@ -20,13 +23,10 @@
     "fetchagent": "~2.1.0",
     "geodesy": "^1.1.1",
     "limiter-component": "^1.2.0",
-    "vis-why": "^1.2.2"
+    "vis-why": "~2"
   },
   "devDependencies": {
-    "jshint": "~2",
-    "mocha": "~10",
-    "should": "~13",
-    "sinon": "~14"
+    "@biomejs/biome": "^1.9.4"
   },
   "scripts": {
     "test": "make check"
@@ -35,4 +35,4 @@
     "index.js",
     "lib"
   ]
-}
+}