@turf/helpers vs @turf/invariant vs @turf/meta vs @turf/turf
Geospatial Processing in JavaScript Comparison
Search packages..
3 Years
@turf/helpers@turf/invariant@turf/meta@turf/turf
What's Geospatial Processing in JavaScript?

The Turf.js ecosystem provides a suite of geospatial libraries for JavaScript, enabling developers to perform advanced geographic calculations, manipulate spatial data, and analyze geographic information. These libraries are designed to work with GeoJSON data, making them highly compatible with web mapping applications, geographic information systems (GIS), and any project that requires spatial analysis. The Turf.js libraries are modular, allowing developers to import only the functions they need, which helps keep applications lightweight and efficient. Whether you need to calculate distances, perform geometric operations, or analyze spatial relationships, Turf.js offers a comprehensive set of tools to handle a wide range of geospatial tasks.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
@turf/helpers6,771,132
9,963151 kB2898 months agoMIT
@turf/invariant4,589,216
9,96345.6 kB2898 months agoMIT
@turf/meta4,373,412
9,963217 kB2898 months agoMIT
@turf/turf789,819
9,963620 kB2898 months agoMIT
Feature Comparison: @turf/helpers vs @turf/invariant vs @turf/meta vs @turf/turf

Purpose and Functionality

  • @turf/helpers:

    The @turf/helpers package provides a collection of utility functions for creating and manipulating GeoJSON data. It includes functions for generating various GeoJSON geometries (points, lines, polygons), as well as helper methods for working with features and feature collections. This package is essential for developers who need lightweight, reusable functions to handle GeoJSON data without the overhead of a full geospatial library.

  • @turf/invariant:

    The @turf/invariant package focuses on ensuring the integrity and validity of GeoJSON data. It provides functions for validating GeoJSON geometries, checking their types, and ensuring they conform to the GeoJSON specification. This package is crucial for developers who need to validate spatial data, enforce data quality, and prevent errors when working with geographic information.

  • @turf/meta:

    The @turf/meta package offers tools for working with collections of GeoJSON features. It provides functions for iterating over features, applying transformations, and extracting data from feature collections. This package is useful for developers who need to perform operations on multiple features at once, such as aggregating values, applying styles, or modifying geometries in bulk.

  • @turf/turf:

    The @turf/turf package is a comprehensive geospatial library that includes a wide array of functions for spatial analysis, geometry manipulation, and geographic calculations. It provides tools for measuring distances, calculating areas, performing geometric operations (such as intersection and union), and much more. This package is ideal for developers who need a full-featured solution for complex geospatial tasks, all within a single, well-documented library.

GeoJSON Validation

  • @turf/helpers:

    The @turf/helpers package does not provide validation for GeoJSON data. Its primary focus is on creating and manipulating GeoJSON geometries and features. Developers are responsible for ensuring that the data they work with is valid GeoJSON.

  • @turf/invariant:

    The @turf/invariant package is dedicated to GeoJSON validation. It includes functions that check whether a given geometry or feature is valid according to the GeoJSON specification. This package helps developers ensure data integrity by providing tools to validate and normalize GeoJSON data before processing it.

  • @turf/meta:

    The @turf/meta package does not focus on validation but rather on iterating and manipulating collections of GeoJSON features. It assumes that the input data is valid GeoJSON and provides tools for working with features and feature collections efficiently.

  • @turf/turf:

    The @turf/turf package includes some validation features as part of its comprehensive geospatial toolkit. While it is not primarily a validation library, it provides functions that check the validity of geometries and features as part of its broader functionality.

Feature Creation

  • @turf/helpers:

    The @turf/helpers package excels in feature creation, providing a variety of functions to generate GeoJSON geometries, features, and feature collections. It includes utilities for creating points, lines, polygons, and more, making it easy for developers to generate valid GeoJSON data programmatically.

  • @turf/invariant:

    The @turf/invariant package does not focus on feature creation. Its primary purpose is to validate and ensure the integrity of GeoJSON data. It does not provide functions for creating features but rather for checking and enforcing their validity.

  • @turf/meta:

    The @turf/meta package is not designed for feature creation. It focuses on iterating over and manipulating existing GeoJSON features and collections. It provides tools for working with features but does not include utilities for generating new ones.

  • @turf/turf:

    The @turf/turf package provides some feature creation capabilities as part of its extensive geospatial functionality. However, it is not its primary focus. The package is more comprehensive, offering a wide range of tools for analysis, manipulation, and geometric operations.

