react-map-gl

react-map-gl provides a React friendly
API wrapper around Mapbox GL JS. A webGL
based vector tile mapping library.

WARNING: This project is new and the API may change. There also may be Mapbox
APIs that haven't yet been exposed.

See the interactive docs at: https://uber.github.io/react-map-gl

Overview

Installation

npm install react-map-gl --save

Usage

var MapGL = require('react-map-gl');

<MapGL width={400} height={400} latitude={37.7577} longitude={-122.4376}
  zoom={8} onChangeViewport={(viewport) => {
    var {latitude, longitude, zoom} = viewport;
    // Optionally call `setState` and use the state to update the map.
  }}
/>

Using overlays

react-map-gl provides an overlay API so you can use the built-in visualization
overlays, or create your own. Here's an example of using the build in
ScatterplotOverlay.

var ScatterplotOverlay = require('react-map-gl/src/overlays/scatterplot.react');
// ...
<MapGL {...viewport}>
  <ScatterplotOverlay
    {...viewport}
    locations={locations}
    dotRadius={4}
    globalOpacity={1}
    compositeOperation="screen" />
  // Add additional overlays here...
])

Built in overlays

1. ChoroplethOverlay
2. ScatterplotOverlay
3. DraggablePointsOverlay
4. SVGOverlay
5. CanvasOverlay

Third party overlays

Other third party overlays can also be created. For example, the
heatmap-overlay uses
webgl-heatmap to create geographic
heatmaps.

Example usage:

var HeatmapOverlay = require('react-map-gl-heatmap-overlay');
var cities = require('example-cities');
// ...
    render: function render() {
      return <MapGL {...viewport}>
        return <HeatmapOverlay locations={cities} {...viewport}/>
      </MapGL>;
    }

Want to create and share your own overlay? Fork the
react-map-gl-example-overlay
project to get started.

ImmutableJS all the things

The mapStyle property of the MapGL as well as several of the built in
overlay properties must be provided as
ImmutableJS objects. This allows
the library to be fast since computing changes to props only involves checking
if the immutable objects are the same instance.

Development

To develop on this component, install the dependencies and then build and watch
the static files.

$ npm install

To serve example app:

$ npm start &
$ open "http://localhost:9966/?access_token="`echo $MapboxAccessToken`

Where echo $MapboxAccessToken returns your Mapbox access token.

Once complete, you can view the component in your browser at
localhost:9966. Any changes you make will automatically
run the compiler to build the files again.

Testing

It's particularly difficult to write tests for this component beacuse it uses WebGL. There are some tests in test/ but for the most part, as new features are added, we typically test drive them by running npm run start and play with the demos.

CHANGE LOG

0.6

Support for React 0.14 as well as several other API changes

Breaking changes

No longer provide viewport props transparently to overlay children.

Require viewport props to be explicitly provided to overlays. Previously,
viewport overlay props all had to be optional because the elements were created
once and then cloned inside of <MapGL>. This also made it difficult to follow
what props were being passed automatically to overlays. In addition, it meant
that overlays could only be direct children of the <MapGL> element.

This shouldn't require changes to overlays, other than marking viewport props
as required. It will only involve passing the needed props explicitly to
overlays.

Old way:

<MapGL {...viewport}>
  <Overlay1 />
  <Overlay2 />
</MapGL>

New way:

<MapGL {...viewport}>
  <Overlay1 {...viewport}/>
  <Overlay2 {...viewport}/>
</MapGL>

For any third party overlay's that depend on project or unproject props,
either update them to calculate the project/unproject functions from the
viewport using the ViewportMercatorProject module or provide them explicitly in the same render function as the
<MapGL/> component. example:

var ViewportMercator = require('viewport-mercator-project');
// ...
  render() {
    var mercator = ViewportMercator(this.state.viewport);
    return <MapGL ...viewport>
      <Overlay1
        project={mercator.project}
        unproject={this.mercator.unproject
        {...viewport}/>
      {/* or equivalently */}
      <Overlay2 {...mercator} {...viewport}/>
    </MapGL>;
  }
</MapGL>

Swapping LatLng for LngLat

This is more inline with
MapboxGL-js and GeoJSON.

Accessors that were previously latLngAccessor are have been renamed to
lngLatAccessor.

Rename the viewport prop startDragLatLng to startDragLngLat.

The project function prop passed to overlays now expecteds an array of
the form [longitude, latitude] instead of [latitude, longitude].

The project function prop now returns an array of [pixelX, pixelY] instead
of an object of the form {x:pixelX, y: pixelY}.

The unproject function prop passed to overlays now returns an array of
the form [longitude, latitude] instead of a MapboxGL
LngLat object.

DraggablePointsOverlay's locationAccessor prop was renamed lngLatAccessor
to be more consistent with other overlays.

bbox property of the onChangeViewport event was removed

This should be calculated instead using the ViewportMercatorProject module instead.

var mercator = ViewportMercator(viewport);
var bbox = [mercator.unproject([0, 0]), mercator.unproject([width, height])];

Non-breaking changes

unproject was added to the arguments passed to the redraw callback in the
CanvasOverlay.

Disclaimer

This project is not affiliated with either Facebook or Mapbox.

Example Data

1. SF GeoJSON data from: SF OpenData.