You’re probably asking “But, why?” Well, it’s because it will give you an error if you bind the map to a container that doesn’t exist just yet.

Uncaught Error: Map container not found

Creating A Map

Now, onto the fun part. To initialize the map, we pass in our div to L.map() with some options.

const myMap = L.map('mapid', {
 center: [37.7749, -122.4194],
  zoom: 13
})

Let’s go step by step to understand what just happened. We use Map class of Leaflet API to create a map on the page. We pass in two parameters to this class:

1. We passed in a string variable representing the DOM ID
2. An optional object literal with map options

There are many options we could pass to our class, but the main two options are the center and zoom. The center defines an initial geographic center of the map while zoom specifies an initial map zoom level. They both are undefined by default.

For the center, we passed in San Francisco’s coordinates. There are a lot of places where we can perform forward and reverse geocoding, but for basic search such as this, we can google it.

Usually, the value for zoom will depend on what you want to display. Do you want to show a city or a state? Country or a continent? Go ahead and play around with the zoom value to get a better idea. For this example, we chose 13 because it shows the entire city.

Another way of initializing the map is by using setView(). It takes the in an array of coordinates and an integer for the zoom level.

const myMap = L.map('map').setView([37.7749, -122.4194], 13);

By default, all mouse and touch interactions on the map are enabled, and it has zoom and attribution controls.

Creating A Layer

Next, we’ll add a tile layer to our map; in our case, it’s a Mapbox Streets tile layer. We can append various types of tile layers by instantiating the TileLayer class.

To create a tile layer, we need to set the URL template for the tile image, the attribution text, and the maximum zoom level of the layer. The URL template is what gives us access to the desired tile layer from the service provider. Since we are using Mapbox’s Static Tiles API, we will need to request an access token.

L.tileLayer('https://api.mapbox.com/styles/v1/{id}/tiles/{z}/{x}/{y}?access_token={accessToken}', { 
attribution: 'Map data © <a href="https://www.openstreetmap.org/">OpenStreetMap</a> contributors, <a href="https://creativecommons.org/licenses/by-sa/2.0/">CC-BY-SA</a>, Imagery (c) <a href="https://www.mapbox.com/">Mapbox</a>',
maxZoom: 18, 
id: 'mapbox/streets-v11', 
accessToken: 'your.mapbox.access.token' }).addTo(mymap);

At this point, if we open our index.html in a browser, we should be able to see a map of San Francisco. Let’s drop a pin on the map.

Markers And Circles

We’ve got the map and the layer, but it doesn’t point us to anything specific. To point to a particular location on the map, Leaflet provides us with markers.

To pin a location, we instantiate the marker using the Marker class, pass in the coordinates, and add it to the map. Here we are using the coordinates of Twin Peaks in the city.

const marker = L.marker([37.7544, -122.4477]).addTo(mymap);

Similarly, we can bind a circle to the map using a Circle class. We pass in a few optional options, such as radius, color, and so on. For the circle marker, we are passing in the coordinates of Point Bonita Lighthouse.

const circle = L.circle([37.8157, -122.5295], {
 color: 'gold',
 fillColor: '#f03',
 fillOpacity: 0.5,
 radius: 200
}).addTo(mymap);

Popups

This is all great, but what if we want to pass in some more information about the location. We do this using popup.

circle.bindPopup("I am pointing to Point Bonita Lighthouse");

marker.bindPopup("I am pointing to Twin Peaks");

The bindPopup method takes in a specified HTML content and appends it to the marker, so the popup appears when you click on the marker.

React-Leaflet

Now we know how to create a map, and add markers using Leaflet and vanilla JavaScript. Let’s see how we can achieve the same results with React. We aren’t going to make the same application but instead make an advanced application.

The first task for us is to get an access token from the San Francisco Open Data portal. It’s an online portal where we can find hundreds of datasets from the City and County of San Francisco. I decided to use this resource, but there are plenty of other resources out there that we can use instead.

Access API Key

1. Make an account and sign-in to the portal.
2. Click on the manage link towards the bottom-right.
3. Click on Create New API Key and give it a name.
4. Copy your Key ID and Key Secret. You’d need this to access the data.

For this, we will use React-Leaflet – react components for Leaflet maps. Let’s create a react app.

npx create-react-app react-fire-incidents
cd react-fire-incidents

Then let’s install react-leaflet, and Leaflet by running the following command in our terminal:

npm install react-leaflet leaflet

App.js