Iterating Over Features

  • @turf/helpers:

    The @turf/helpers package does not provide specific functions for iterating over features. It focuses on feature creation and manipulation but does not include utilities for traversing or processing collections of features.

  • @turf/invariant:

    The @turf/invariant package does not include iteration functions. Its focus is on validating GeoJSON data rather than processing or iterating over features.

  • @turf/meta:

    The @turf/meta package specializes in iterating over features. It provides functions for traversing GeoJSON feature collections, applying transformations, and performing operations on multiple features efficiently. This package is ideal for developers who need to work with collections of features and perform batch processing or aggregation.

  • @turf/turf:

    The @turf/turf package includes some iteration capabilities as part of its geospatial toolkit. However, it is not specialized for iteration. The package provides functions that can operate on features and collections, but it does not focus exclusively on iterating over them.

Ease of Use: Code Examples

  • @turf/helpers:

    Creating a Point Feature with @turf/helpers

    import { point } from '@turf/helpers';
const myPoint = point([102.0, 0.5]);
console.log(myPoint);
  • @turf/invariant:

    Validating a GeoJSON Feature with @turf/invariant

    import { isValid } from '@turf/invariant';
const myFeature = {
type: 'Feature',
geometry: {
type: 'Point',
coordinates: [102.0, 0.5]
},
properties: {}
};
console.log(isValid(myFeature)); // true
  • @turf/meta:

    Iterating Over Features with @turf/meta

    import { featureEach } from '@turf/meta';
const featureCollection = {
type: 'FeatureCollection',
features: [
{ type: 'Feature', geometry: { type: 'Point', coordinates: [102.0, 0.5] }, properties: {} },
{ type: 'Feature', geometry: { type: 'Point', coordinates: [103.0, 1.0] }, properties: {} }
]
};
featureEach(featureCollection, (feature) => {
console.log(feature);
});
  • @turf/turf:

    Calculating Distance with @turf/turf

    import { distance } from '@turf/turf';
const point1 = [102.0, 0.5];
const point2 = [103.0, 1.0];
const dist = distance(point1, point2);
console.log(dist);
How to Choose: @turf/helpers vs @turf/invariant vs @turf/meta vs @turf/turf
  • @turf/helpers:

    Choose @turf/helpers if you need utility functions for creating and manipulating GeoJSON data. This package is ideal for developers who require a set of helper functions to work with geographic features, such as points, lines, and polygons, without needing the full functionality of the entire Turf.js library.

  • @turf/invariant:

    Select @turf/invariant if your project requires validation and type-checking for GeoJSON data. This package is essential for ensuring that the geographic data you work with conforms to the GeoJSON specification, making it a valuable tool for developers who need to validate, normalize, or enforce data integrity in their geospatial applications.

  • @turf/meta:

    Use @turf/meta when you need to perform operations that involve iterating over multiple GeoJSON features or collections. This package provides functions for efficiently traversing and manipulating collections of geographic features, making it useful for tasks such as aggregating data, applying transformations, or extracting information from complex GeoJSON structures.

  • @turf/turf:

    Opt for @turf/turf if you need a comprehensive geospatial library that includes a wide range of functions for spatial analysis, geometry manipulation, and geographic calculations. This package is suitable for developers who require a full-featured solution with extensive capabilities, including distance calculations, area measurements, and advanced geometric operations, all within a single package.

Similar Npm Packages to @turf/turf

@turf/turf is a comprehensive geospatial analysis library for JavaScript. It provides a wide range of functions for manipulating and analyzing geographic data, making it a popular choice for developers working with maps and spatial data. Turf.js is designed to work seamlessly with GeoJSON, allowing users to perform various operations such as calculating distances, creating buffers, and performing spatial joins. Its modular architecture means that you can include only the functions you need, keeping your application lightweight and efficient.

