Use setData operation when diffing geojson sources

src/source/source.js

@@ -57,6 +57,7 @@ export interface Source {
 
     +onAdd?: (map: Map) => void;
     +onRemove?: (map: Map) => void;
+    +setData?: (data: GeoJSON | string) => Source;
 
     loadTile(tile: Tile, callback: Callback<void>): void;
     +hasTile?: (coord: TileCoord) => boolean;

src/source/source_cache.js

@@ -102,6 +102,12 @@ class SourceCache extends Evented {
         }
     }
 
+    setData(data: GeoJSON | string) {
+        if (this._source && this._source.setData) {
+            this._source.setData(data);
+        }
+    }
+
     /**
      * Return true if no tile data is pending, tiles will not change unless
      * an additional API call is received.

src/style-spec/diff.js

@@ -43,6 +43,11 @@ const operations = {
      */
     removeSource: 'removeSource',
 
+    /*
+     * { command: 'setData', args: ['sourceId', data] }
+     */
+    setData: 'setData',
+
     /*
      * { command: 'setLayerZoomRange', args: ['layerId', 0, 22] }
      */
@@ -117,10 +122,15 @@ function diffSources(before, after, commands, sourcesRemoved) {
         if (!before.hasOwnProperty(sourceId)) {
             commands.push({ command: operations.addSource, args: [sourceId, after[sourceId]] });
         } else if (!isEqual(before[sourceId], after[sourceId])) {
-            // no update command, must remove then add
-            commands.push({ command: operations.removeSource, args: [sourceId] });
-            commands.push({ command: operations.addSource, args: [sourceId, after[sourceId]] });
-            sourcesRemoved[sourceId] = true;
+            if (before[sourceId].type === 'geojson' && after[sourceId].type === 'geojson') {
+                // geojson sources use setData command to update
+                commands.push({ command: operations.setData, args: [sourceId, after[sourceId].data] });
+            } else {
+                // no update command, must remove then add
+                commands.push({ command: operations.removeSource, args: [sourceId] });
+                commands.push({ command: operations.addSource, args: [sourceId, after[sourceId]] });
+                sourcesRemoved[sourceId] = true;
+            }
         }
     }
 }

src/style/style.js

@@ -42,7 +42,8 @@ const supportedDiffOperations = util.pick(diff.operations, [
     'removeSource',
     'setLayerZoomRange',
     'setLight',
-    'setTransition'
+    'setTransition',
+    'setData'
     // 'setGlyphs',
     // 'setSprite',
 ]);
@@ -500,6 +501,27 @@ class Style extends Evented {
         this._changed = true;
     }
 
+    /**
+    * Set the data of a source, given its id. Only available for GeoJSON sources.
+    * @param {string} id id of the source
+    * @param {GeoJSON|string} data GeoJSON source
+    * @throws {Error} if no source is found with the given ID
+    */
+
+    setData(id: string, data: GeoJSON | string) {
+        this._checkLoaded();
+
+        if (this.sourceCaches[id] === undefined) {
+            throw new Error('There is no source with this ID');
+        }
+
+
+        const sourceCache = this.sourceCaches[id];
+
+        sourceCache.setData(data);
+        this._changed = true;
+    }
+
     /**
      * Get a source by id.
      * @param {string} id id of the desired source

test/unit/style-spec/diff.test.js

@@ -111,6 +111,36 @@ t('diff', (t) => {
         { command: 'addSource', args: ['foo', 1] }
     ], 'add a source');
 
+    t.deepEqual(diffStyles({
+        sources: {
+            foo: {
+                type: 'geojson',
+                data: { type: 'FeatureCollection', features: [] }
+            }
+        }
+    }, {
+        sources: {
+            foo: {
+                type: 'geojson',
+                data: {
+                    type: 'FeatureCollection',
+                    features: [{
+                        type: 'Feature',
+                        geometry: { type: 'Point', coordinates: [10, 20] }
+                    }]
+                }
+            }
+        }
+    }), [
+        { command: 'setData', args: ['foo', {
+            type: 'FeatureCollection',
+            features: [{
+                type: 'Feature',
+                geometry: { type: 'Point', coordinates: [10, 20] }
+            }]
+        }]}
+    ], 'update a geojson source');
+
     t.deepEqual(diffStyles({}, {
         metadata: { 'mapbox:author': 'nobody' }
     }), [], 'ignore style metadata');

test/unit/style/style.test.js

@@ -405,6 +405,7 @@ test('Style#setState', (t) => {
             'setFilter',
             'addSource',
             'removeSource',
+            'setData',
             'setLayerZoomRange',
             'setLight'
         ].forEach((method) => t.stub(style, method).callsFake(() => t.fail(`${method} called`)));
@@ -644,6 +645,64 @@ test('Style#removeSource', (t) => {
     t.end();
 });
 
+test('Style#setData', (t) => {
+    t.test('throw before loaded', (t) => {
+        const style = new Style(createStyleJSON({
+            "sources": { "source-id": createGeoJSONSource() }
+        }), new StubMap());
+        const geoJSONSourceData = {
+            "type": "FeatureCollection",
+            "features": [
+                {
+                    "type": "Feature",
+                    "geometry": { "type": "Point", "coordinates": [125.6, 10.1] }
+                }
+            ]
+        };
+        t.throws(() => {
+            style.setData('source-id', geoJSONSourceData);
+        }, Error, /load/i);
+        style.on('style.load', () => {
+            t.end();
+        });
+    });
+
+    t.test('throws on non-existence', (t) => {
+        const style = new Style(createStyleJSON(), new StubMap()),
+            geoJSONSourceData = { type: "FeatureCollection", "features": [] };
+        style.on('style.load', () => {
+            t.throws(() => {
+                style.setData('source-id', geoJSONSourceData);
+            }, /There is no source with this ID/);
+            t.end();
+        });
+    });
+
+    t.test('sets data of source', (t) => {
+        const style = new Style(createStyleJSON({
+            sources: {'source-id': createGeoJSONSource()}
+        }), new StubMap());
+        const geoJSONSourceData = {
+            "type": "FeatureCollection",
+            "features": [
+                {
+                    "type": "Feature",
+                    "geometry": { "type": "Point", "coordinates": [125.6, 10.1] }
+                }
+            ]
+        };
+        style.on('style.load', () => {
+            const sourceCache = style.sourceCaches['source-id'];
+            t.spy(sourceCache, 'setData');
+            style.setData('source-id', geoJSONSourceData);
+            t.ok(sourceCache.setData.calledWith(geoJSONSourceData));
+            t.end();
+        });
+    });
+
+    t.end();
+});
+
 test('Style#addLayer', (t) => {
     t.test('throw before loaded', (t) => {
         const style = new Style(createStyleJSON(), new StubMap()),