@esri/arcgis-rest-routing 3.4.2 → 4.0.0-beta.3

package/dist/bundled/routing.esm.js

@@ -0,0 +1,736 @@
+/* @preserve
+* @esri/arcgis-rest-routing - v4.0.0-beta.2 - Apache-2.0
+* Copyright (c) 2017-2022 Esri, Inc.
+* Thu Mar 10 2022 23:21:15 GMT+0000 (Coordinated Universal Time)
+*/
+import { request, cleanUrl, appendCustomParams } from '@esri/arcgis-rest-request';
+
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+// https always
+const ARCGIS_ONLINE_ROUTING_URL = "https://route.arcgis.com/arcgis/rest/services/World/Route/NAServer/Route_World";
+const ARCGIS_ONLINE_CLOSEST_FACILITY_URL = "https://route.arcgis.com/arcgis/rest/services/World/ClosestFacility/NAServer/ClosestFacility_World";
+const ARCGIS_ONLINE_SERVICE_AREA_URL = "https://route.arcgis.com/arcgis/rest/services/World/ServiceAreas/NAServer/ServiceArea_World";
+const ARCGIS_ONLINE_ORIGIN_DESTINATION_MATRIX_URL = "https://route.arcgis.com/arcgis/rest/services/World/OriginDestinationCostMatrix/NAServer/OriginDestinationCostMatrix_World";
+function isLocationArray$1(coords) {
+    return (coords.length === 2 ||
+        coords.length === 3);
+}
+function isLocation$1(coords) {
+    return (coords.latitude !== undefined ||
+        coords.lat !== undefined);
+}
+function normalizeLocationsList(locations) {
+    return locations.map((coords) => {
+        if (isLocationArray$1(coords)) {
+            return coords.join();
+        }
+        else if (isLocation$1(coords)) {
+            if (coords.lat) {
+                return coords.long + "," + coords.lat;
+            }
+            else {
+                return coords.longitude + "," + coords.latitude;
+            }
+        }
+        else {
+            return coords.x + "," + coords.y;
+        }
+    });
+}
+function decompressGeometry(str) {
+    let xDiffPrev = 0;
+    let yDiffPrev = 0;
+    const points = [];
+    let x;
+    let y;
+    // Split the string into an array on the + and - characters
+    const strings = str.match(/((\+|-)[^+-]+)/g);
+    // The first value is the coefficient in base 32
+    const coefficient = parseInt(strings[0], 32);
+    for (let j = 1; j < strings.length; j += 2) {
+        // j is the offset for the x value
+        // Convert the value from base 32 and add the previous x value
+        x = parseInt(strings[j], 32) + xDiffPrev;
+        xDiffPrev = x;
+        // j+1 is the offset for the y value
+        // Convert the value from base 32 and add the previous y value
+        y = parseInt(strings[j + 1], 32) + yDiffPrev;
+        yDiffPrev = y;
+        points.push([x / coefficient, y / coefficient]);
+    }
+    return {
+        paths: [points]
+    };
+}
+/**
+ * User Defined Type Guard that verifies this is a featureSet
+ */
+function isFeatureSet(arg) {
+    return Object.prototype.hasOwnProperty.call(arg, "features");
+}
+
+/* @preserve
+* @terraformer/arcgis - v2.0.7 - MIT
+* Copyright (c) 2012-2021 Environmental Systems Research Institute, Inc.
+* Thu Jul 22 2021 13:58:30 GMT-0700 (Pacific Daylight Time)
+*/
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var edgeIntersectsEdge = function edgeIntersectsEdge(a1, a2, b1, b2) {
+  var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);
+  var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);
+  var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);
+
+  if (uB !== 0) {
+    var ua = uaT / uB;
+    var ub = ubT / uB;
+
+    if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
+      return true;
+    }
+  }
+
+  return false;
+};
+var coordinatesContainPoint = function coordinatesContainPoint(coordinates, point) {
+  var contains = false;
+
+  for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {
+    if ((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1] || coordinates[j][1] <= point[1] && point[1] < coordinates[i][1]) && point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0]) {
+      contains = !contains;
+    }
+  }
+
+  return contains;
+};
+var pointsEqual = function pointsEqual(a, b) {
+  for (var i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+var arrayIntersectsArray = function arrayIntersectsArray(a, b) {
+  for (var i = 0; i < a.length - 1; i++) {
+    for (var j = 0; j < b.length - 1; j++) {
+      if (edgeIntersectsEdge(a[i], a[i + 1], b[j], b[j + 1])) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var closeRing = function closeRing(coordinates) {
+  if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) {
+    coordinates.push(coordinates[0]);
+  }
+
+  return coordinates;
+}; // determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring
+// or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-
+// points-are-in-clockwise-order
+
+var ringIsClockwise = function ringIsClockwise(ringToTest) {
+  var total = 0;
+  var i = 0;
+  var rLength = ringToTest.length;
+  var pt1 = ringToTest[i];
+  var pt2;
+
+  for (i; i < rLength - 1; i++) {
+    pt2 = ringToTest[i + 1];
+    total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);
+    pt1 = pt2;
+  }
+
+  return total >= 0;
+}; // This function ensures that rings are oriented in the right directions
+// from http://jsperf.com/cloning-an-object/2
+
+var shallowClone = function shallowClone(obj) {
+  var target = {};
+
+  for (var i in obj) {
+    // both arcgis attributes and geojson props are just hardcoded keys
+    if (obj.hasOwnProperty(i)) {
+      // eslint-disable-line no-prototype-builtins
+      target[i] = obj[i];
+    }
+  }
+
+  return target;
+};
+
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var coordinatesContainCoordinates = function coordinatesContainCoordinates(outer, inner) {
+  var intersects = arrayIntersectsArray(outer, inner);
+  var contains = coordinatesContainPoint(outer, inner[0]);
+
+  if (!intersects && contains) {
+    return true;
+  }
+
+  return false;
+}; // do any polygons in this array contain any other polygons in this array?
+// used for checking for holes in arcgis rings
+
+
+var convertRingsToGeoJSON = function convertRingsToGeoJSON(rings) {
+  var outerRings = [];
+  var holes = [];
+  var x; // iterator
+
+  var outerRing; // current outer ring being evaluated
+
+  var hole; // current hole being evaluated
+  // for each ring
+
+  for (var r = 0; r < rings.length; r++) {
+    var ring = closeRing(rings[r].slice(0));
+
+    if (ring.length < 4) {
+      continue;
+    } // is this ring an outer ring? is it clockwise?
+
+
+    if (ringIsClockwise(ring)) {
+      var polygon = [ring.slice().reverse()]; // wind outer rings counterclockwise for RFC 7946 compliance
+
+      outerRings.push(polygon); // push to outer rings
+    } else {
+      holes.push(ring.slice().reverse()); // wind inner rings clockwise for RFC 7946 compliance
+    }
+  }
+
+  var uncontainedHoles = []; // while there are holes left...
+
+  while (holes.length) {
+    // pop a hole off out stack
+    hole = holes.pop(); // loop over all outer rings and see if they contain our hole.
+
+    var contained = false;
+
+    for (x = outerRings.length - 1; x >= 0; x--) {
+      outerRing = outerRings[x][0];
+
+      if (coordinatesContainCoordinates(outerRing, hole)) {
+        // the hole is contained push it into our polygon
+        outerRings[x].push(hole);
+        contained = true;
+        break;
+      }
+    } // ring is not contained in any outer ring
+    // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320
+
+
+    if (!contained) {
+      uncontainedHoles.push(hole);
+    }
+  } // if we couldn't match any holes using contains we can try intersects...
+
+
+  while (uncontainedHoles.length) {
+    // pop a hole off out stack
+    hole = uncontainedHoles.pop(); // loop over all outer rings and see if any intersect our hole.
+
+    var intersects = false;
+
+    for (x = outerRings.length - 1; x >= 0; x--) {
+      outerRing = outerRings[x][0];
+
+      if (arrayIntersectsArray(outerRing, hole)) {
+        // the hole is contained push it into our polygon
+        outerRings[x].push(hole);
+        intersects = true;
+        break;
+      }
+    }
+
+    if (!intersects) {
+      outerRings.push([hole.reverse()]);
+    }
+  }
+
+  if (outerRings.length === 1) {
+    return {
+      type: 'Polygon',
+      coordinates: outerRings[0]
+    };
+  } else {
+    return {
+      type: 'MultiPolygon',
+      coordinates: outerRings
+    };
+  }
+};
+
+var getId = function getId(attributes, idAttribute) {
+  var keys = idAttribute ? [idAttribute, 'OBJECTID', 'FID'] : ['OBJECTID', 'FID'];
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+
+    if (key in attributes && (typeof attributes[key] === 'string' || typeof attributes[key] === 'number')) {
+      return attributes[key];
+    }
+  }
+
+  throw Error('No valid id attribute found');
+};
+
+var arcgisToGeoJSON = function arcgisToGeoJSON(arcgis, idAttribute) {
+  var geojson = {};
+
+  if (arcgis.features) {
+    geojson.type = 'FeatureCollection';
+    geojson.features = [];
+
+    for (var i = 0; i < arcgis.features.length; i++) {
+      geojson.features.push(arcgisToGeoJSON(arcgis.features[i], idAttribute));
+    }
+  }
+
+  if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') {
+    geojson.type = 'Point';
+    geojson.coordinates = [arcgis.x, arcgis.y];
+
+    if (typeof arcgis.z === 'number') {
+      geojson.coordinates.push(arcgis.z);
+    }
+  }
+
+  if (arcgis.points) {
+    geojson.type = 'MultiPoint';
+    geojson.coordinates = arcgis.points.slice(0);
+  }
+
+  if (arcgis.paths) {
+    if (arcgis.paths.length === 1) {
+      geojson.type = 'LineString';
+      geojson.coordinates = arcgis.paths[0].slice(0);
+    } else {
+      geojson.type = 'MultiLineString';
+      geojson.coordinates = arcgis.paths.slice(0);
+    }
+  }
+
+  if (arcgis.rings) {
+    geojson = convertRingsToGeoJSON(arcgis.rings.slice(0));
+  }
+
+  if (typeof arcgis.xmin === 'number' && typeof arcgis.ymin === 'number' && typeof arcgis.xmax === 'number' && typeof arcgis.ymax === 'number') {
+    geojson.type = 'Polygon';
+    geojson.coordinates = [[[arcgis.xmax, arcgis.ymax], [arcgis.xmin, arcgis.ymax], [arcgis.xmin, arcgis.ymin], [arcgis.xmax, arcgis.ymin], [arcgis.xmax, arcgis.ymax]]];
+  }
+
+  if (arcgis.geometry || arcgis.attributes) {
+    geojson.type = 'Feature';
+    geojson.geometry = arcgis.geometry ? arcgisToGeoJSON(arcgis.geometry) : null;
+    geojson.properties = arcgis.attributes ? shallowClone(arcgis.attributes) : null;
+
+    if (arcgis.attributes) {
+      try {
+        geojson.id = getId(arcgis.attributes, idAttribute);
+      } catch (err) {// don't set an id
+      }
+    }
+  } // if no valid geometry was encountered
+
+
+  if (JSON.stringify(geojson.geometry) === JSON.stringify({})) {
+    geojson.geometry = null;
+  }
+
+  if (arcgis.spatialReference && arcgis.spatialReference.wkid && arcgis.spatialReference.wkid !== 4326) {
+    console.warn('Object converted in non-standard crs - ' + JSON.stringify(arcgis.spatialReference));
+  }
+
+  return geojson;
+};
+
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+function isLocationArray(coords) {
+    return (coords.length === 2 ||
+        coords.length === 3);
+}
+function isLocation(coords) {
+    return (coords.latitude !== undefined ||
+        coords.lat !== undefined);
+}
+/**
+ * ```js
+ * import { solveRoute } from '@esri/arcgis-rest-routing';
+ * //
+ * solveRoute({
+ *   stops: [
+ *     [-117.195677, 34.056383],
+ *     [-117.918976, 33.812092],
+ *    ],
+ *    authentication
+ * })
+ *   .then(response) // => {routes: {features: [{attributes: { ... }, geometry:{ ... }}]}
+ * ```
+ * Used to find the best way to get from one location to another or to visit several locations. See the [REST Documentation](https://developers.arcgis.com/rest/network/api-reference/route-synchronous-service.htm) for more information.
+ *
+ * @param requestOptions Options to pass through to the routing service.
+ * @returns A Promise that will resolve with routes and directions for the request.
+ * @restlink https://developers.arcgis.com/rest/network/api-reference/route-synchronous-service.htm
+ */
+function solveRoute(requestOptions) {
+    const options = Object.assign({ endpoint: requestOptions.endpoint || ARCGIS_ONLINE_ROUTING_URL, params: {} }, requestOptions);
+    // the SAAS service does not support anonymous requests
+    if (!requestOptions.authentication &&
+        options.endpoint === ARCGIS_ONLINE_ROUTING_URL) {
+        return Promise.reject("Routing using the ArcGIS service requires authentication");
+    }
+    if (isFeatureSet(requestOptions.stops)) {
+        options.params.stops = requestOptions.stops;
+    }
+    else {
+        const stops = requestOptions.stops.map((coords) => {
+            if (isLocationArray(coords)) {
+                return coords.join();
+            }
+            else if (isLocation(coords)) {
+                if (coords.lat) {
+                    return (coords.long + "," + coords.lat + (coords.z ? "," + coords.z : ""));
+                }
+                else {
+                    return (coords.longitude +
+                        "," +
+                        coords.latitude +
+                        (coords.z ? "," + coords.z : ""));
+                }
+            }
+            else {
+                return coords.x + "," + coords.y + (coords.z ? "," + coords.z : "");
+            }
+        });
+        options.params.stops = stops.join(";");
+    }
+    return request(`${cleanUrl(options.endpoint)}/solve`, options).then(cleanResponse$3);
+}
+function cleanResponse$3(res) {
+    if (res.directions && res.directions.length > 0) {
+        res.directions = res.directions.map((direction) => {
+            direction.features = direction.features.map((feature) => {
+                feature.geometry = decompressGeometry(feature.compressedGeometry);
+                return feature;
+            });
+            return direction;
+        });
+    }
+    // add "geoJson" property to "routes"
+    if (res.routes.spatialReference.wkid === 4326) {
+        const features = res.routes.features.map((feature) => {
+            return {
+                type: "Feature",
+                geometry: arcgisToGeoJSON(feature.geometry),
+                properties: Object.assign({}, feature.attributes)
+            };
+        });
+        res.routes.geoJson = {
+            type: "FeatureCollection",
+            features
+        };
+    }
+    return res;
+}
+
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+function getTravelDirection$1(key) {
+    if (key === "incidentsToFacilities") {
+        return "esriNATravelDirectionFromFacility";
+    }
+    else {
+        return "esriNATravelDirectionToFacility";
+    }
+}
+/**
+ * ```js
+ * import { closestFacility } from '@esri/arcgis-rest-routing';
+ * //
+ * closestFacility({
+ *   incidents: [
+ *     [-90.404302, 38.600621],
+ *     [-90.364293, 38.620427],
+ *    ],
+ *   facilities: [
+ *     [-90.444716, 38.635501],
+ *     [-90.311919, 38.633523],
+ *     [-90.451147, 38.581107]
+ *    ],
+ *    authentication
+ * })
+ *   .then(response) // => {routes: {features: [{attributes: { ... }, geometry:{ ... }}]}
+ * ```
+ * Used to find a route to the nearest of several possible destinations. See the [REST Documentation](https://developers.arcgis.com/rest/network/api-reference/closest-facility-synchronous-service.htm) for more information.
+ *
+ * @param requestOptions Options to pass through to the routing service.
+ * @returns A Promise that will resolve with routes and directions for the request.
+ * @restlink https://developers.arcgis.com/rest/network/api-reference/closest-facility-synchronous-service.htm
+ * @inline IClosestFacilityOptions
+ */
+function closestFacility(requestOptions) {
+    const endpoint = requestOptions.endpoint || ARCGIS_ONLINE_CLOSEST_FACILITY_URL;
+    requestOptions.params = Object.assign({ returnFacilities: true, returnDirections: true, returnIncidents: true, returnBarriers: true, returnPolylineBarriers: true, returnPolygonBarriers: true, preserveObjectID: true }, requestOptions.params);
+    const options = appendCustomParams(requestOptions, [
+        "returnCFRoutes",
+        // "travelDirection",
+        "barriers",
+        "polylineBarriers",
+        "polygonBarriers",
+        "returnDirections",
+        "directionsOutputType",
+        "directionsLengthUnits",
+        "outputLines",
+        "returnFacilities",
+        "returnIncidents",
+        "returnBarriers",
+        "returnPolylineBarriers",
+        "returnPolygonBarriers",
+        "preserveObjectID"
+    ]);
+    // Set travelDirection
+    if (requestOptions.travelDirection) {
+        options.params.travelDirection = getTravelDirection$1(requestOptions.travelDirection);
+    }
+    // the SAAS service does not support anonymous requests
+    if (!requestOptions.authentication &&
+        endpoint === ARCGIS_ONLINE_CLOSEST_FACILITY_URL) {
+        return Promise.reject("Finding the closest facility using the ArcGIS service requires authentication");
+    }
+    if (isFeatureSet(requestOptions.incidents)) {
+        options.params.incidents = requestOptions.incidents;
+    }
+    else {
+        options.params.incidents = normalizeLocationsList(requestOptions.incidents).join(";");
+    }
+    if (isFeatureSet(requestOptions.facilities)) {
+        options.params.facilities = requestOptions.facilities;
+    }
+    else {
+        options.params.facilities = normalizeLocationsList(requestOptions.facilities).join(";");
+    }
+    // optional input param that may need point geometry normalizing
+    if (requestOptions.barriers) {
+        if (isFeatureSet(requestOptions.barriers)) {
+            options.params.barriers = requestOptions.barriers;
+        }
+        else {
+            // optional point geometry barriers must be normalized, too
+            // but not if provided as IFeatureSet type
+            // note that optional polylineBarriers and polygonBarriers do not need to be normalized
+            options.params.barriers = normalizeLocationsList(requestOptions.barriers).join(";");
+        }
+    }
+    return request(`${cleanUrl(endpoint)}/solveClosestFacility`, options).then(cleanResponse$2);
+}
+function cleanResponse$2(res) {
+    // add "geoJson" property to "routes"
+    if (res.routes.spatialReference.wkid === 4326) {
+        res.routes.geoJson = arcgisToGeoJSON(res.routes);
+    }
+    return res;
+}
+
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+function getTravelDirection(key) {
+    if (key === "incidentsToFacilities") {
+        return "esriNATravelDirectionFromFacility";
+    }
+    else {
+        return "esriNATravelDirectionToFacility";
+    }
+}
+/**
+ * ```js
+ * import { serviceArea } from '@esri/arcgis-rest-routing';
+ * //
+ * serviceArea({
+ *   facilities: [
+ *     [-90.444716, 38.635501],
+ *     [-90.311919, 38.633523],
+ *     [-90.451147, 38.581107]
+ *    ],
+ *    authentication
+ * })
+ *   .then(response) // => {routes: {features: [{attributes: { ... }, geometry:{ ... }}]}
+ * ```
+ * Used to find the area that can be reached from the input location within a given travel time or travel distance. See the [REST Documentation](https://developers.arcgis.com/rest/network/api-reference/service-area-synchronous-service.htm) for more information.
+ *
+ * @param requestOptions Options to pass through to the routing service.
+ * @returns A Promise that will resolve with service area polygons for the request.
+ * @restlink https://developers.arcgis.com/rest/network/api-reference/service-area-synchronous-service.htm
+ */
+function serviceArea(requestOptions) {
+    const endpoint = requestOptions.endpoint || ARCGIS_ONLINE_SERVICE_AREA_URL;
+    requestOptions.params = Object.assign({ returnFacilities: true, returnBarriers: true, returnPolylineBarriers: true, returnPolygonBarriers: true, preserveObjectID: true }, requestOptions.params);
+    const options = appendCustomParams(requestOptions, [
+        "barriers",
+        "polylineBarriers",
+        "polygonBarriers",
+        "outputLines",
+        "returnFacilities",
+        "returnBarriers",
+        "returnPolylineBarriers",
+        "returnPolygonBarriers",
+        "preserveObjectID"
+    ]);
+    // Set travelDirection
+    if (requestOptions.travelDirection) {
+        options.params.travelDirection = getTravelDirection(requestOptions.travelDirection);
+    }
+    // the SAAS service does not support anonymous requests
+    if (!requestOptions.authentication &&
+        endpoint === ARCGIS_ONLINE_SERVICE_AREA_URL) {
+        return Promise.reject("Finding service areas using the ArcGIS service requires authentication");
+    }
+    if (isFeatureSet(requestOptions.facilities)) {
+        options.params.facilities = requestOptions.facilities;
+    }
+    else {
+        options.params.facilities = normalizeLocationsList(requestOptions.facilities).join(";");
+    }
+    // optional input param that may need point geometry normalizing
+    if (requestOptions.barriers) {
+        if (isFeatureSet(requestOptions.barriers)) {
+            options.params.barriers = requestOptions.barriers;
+        }
+        else {
+            // optional point geometry barriers must be normalized, too
+            // but not if provided as IFeatureSet type
+            // note that optional polylineBarriers and polygonBarriers do not need to be normalized
+            options.params.barriers = normalizeLocationsList(requestOptions.barriers).join(";");
+        }
+    }
+    return request(`${cleanUrl(endpoint)}/solveServiceArea`, options).then(cleanResponse$1);
+}
+function cleanResponse$1(res) {
+    // remove "fieldAliases" because it does not do anything.
+    delete res.saPolygons.fieldAliases;
+    // add "geoJson" property to "saPolygons"
+    if (res.saPolygons.spatialReference.wkid === 4326) {
+        res.saPolygons.geoJson = arcgisToGeoJSON(res.saPolygons);
+    }
+    return res;
+}
+
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+/**
+ * ```js
+ * import { originDestinationMatrix } from '@esri/arcgis-rest-routing';
+ * //
+ * originDestinationMatrix({
+ *   origins: [
+ *     [-90.404302, 38.600621],
+ *     [-90.364293, 38.620427],
+ *   ],
+ *   destinations: [
+ *     [-90.444716, 38.635501],
+ *     [-90.311919, 38.633523],
+ *     [-90.451147, 38.581107]
+ *   ],
+ *   authentication
+ * })
+ *   .then(response) // => { ... }
+ * ```
+ * Used to create an origin-destination (OD) cost matrix from multiple origins to multiple destinations. See the [REST Documentation](https://developers.arcgis.com/rest/network/api-reference/origin-destination-cost-matrix-synchronous-service.htm) for more information.
+ *
+ * @param requestOptions Options to pass through to the routing service.
+ * @returns A Promise that will resolve with travel time and/or distance for each origin-destination pair. It returns either odLines or odCostMatrix for this information depending on the outputType you specify.
+ * @restlink https://developers.arcgis.com/rest/network/api-reference/origin-destination-cost-matrix-synchronous-service.htm
+ */
+function originDestinationMatrix(requestOptions) {
+    const endpoint = requestOptions.endpoint || ARCGIS_ONLINE_ORIGIN_DESTINATION_MATRIX_URL;
+    requestOptions.params = Object.assign({ outputType: "esriNAODOutputSparseMatrix", returnOrigins: true, returnDestinations: true, returnBarriers: true, returnPolylineBarriers: true, returnPolygonBarriers: true }, requestOptions.params);
+    const options = appendCustomParams(requestOptions, [
+        "outputType",
+        "barriers",
+        "polylineBarriers",
+        "polygonBarriers",
+        "returnOrigins",
+        "returnDestinations",
+        "returnBarriers",
+        "returnPolylineBarriers",
+        "returnPolygonBarriers"
+    ]);
+    // the SAAS service does not support anonymous requests
+    if (!requestOptions.authentication &&
+        endpoint === ARCGIS_ONLINE_ORIGIN_DESTINATION_MATRIX_URL) {
+        return Promise.reject("Calculating the origin-destination cost matrix using the ArcGIS service requires authentication");
+    }
+    // use a formatting helper for input params of this type: Array<IPoint | ILocation | [number, number]>
+    if (isFeatureSet(requestOptions.origins)) {
+        options.params.origins = requestOptions.origins;
+    }
+    else {
+        options.params.origins = normalizeLocationsList(requestOptions.origins).join(";");
+    }
+    if (isFeatureSet(requestOptions.destinations)) {
+        options.params.destinations = requestOptions.destinations;
+    }
+    else {
+        options.params.destinations = normalizeLocationsList(requestOptions.destinations).join(";");
+    }
+    // optional input param that may need point geometry normalizing
+    if (requestOptions.barriers) {
+        if (isFeatureSet(requestOptions.barriers)) {
+            options.params.barriers = requestOptions.barriers;
+        }
+        else {
+            // optional point geometry barriers must be normalized, too
+            // but not if provided as IFeatureSet type
+            // note that optional polylineBarriers and polygonBarriers do not need to be normalized
+            options.params.barriers = normalizeLocationsList(requestOptions.barriers).join(";");
+        }
+    }
+    return request(`${cleanUrl(endpoint)}/solveODCostMatrix`, options).then(function (res) {
+        return cleanResponse(res, options);
+    });
+}
+function cleanResponse(res, options) {
+    // add "geoJson" property to each response property that is an arcgis featureSet
+    // res.odLines only exists and only includes geometry in this condition (out of 3 possible options.params.outputType conditions)
+    if (options.params.outputType === "esriNAODOutputStraightLines" &&
+        res.odLines &&
+        res.odLines.spatialReference.wkid === 4326) {
+        res.odLines.geoJson = arcgisToGeoJSON(res.odLines);
+    }
+    if (res.origins && res.origins.spatialReference.wkid === 4326) {
+        res.origins.geoJson = arcgisToGeoJSON(res.origins);
+    }
+    if (res.destinations && res.destinations.spatialReference.wkid === 4326) {
+        res.destinations.geoJson = arcgisToGeoJSON(res.destinations);
+    }
+    if (res.barriers && res.barriers.spatialReference.wkid === 4326) {
+        res.barriers.geoJson = arcgisToGeoJSON(res.barriers);
+    }
+    if (res.polygonBarriers &&
+        res.polygonBarriers.spatialReference.wkid === 4326) {
+        res.polygonBarriers.geoJson = arcgisToGeoJSON(res.polygonBarriers);
+    }
+    if (res.polylineBarriers &&
+        res.polylineBarriers.spatialReference.wkid === 4326) {
+        res.polylineBarriers.geoJson = arcgisToGeoJSON(res.polylineBarriers);
+    }
+    return res;
+}
+
+export { ARCGIS_ONLINE_CLOSEST_FACILITY_URL, ARCGIS_ONLINE_ORIGIN_DESTINATION_MATRIX_URL, ARCGIS_ONLINE_ROUTING_URL, ARCGIS_ONLINE_SERVICE_AREA_URL, closestFacility, decompressGeometry, isFeatureSet, normalizeLocationsList, originDestinationMatrix, serviceArea, solveRoute };
+//# sourceMappingURL=routing.esm.js.map