While Turf.js is a powerful tool for geospatial analysis, there are alternative packages within the Turf ecosystem that serve specific purposes:

  • @turf/helpers is a utility library that provides helper functions for creating and manipulating GeoJSON features and geometries. It simplifies the process of constructing GeoJSON objects, making it easier to work with geographic data in your applications. If you need to create or modify GeoJSON data structures, @turf/helpers is an essential companion to the main Turf.js library.

  • @turf/invariant focuses on providing invariant checks and validation for GeoJSON data. It ensures that the data you are working with adheres to the GeoJSON specification, helping to prevent errors and inconsistencies in your geospatial analyses. If your application relies heavily on the integrity of GeoJSON data, using @turf/invariant can enhance the reliability of your spatial computations.

  • @turf/meta offers functions for iterating over GeoJSON features and collections. It provides utilities for working with multiple features at once, allowing you to perform batch operations and analyses on collections of geographic data. If you frequently need to process or analyze multiple GeoJSON features together, @turf/meta can streamline your workflow.

To see how these packages compare, check out the comparison: Comparing @turf/helpers vs @turf/invariant vs @turf/meta vs @turf/turf.

README for @turf/helpers

@turf/helpers

helpers

Units

Linear measurement units.

⚠️ Warning. Be aware of the implications of using radian or degree units to measure distance. The distance represented by a degree of longitude varies depending on latitude.

See https://www.thoughtco.com/degree-of-latitude-and-longitude-distance-4070616 for an illustration of this behaviour.

Type: ("meters" | "metres" | "millimeters" | "millimetres" | "centimeters" | "centimetres" | "kilometers" | "kilometres" | "miles" | "nauticalmiles" | "inches" | "yards" | "feet" | "radians" | "degrees")

AreaUnits

Area measurement units.

Type: (Exclude<Units, ("radians" | "degrees")> | "acres" | "hectares")

Grid

Grid types.

Type: ("point" | "square" | "hex" | "triangle")

Corners

Shorthand corner identifiers.

Type: ("sw" | "se" | "nw" | "ne" | "center" | "centroid")

Lines

Geometries made up of lines i.e. lines and polygons.

Type: (LineString | MultiLineString | Polygon | MultiPolygon)

AllGeoJSON

Convenience type for all possible GeoJSON.

Type: (Feature | FeatureCollection | Geometry | GeometryCollection)

earthRadius

The Earth radius in kilometers. Used by Turf modules that model the Earth as a sphere. The mean radius was selected because it is recommended by the Haversine formula (used by turf/distance) to reduce error.

Type: number

factors

Unit of measurement factors based on earthRadius.

Keys are the name of the unit, values are the number of that unit in a single radian

Type: Record<Units, number>

areaFactors

Area of measurement factors based on 1 square meter.

Type: Record<AreaUnits, number>

feature

Wraps a GeoJSON Geometry in a GeoJSON Feature.

Parameters

  • geom (G | null)

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the Feature

  • geometry GeometryObject input geometry

Examples

var geometry = {
  "type": "Point",
  "coordinates": [110, 50]
};

var feature = turf.feature(geometry);

//=feature

Returns Feature<GeometryObject, GeoJsonProperties> a GeoJSON Feature

geometry

Creates a GeoJSON Geometry from a Geometry string type & coordinates. For GeometryCollection type use helpers.geometryCollection

Parameters

  • type ("Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon") Geometry Type
  • coordinates Array<any> Coordinates
  • _options Record<string, never> (optional, default {})
  • options Object Optional Parameters (optional, default {})

Examples

var type = "Point";
var coordinates = [110, 50];
var geometry = turf.geometry(type, coordinates);
// => geometry

Returns Geometry a GeoJSON Geometry

point

Creates a Point Feature from a Position.

Parameters

  • coordinates Position longitude, latitude position (each in decimal degrees)

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the Feature

Examples

var point = turf.point([-75.343, 39.984]);

//=point

Returns Feature<Point, GeoJsonProperties> a Point feature

points

Creates a Point FeatureCollection from an Array of Point coordinates.

