@turf/distance

import { distance } from "@turf/distance";

import distance from "@turf/distance";

const { distance } = require("@turf/distance");

import { distance } from "@turf/distance";
import { point } from "@turf/helpers";

// Using Point Features
const from = point([-75.343, 39.984]);
const to = point([-75.534, 39.123]);
const distanceInKm = distance(from, to);
console.log(distanceInKm); // ~97.15 kilometers

// Using coordinate arrays
const distanceInMiles = distance(
  [-75.343, 39.984],
  [-75.534, 39.123],
  { units: "miles" }
);
console.log(distanceInMiles); // ~60.35 miles

/**
 * Calculates the distance between two coordinates in degrees, radians, miles, or kilometers.
 * This uses the Haversine formula to account for global curvature.
 * @param from - Origin coordinate
 * @param to - Destination coordinate  
 * @param options - Optional parameters (defaults to empty object)
 * @returns Distance between the two coordinates
 */
function distance(
  from: Coord,
  to: Coord,
  options: {
    units?: Units;
  } = {}
): number;

// Also available as default export
export default distance;
export { distance };

import { distance } from "@turf/distance";
import { point } from "@turf/helpers";

// Different coordinate input formats
const pointFeature = point([0, 0]);
const pointGeometry = { type: "Point", coordinates: [1, 1] };
const positionArray = [2, 2];

// All these work as coordinate inputs
const dist1 = distance(pointFeature, pointGeometry);
const dist2 = distance(positionArray, [3, 3]);
const dist3 = distance([0, 0], [1, 1], { units: "miles" });

// Different units
const kilometers = distance([0, 0], [1, 1]); // default
const miles = distance([0, 0], [1, 1], { units: "miles" });
const meters = distance([0, 0], [1, 1], { units: "meters" });
const degrees = distance([0, 0], [1, 1], { units: "degrees" });
const radians = distance([0, 0], [1, 1], { units: "radians" });
const nauticalMiles = distance([0, 0], [1, 1], { units: "nauticalmiles" });

/**
 * Coordinate input type - accepts Point Features, Point geometries, or coordinate arrays
 */
type Coord = Feature<Point> | Point | Position;

/**
 * Point Feature from GeoJSON
 */
interface Feature<Point> {
  type: "Feature";
  geometry: Point;
  properties?: GeoJsonProperties;
}

/**
 * Point geometry from GeoJSON
 */
interface Point {
  type: "Point";
  coordinates: Position;
}

/**
 * Position array representing [longitude, latitude]
 */
type Position = [number, number];

/**
 * GeoJSON properties object (can be any object or null)
 */
type GeoJsonProperties = { [name: string]: any } | null;

/**
 * Supported distance measurement units
 */
type Units =
  | "meters"
  | "metres" 
  | "millimeters"
  | "millimetres"
  | "centimeters"
  | "centimetres"
  | "kilometers"
  | "kilometres"
  | "miles"
  | "nauticalmiles"
  | "inches"
  | "yards"
  | "feet"
  | "radians"
  | "degrees";

import { distance } from "@turf/distance";
import { point } from "@turf/helpers";

try {
  // This will throw an error due to invalid units
  const result = distance(
    point([0, 0]), 
    point([1, 1]), 
    { units: "invalid-unit" as any }
  );
} catch (error) {
  console.error("Invalid units provided:", error.message);
}