Let’s create a folder /components inside src. Inside components, let’s create a file named Map.js. This is where our Map will live. Now let’s edit App.js by removing unnecessary code and importing modules from react-leaflet axios and the newly created Map.js.

import React, { Component, Fragment } from 'react';
import axios from 'axios';
import Map from './components/Map'

In our App class, we are going to define an array in our state called incidents — when the page loads, we will push our data into this array.

class App extends Component {
 state = {
   incidents: [],
 }
 render() {
   return (
     <div> </div>
   );
 }
}
export default App;

Next, we will make a GET request when the component mounts. We have the app token, but we still need an endpoint. Where do we find the endpoint?

Let’s head over to the portal and click on Browse Data. In the search bar, let’s search for fire incidents. The first result that shows up is what we are looking for. Once we click on the link, we can get the URL by clicking the API button on the top-right.

We will pass in the endpoint to our GET request, and pass in a limit and our app token as parameters. The original data has thousands of records, but for the sake of keeping things simple, we have limited it to 500. We update our incidents array with our results.

Once we get the data, we update our state.

async componentDidMount() {
   const res = await axios.get('https://data.sfgov.org/resource/wr8u-xric.json', {
     params: {
       "$limit": 500,
       "$$app_token": YOUR_APP_TOKEN
     }
   })
   const incidents = res.data;
   this.setState({incidents: incidents });
 };

This is what our App.js should look like.

class App extends Component {
state = {
  incidents: [],
}

async componentDidMount() {
 const res = await axios.get('https://data.sfgov.org/resource/wr8u-xric.json', {
   params: {
     "$limit": 500,
     "$$app_token": YOUR_APP_TOKEN
   }
 })
 const incidents = res.data;
 this.setState({incidents: incidents });
};
render() {
 return (
<Map incidents={this.state.incidents}/>
 );
}
}
export default App;

Map.js

Since we already know how to create a Leaflet map, this part will be relatively easy. We will import Map, TileLayer, Marker, Popup components from react-leaflet.

import React, { Component } from 'react'
import { Map, TileLayer, Marker, Popup } from 'react-leaflet'

If we remember from the previous example, we need coordinates and a zoom level for initializing the map. In our Map class, we define them in our state using lat, lng and zoom variables.

export default class Map extends Component {
   state = {
       lat: 37.7749,
       lng: -122.4194,
       zoom: 13,
   }
   render() {
       return (
     <div></div>
        )
    }
}

Then we will check whether our array of incidents is empty. If it’s empty, we will return a message saying “Data is Loading”; otherwise, we will return a map.

In our react-leaflet‘s Map component, we will pass center coordinates and a zoom level along with some styling. In our TileLayer component, we will pass attribution and URL similar to our previous example.

render() {
       return (
          this.props.incidents ?
              <Map 
                 center={[this.state.lat, this.state.lng]} 
                 zoom={this.state.zoom} 
                 style={{ width: '100%', height: '900px'}}
              >
              <TileLayer
                attribution='&copy <a href="http://osm.org/copyright">OpenStreetMap</a> contributors'
                url="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
               />
             </Map>
               :
               'Data is loading...'
       )
   }
}

Next, we loop over our props.incident and pass in the coordinates of every incident to the Marker component. Since React warns us to pass a key to every item in an array, we will pass in a key to Marker as well.

Inside the Marker component, we pass in a Popup component. I’ve added some information about the incident inside the popup.

<Map 
    center={[this.state.lat, this.state.lng]} 
    zoom={this.state.zoom} 
    style={{ width: '100%', height: '900px'}}>
       <TileLayer
          attribution='&copy <a href="http://osm.org/copyright">OpenStreetMap</a> contributors'
          url="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
        />
        {
          this.props.incidents.map(incident => {
               const point = [incident['point']['coordinates'][1],                 incident['point']['coordinates'][0]]
         

return (
    <Marker position={point} key={incident['incident_number']} >
         <Popup>
            <span>ADDRESS: {incident['address']}, {incident['city']} - {incident['zip_code']}</span>
          <br/>
            <span>BATTALION: {incident['battalion']}</span><br/>
         </Popup>
     </Marker>
  )
 })
}
</Map>

And this is it. If we run our app, and if everything went fine, we should be able to see a map of San Francisco with 500 markers pointing us to the locations of the fire-incidents. If we click on one of those markers, a popup will appear with more information about the incident.

Wrapping Up

Even though we covered a lot, this was just the basics. Leaflet is a very powerful tool, and we can create a lot of different kinds of maps. If you want to play around, try adding another layer or a custom icon. Or maybe you would like to create an interactive Choropleth Map.