Parameters

  • coordinates Array<Position> an array of Points

  • properties GeoJsonProperties Translate these properties to each Feature (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the FeatureCollection
    • options.id Id? Identifier associated with the FeatureCollection

Examples

var points = turf.points([
  [-75, 39],
  [-80, 45],
  [-78, 50]
]);

//=points

Returns FeatureCollection<Point> Point Feature

polygon

Creates a Polygon Feature from an Array of LinearRings.

Parameters

  • coordinates Array<Array<Position>>

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the Feature

Examples

var polygon = turf.polygon([[[-5, 52], [-4, 56], [-2, 51], [-7, 54], [-5, 52]]], { name: 'poly1' });

//=polygon

Returns Feature<Polygon, GeoJsonProperties> Polygon Feature

polygons

Creates a Polygon FeatureCollection from an Array of Polygon coordinates.

Parameters

  • coordinates Array<Array<Array<Position>>>

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the FeatureCollection

Examples

var polygons = turf.polygons([
  [[[-5, 52], [-4, 56], [-2, 51], [-7, 54], [-5, 52]]],
  [[[-15, 42], [-14, 46], [-12, 41], [-17, 44], [-15, 42]]],
]);

//=polygons

Returns FeatureCollection<Polygon, GeoJsonProperties> Polygon FeatureCollection

lineString

Creates a LineString Feature from an Array of Positions.

Parameters

  • coordinates Array<Position> an array of Positions

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the Feature

Examples

var linestring1 = turf.lineString([[-24, 63], [-23, 60], [-25, 65], [-20, 69]], {name: 'line 1'});
var linestring2 = turf.lineString([[-14, 43], [-13, 40], [-15, 45], [-10, 49]], {name: 'line 2'});

//=linestring1
//=linestring2

Returns Feature<LineString, GeoJsonProperties> LineString Feature

lineStrings

Creates a LineString FeatureCollection from an Array of LineString coordinates.

Parameters

  • coordinates Array<Array<Position>>

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the FeatureCollection
    • options.id Id? Identifier associated with the FeatureCollection

Examples

var linestrings = turf.lineStrings([
  [[-24, 63], [-23, 60], [-25, 65], [-20, 69]],
  [[-14, 43], [-13, 40], [-15, 45], [-10, 49]]
]);

//=linestrings

Returns FeatureCollection<LineString, GeoJsonProperties> LineString FeatureCollection

featureCollection

Takes one or more Features and creates a FeatureCollection.

Parameters

  • features Array<Feature<GeometryObject, GeoJsonProperties>> input features

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the Feature

Examples

var locationA = turf.point([-75.343, 39.984], {name: 'Location A'});
var locationB = turf.point([-75.833, 39.284], {name: 'Location B'});
var locationC = turf.point([-75.534, 39.123], {name: 'Location C'});

var collection = turf.featureCollection([
  locationA,
  locationB,
  locationC
]);

//=collection

Returns FeatureCollection<GeometryObject, GeoJsonProperties> FeatureCollection of Features

multiLineString

Creates a Feature<MultiLineString> based on a coordinate array. Properties can be added optionally.

Parameters

  • coordinates Array<Array<Position>>

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the Feature

Examples

var multiLine = turf.multiLineString([[[0,0],[10,10]]]);

//=multiLine
  • Throws Error if no coordinates are passed

Returns Feature<MultiLineString, GeoJsonProperties> a MultiLineString feature

multiPoint

Creates a Feature<MultiPoint> based on a coordinate array. Properties can be added optionally.

Parameters

  • coordinates Array<Position> an array of Positions

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the Feature

Examples

var multiPt = turf.multiPoint([[0,0],[10,10]]);

//=multiPt
  • Throws Error if no coordinates are passed

Returns Feature<MultiPoint, GeoJsonProperties> a MultiPoint feature

multiPolygon

Creates a Feature<MultiPolygon> based on a coordinate array. Properties can be added optionally.

Parameters

  • coordinates Array<Array<Array<Position>>>

  • properties GeoJsonProperties an Object of key-value pairs to add as properties (optional, default {})

  • options Object Optional Parameters (optional, default {})

    • options.bbox BBox? Bounding Box Array [west, south, east, north] associated with the Feature
    • options.id Id? Identifier associated with the Feature

Examples

var multiPoly = turf.multiPolygon([[[[0,0],[0,10],[10,10],[10,0],[0,0]]]]);

//=multiPoly
  • Throws Error if no coordinates are passed

Returns Feature<MultiPolygon, GeoJsonProperties> a multipolygon feature

geometryCollection

Creates a Feature based on a coordinate array. Properties can be added optionally.

Parameters

Examples

var pt = turf.geometry("Point", [100, 0]);
var line = turf.geometry("LineString", [[101, 0], [102, 1]]);
var collection = turf.geometryCollection([pt, line]);

// => collection

Returns Feature<GeometryCollection, GeoJsonProperties> a GeoJSON GeometryCollection Feature

round

Round number to precision

Parameters

  • num number Number
  • precision number Precision (optional, default 0)

Examples

turf.round(120.4321)
//=120

turf.round(120.4321, 2)
//=120.43

Returns number rounded number

radiansToLength

Convert a distance measurement (assuming a spherical Earth) from radians to a more friendly unit. Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet

Parameters

  • radians number in radians across the sphere
  • units Units can be degrees, radians, miles, inches, yards, metres, meters, kilometres, kilometers. (optional, default "kilometers")

Returns number distance

lengthToRadians

Convert a distance measurement (assuming a spherical Earth) from a real-world unit into radians Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet

Parameters

  • distance number in real units
  • units Units can be degrees, radians, miles, inches, yards, metres, meters, kilometres, kilometers. (optional, default "kilometers")

Returns number radians

lengthToDegrees

Convert a distance measurement (assuming a spherical Earth) from a real-world unit into degrees Valid units: miles, nauticalmiles, inches, yards, meters, metres, centimeters, kilometres, feet

Parameters

  • distance number in real units
  • units Units can be degrees, radians, miles, inches, yards, metres, meters, kilometres, kilometers. (optional, default "kilometers")

Returns number degrees

bearingToAzimuth

Converts any bearing angle from the north line direction (positive clockwise) and returns an angle between 0-360 degrees (positive clockwise), 0 being the north line

Parameters

  • bearing number angle, between -180 and +180 degrees

Returns number angle between 0 and 360 degrees

azimuthToBearing

Converts any azimuth angle from the north line direction (positive clockwise) and returns an angle between -180 and +180 degrees (positive clockwise), 0 being the north line

Parameters

  • angle number between 0 and 360 degrees

Returns number bearing between -180 and +180 degrees

radiansToDegrees

Converts an angle in radians to degrees

Parameters

  • radians number angle in radians

Returns number degrees between 0 and 360 degrees

degreesToRadians

Converts an angle in degrees to radians

Parameters

  • degrees number angle between 0 and 360 degrees

Returns number angle in radians

convertLength

Converts a length from one unit to another.

Parameters

  • length number Length to be converted
  • originalUnit Units Input length unit (optional, default "kilometers")
  • finalUnit Units Returned length unit (optional, default "kilometers")

Returns number The converted length

convertArea

Converts an area from one unit to another.

Parameters

  • area number Area to be converted
  • originalUnit AreaUnits Input area unit (optional, default "meters")
  • finalUnit AreaUnits Returned area unit (optional, default "kilometers")

Returns number The converted length

isNumber

isNumber

Parameters

  • num any Number to validate

Examples

turf.isNumber(123)
//=true
turf.isNumber('foo')
//=false

Returns boolean true/false

isObject

isObject

Parameters

  • input any variable to validate

Examples

turf.isObject({elevation: 10})
//=true
turf.isObject('foo')
//=false

Returns boolean true/false, including false for Arrays and Functions

This module is part of the Turfjs project, an open source module collection dedicated to geographic algorithms. It is maintained in the Turfjs/turf repository, where you can create PRs and issues.

Installation

Install this single module individually:

$ npm install @turf/helpers

Or install the all-encompassing @turf/turf module that includes all modules as functions:

$ npm install @turf/turf
npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.