leaflet-js 0.6.beta4 → 0.7.0

data/lib/leaflet/spec/suites/geo/LatLngSpec.js

@@ -1,6 +1,6 @@
-describe('LatLng', function() {
-	describe('constructor', function() {
-		it("sets lat and lng", function() {
+describe('LatLng', function () {
+	describe('constructor', function () {
+		it("sets lat and lng", function () {
 			var a = new L.LatLng(25, 74);
 			expect(a.lat).to.eql(25);
 			expect(a.lng).to.eql(74);
@@ -15,16 +15,30 @@ describe('LatLng', function() {
 				var a = new L.LatLng(NaN, NaN);
 			}).to.throwError();
 		});
+
+		it('does not set altitude if undefined', function () {
+			var a = new L.LatLng(25, 74);
+			expect(typeof a.alt).to.eql('undefined');
+		});
+
+		it('sets altitude', function () {
+			var a = new L.LatLng(25, 74, 50);
+			expect(a.alt).to.eql(50);
+
+			var b = new L.LatLng(-25, -74, -50);
+			expect(b.alt).to.eql(-50);
+		});
+
 	});
 
-	describe('#equals', function() {
-		it("returns true if compared objects are equal within a certain margin", function() {
+	describe('#equals', function () {
+		it("returns true if compared objects are equal within a certain margin", function () {
 			var a = new L.LatLng(10, 20);
 			var b = new L.LatLng(10 + 1.0E-10, 20 - 1.0E-10);
 			expect(a.equals(b)).to.eql(true);
 		});
 
-		it("returns false if compared objects are not equal within a certain margin", function() {
+		it("returns false if compared objects are not equal within a certain margin", function () {
 			var a = new L.LatLng(10, 20);
 			var b = new L.LatLng(10, 23.3);
 			expect(a.equals(b)).to.eql(false);
@@ -37,7 +51,7 @@ describe('LatLng', function() {
 	});
 
 	describe('#wrap', function () {
-		it("wraps longitude to lie between -180 and 180 by default", function() {
+		it("wraps longitude to lie between -180 and 180 by default", function () {
 			var a = new L.LatLng(0, 190).wrap().lng;
 			expect(a).to.eql(-170);
 
@@ -63,7 +77,7 @@ describe('LatLng', function() {
 			expect(h).to.eql(180);
 		});
 
-		it("wraps longitude within the given range", function() {
+		it("wraps longitude within the given range", function () {
 			var a = new L.LatLng(0, 190).wrap(-100, 100).lng;
 			expect(a).to.eql(-10);
 		});

data/lib/leaflet/spec/suites/geo/ProjectionSpec.js

@@ -1,47 +1,48 @@
-describe("Projection.Mercator", function() {
+describe("Projection.Mercator", function () {
 	var p = L.Projection.Mercator;
 
-	expect.Assertion.prototype.near = function(expected, delta) {
-		delta = delta || 1;
-		expect(this.obj.x).to
-			.be.within(expected.x - delta, expected.x + delta);
-		expect(this.obj.y).to
-			.be.within(expected.y - delta, expected.y + delta);
-	};
-
-	describe("#project", function() {
-		it("projects a center point", function() {
+	describe("#project", function () {
+		it("projects a center point", function () {
 			//edge cases
 			expect(p.project(new L.LatLng(0, 0))).near(new L.Point(0, 0));
 		});
 
-		it("projects the northeast corner of the world", function() {
-			expect(p.project(new L.LatLng(90, 180))).near(new L.Point(20037508.342789244, 19970326.50745906));
+		it("projects the northeast corner of the world", function () {
+			expect(p.project(new L.LatLng(90, 180))).near(new L.Point(20037508, 20037508));
 		});
 
-		it("projects the southwest corner of the world", function() {
-			expect(p.project(new L.LatLng(-90, -180))).near(new L.Point(-20037508, -19970326));
+		it("projects the southwest corner of the world", function () {
+			expect(p.project(new L.LatLng(-90, -180))).near(new L.Point(-20037508, -20037508));
 		});
 
-		it("projects 50, 30", function() {
-			 expect(p.project(new L.LatLng(50, 30))).near(new L.Point(3339584, 6392021));
+		it("projects other points", function () {
+			expect(p.project(new L.LatLng(50, 30))).near(new L.Point(3339584, 6413524));
+
+			// from https://github.com/Leaflet/Leaflet/issues/1578
+			expect(p.project(new L.LatLng(51.9371170300465, 80.11230468750001)))
+			        .near(new L.Point(8918060.964088084, 6755099.410887127));
 		});
 	});
 
-	describe("#unproject", function() {
+	describe("#unproject", function () {
 		function pr(point) {
 			return p.project(p.unproject(point));
 		}
 
-		it("unprojects a center point", function() {
+		it("unprojects a center point", function () {
 			expect(pr(new L.Point(0, 0))).near(new L.Point(0, 0));
 		});
 
-		it("pi points", function() {
+		it("unprojects pi points", function () {
 			expect(pr(new L.Point(-Math.PI, Math.PI))).near(new L.Point(-Math.PI, Math.PI));
 			expect(pr(new L.Point(-Math.PI, -Math.PI))).near(new L.Point(-Math.PI, -Math.PI));
 
 			expect(pr(new L.Point(0.523598775598, 1.010683188683))).near(new L.Point(0.523598775598, 1.010683188683));
 		});
+
+		it('unprojects other points', function () {
+			// from https://github.com/Leaflet/Leaflet/issues/1578
+			expect(pr(new L.Point(8918060.964088084, 6755099.410887127)));
+		});
 	});
 });

data/lib/leaflet/spec/suites/geometry/BoundsSpec.js

@@ -1,7 +1,7 @@
-describe('Bounds', function() {
+describe('Bounds', function () {
 	var a, b, c;
 
-	beforeEach(function() {
+	beforeEach(function () {
 		a = new L.Bounds(
 			new L.Point(14, 12),
 			new L.Point(30, 40));
@@ -13,19 +13,19 @@ describe('Bounds', function() {
 		c = new L.Bounds();
 	});
 
-	describe('constructor', function() {
-		it('creates bounds with proper min & max on (Point, Point)', function() {
+	describe('constructor', function () {
+		it('creates bounds with proper min & max on (Point, Point)', function () {
 			expect(a.min).to.eql(new L.Point(14, 12));
 			expect(a.max).to.eql(new L.Point(30, 40));
 		});
-		it('creates bounds with proper min & max on (Point[])', function() {
+		it('creates bounds with proper min & max on (Point[])', function () {
 			expect(b.min).to.eql(new L.Point(14, 12));
 			expect(b.max).to.eql(new L.Point(30, 40));
 		});
 	});
 
-	describe('#extend', function() {
-		it('extends the bounds to contain the given point', function() {
+	describe('#extend', function () {
+		it('extends the bounds to contain the given point', function () {
 			a.extend(new L.Point(50, 20));
 			expect(a.min).to.eql(new L.Point(14, 12));
 			expect(a.max).to.eql(new L.Point(50, 40));
@@ -36,14 +36,14 @@ describe('Bounds', function() {
 		});
 	});
 
-	describe('#getCenter', function() {
-		it('returns the center point', function() {
+	describe('#getCenter', function () {
+		it('returns the center point', function () {
 			expect(a.getCenter()).to.eql(new L.Point(22, 26));
 		});
 	});
 
-	describe('#contains', function() {
-		it('contains other bounds or point', function() {
+	describe('#contains', function () {
+		it('contains other bounds or point', function () {
 			a.extend(new L.Point(50, 10));
 			expect(a.contains(b)).to.be.ok();
 			expect(b.contains(a)).to.not.be.ok();
@@ -52,14 +52,14 @@ describe('Bounds', function() {
 		});
 	});
 
-	describe('#isValid', function() {
-		it('returns true if properly set up', function() {
+	describe('#isValid', function () {
+		it('returns true if properly set up', function () {
 			expect(a.isValid()).to.be.ok();
 		});
-		it('returns false if is invalid', function() {
+		it('returns false if is invalid', function () {
 			expect(c.isValid()).to.not.be.ok();
 		});
-		it('returns true if extended', function() {
+		it('returns true if extended', function () {
 			c.extend([0, 0]);
 			expect(c.isValid()).to.be.ok();
 		});

data/lib/leaflet/spec/suites/geometry/PointSpec.js

@@ -1,42 +1,42 @@
-describe("Point", function() {
+describe("Point", function () {
 
-	describe('constructor', function() {
+	describe('constructor', function () {
 
-		it("creates a point with the given x and y", function() {
+		it("creates a point with the given x and y", function () {
 			var p = new L.Point(1.5, 2.5);
 			expect(p.x).to.eql(1.5);
 			expect(p.y).to.eql(2.5);
 		});
 
-		it("rounds the given x and y if the third argument is true", function() {
+		it("rounds the given x and y if the third argument is true", function () {
 			var p = new L.Point(1.3, 2.7, true);
 			expect(p.x).to.eql(1);
 			expect(p.y).to.eql(3);
 		});
 	});
 
-	describe('#subtract', function() {
-		it('subtracts the given point from this one', function() {
+	describe('#subtract', function () {
+		it('subtracts the given point from this one', function () {
 			var a = new L.Point(50, 30),
 				b = new L.Point(20, 10);
 			expect(a.subtract(b)).to.eql(new L.Point(30, 20));
 		});
 	});
 
-	describe('#add', function() {
-		it('adds given point to this one', function() {
+	describe('#add', function () {
+		it('adds given point to this one', function () {
 			expect(new L.Point(50, 30).add(new L.Point(20, 10))).to.eql(new L.Point(70, 40));
 		});
 	});
 
-	describe('#divideBy', function() {
-		it('divides this point by the given amount', function() {
+	describe('#divideBy', function () {
+		it('divides this point by the given amount', function () {
 			expect(new L.Point(50, 30).divideBy(5)).to.eql(new L.Point(10, 6));
 		});
 	});
 
-	describe('#multiplyBy', function() {
-		it('multiplies this point by the given amount', function() {
+	describe('#multiplyBy', function () {
+		it('multiplies this point by the given amount', function () {
 			expect(new L.Point(50, 30).multiplyBy(2)).to.eql(new L.Point(100, 60));
 		});
 	});

data/lib/leaflet/spec/suites/geometry/TransformationSpec.js

@@ -1,13 +1,13 @@
-describe("Transformation", function() {
+describe("Transformation", function () {
 	var t, p;
 
-	beforeEach(function() {
+	beforeEach(function () {
 		t = new L.Transformation(1, 2, 3, 4);
 		p = new L.Point(10, 20);
 	});
 
 	describe('#transform', function () {
-		it("performs a transformation", function() {
+		it("performs a transformation", function () {
 			var p2 = t.transform(p, 2);
 			expect(p2).to.eql(new L.Point(24, 128));
 		});
@@ -18,7 +18,7 @@ describe("Transformation", function() {
 	});
 
 	describe('#untransform', function () {
-		it("performs a reverse transformation", function() {
+		it("performs a reverse transformation", function () {
 			var p2 = t.transform(p, 2);
 			var p3 = t.untransform(p2, 2);
 			expect(p3).to.eql(p);

data/lib/leaflet/spec/suites/layer/FeatureGroupSpec.js

@@ -1,9 +1,12 @@
-describe('CircleMarker', function () {
+describe('FeatureGroup', function () {
+	var map;
+	beforeEach(function () {
+		map = L.map(document.createElement('div'));
+		map.setView([0, 0], 1);
+	});
 	describe("#_propagateEvent", function () {
-		var map, marker;
+		var marker;
 		beforeEach(function () {
-			map = L.map(document.createElement('div'));
-			map.setView([0, 0], 1);
 			marker = L.marker([0, 0]);
 		});
 		describe("when a Marker is added to multiple FeatureGroups ", function () {
@@ -14,23 +17,70 @@
 				fg1.addLayer(marker);
 				fg2.addLayer(marker);
 
-				var wasClicked = 0;
-				fg2.on('click', function(e) {
+				var wasClicked1,
+					wasClicked2;
+
+				fg2.on('click', function (e) {
 					expect(e.layer).to.be(marker);
 					expect(e.target).to.be(fg2);
-					wasClicked |= 1;
+					wasClicked2 = true;
 				});
 
 				fg1.on('click', function (e) {
 					expect(e.layer).to.be(marker);
 					expect(e.target).to.be(fg1);
-					wasClicked |= 2;
+					wasClicked1 = true;
 				});
 
 				marker.fire('click', { type: 'click' });
 
-				expect(wasClicked).to.be(3);
+				expect(wasClicked1).to.be(true);
+				expect(wasClicked2).to.be(true);
 			});
 		});
 	});
+	describe('addLayer', function () {
+		it('adds the layer', function () {
+			var fg = L.featureGroup(),
+			    marker = L.marker([0, 0]);
+
+			expect(fg.hasLayer(marker)).to.be(false);
+
+			fg.addLayer(marker);
+
+			expect(fg.hasLayer(marker)).to.be(true);
+		});
+		it('supports non-evented layers', function () {
+			var fg = L.featureGroup(),
+			    g = L.layerGroup();
+
+			expect(fg.hasLayer(g)).to.be(false);
+
+			fg.addLayer(g);
+
+			expect(fg.hasLayer(g)).to.be(true);
+		});
+	});
+	describe('removeLayer', function () {
+		it('removes the layer passed to it', function () {
+			var fg = L.featureGroup(),
+			    marker = L.marker([0, 0]);
+
+			fg.addLayer(marker);
+			expect(fg.hasLayer(marker)).to.be(true);
+
+			fg.removeLayer(marker);
+			expect(fg.hasLayer(marker)).to.be(false);
+		});
+		it('removes the layer passed to it by id', function () {
+			var fg = L.featureGroup(),
+			    marker = L.marker([0, 0]);
+
+			fg.addLayer(marker);
+			expect(fg.hasLayer(marker)).to.be(true);
+
+			fg.removeLayer(L.stamp(marker));
+			expect(fg.hasLayer(marker)).to.be(false);
+		});
+	});
 });

data/lib/leaflet/spec/suites/layer/GeoJSONSpec.js

@@ -1,27 +1,104 @@
+describe("L.GeoJSON", function () {
+	describe("addData", function () {
+		var geoJSON = {
+			type: 'Feature',
+			properties: {},
+			geometry: {
+				type: 'Point',
+				coordinates: [20, 10, 5]
+			}
+		};
+
+		it("sets feature property on member layers", function () {
+			var layer = new L.GeoJSON();
+			layer.addData(geoJSON);
+			expect(layer.getLayers()[0].feature).to.eql(geoJSON);
+		});
+
+		it("normalizes a geometry to a Feature", function () {
+			var layer = new L.GeoJSON();
+			layer.addData(geoJSON.geometry);
+			expect(layer.getLayers()[0].feature).to.eql(geoJSON);
+		});
+	});
+});
+
 describe("L.Marker#toGeoJSON", function () {
-	it("returns a Point object", function () {
+	it("returns a 2D Point object", function () {
 		var marker = new L.Marker([10, 20]);
-		expect(marker.toGeoJSON()).to.eql({
+		expect(marker.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10]
+		});
+	});
+
+	it("returns a 3D Point object", function () {
+		var marker = new L.Marker([10, 20, 30]);
+		expect(marker.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10, 30]
+		});
+	});
+});
+
+describe("L.Circle#toGeoJSON", function () {
+	it("returns a 2D Point object", function () {
+		var circle = new L.Circle([10, 20], 100);
+		expect(circle.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10]
+		});
+	});
+
+	it("returns a 3D Point object", function () {
+		var circle = new L.Circle([10, 20, 30], 100);
+		expect(circle.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10, 30]
+		});
+	});
+});
+
+describe("L.CircleMarker#toGeoJSON", function () {
+	it("returns a 2D Point object", function () {
+		var marker = new L.CircleMarker([10, 20]);
+		expect(marker.toGeoJSON().geometry).to.eql({
 			type: 'Point',
 			coordinates: [20, 10]
 		});
 	});
+
+	it("returns a 3D Point object", function () {
+		var marker = new L.CircleMarker([10, 20, 30]);
+		expect(marker.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10, 30]
+		});
+	});
 });
 
 describe("L.Polyline#toGeoJSON", function () {
-	it("returns a LineString object", function () {
+	it("returns a 2D LineString object", function () {
 		var polyline = new L.Polyline([[10, 20], [2, 5]]);
-		expect(polyline.toGeoJSON()).to.eql({
+		expect(polyline.toGeoJSON().geometry).to.eql({
 			type: 'LineString',
 			coordinates: [[20, 10], [5, 2]]
 		});
 	});
+
+	it("returns a 3D LineString object", function () {
+		var polyline = new L.Polyline([[10, 20, 30], [2, 5, 10]]);
+		expect(polyline.toGeoJSON().geometry).to.eql({
+			type: 'LineString',
+			coordinates: [[20, 10, 30], [5, 2, 10]]
+		});
+	});
 });
 
 describe("L.MultiPolyline#toGeoJSON", function () {
-	it("returns a MultiLineString object", function () {
+	it("returns a 2D MultiLineString object", function () {
 		var multiPolyline = new L.MultiPolyline([[[10, 20], [2, 5]], [[1, 2], [3, 4]]]);
-		expect(multiPolyline.toGeoJSON()).to.eql({
+		expect(multiPolyline.toGeoJSON().geometry).to.eql({
 			type: 'MultiLineString',
 			coordinates: [
 				[[20, 10], [5, 2]],
@@ -29,20 +106,39 @@ describe("L.MultiPolyline#toGeoJSON", function () {
 			]
 		});
 	});
+
+	it("returns a 3D MultiLineString object", function () {
+		var multiPolyline = new L.MultiPolyline([[[10, 20, 30], [2, 5, 10]], [[1, 2, 3], [4, 5, 6]]]);
+		expect(multiPolyline.toGeoJSON().geometry).to.eql({
+			type: 'MultiLineString',
+			coordinates: [
+				[[20, 10, 30], [5, 2, 10]],
+				[[2, 1, 3], [5, 4, 6]]
+			]
+		});
+	});
 });
 
 describe("L.Polygon#toGeoJSON", function () {
-	it("returns a Polygon object (no holes)", function () {
+	it("returns a 2D Polygon object (no holes)", function () {
 		var polygon = new L.Polygon([[1, 2], [3, 4], [5, 6]]);
-		expect(polygon.toGeoJSON()).to.eql({
+		expect(polygon.toGeoJSON().geometry).to.eql({
 			type: 'Polygon',
 			coordinates: [[[2, 1], [4, 3], [6, 5], [2, 1]]]
 		});
 	});
 
-	it("returns a Polygon object (with holes)", function () {
+	it("returns a 3D Polygon object (no holes)", function () {
+		var polygon = new L.Polygon([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+		expect(polygon.toGeoJSON().geometry).to.eql({
+			type: 'Polygon',
+			coordinates: [[[2, 1, 3], [5, 4, 6], [8, 7, 9], [2, 1, 3]]]
+		});
+	});
+
+	it("returns a 2D Polygon object (with holes)", function () {
 		var polygon = new L.Polygon([[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]]);
-		expect(polygon.toGeoJSON()).to.eql({
+		expect(polygon.toGeoJSON().geometry).to.eql({
 			type: 'Polygon',
 			coordinates: [
 				[[2, 1], [4, 3], [6, 5], [2, 1]],
@@ -50,37 +146,137 @@ describe("L.Polygon#toGeoJSON", function () {
 			]
 		});
 	});
+
+	it("returns a 3D Polygon object (with holes)", function () {
+		var polygon = new L.Polygon([[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]]]);
+		expect(polygon.toGeoJSON().geometry).to.eql({
+			type: 'Polygon',
+			coordinates: [
+				[[2, 1, 3], [5, 4, 6], [8, 7, 9], [2, 1, 3]],
+				[[11, 10, 12], [14, 13, 15], [17, 16, 18], [11, 10, 12]]
+			]
+		});
+	});
 });
 
 describe("L.MultiPolygon#toGeoJSON", function () {
-	it("returns a MultiPolygon object", function () {
+	it("returns a 2D MultiPolygon object", function () {
 		var multiPolygon = new L.MultiPolygon([[[1, 2], [3, 4], [5, 6]]]);
-		expect(multiPolygon.toGeoJSON()).to.eql({
+		expect(multiPolygon.toGeoJSON().geometry).to.eql({
 			type: 'MultiPolygon',
 			coordinates: [
 				[[[2, 1], [4, 3], [6, 5], [2, 1]]]
 			]
 		});
 	});
+
+	it("returns a 3D MultiPolygon object", function () {
+		var multiPolygon = new L.MultiPolygon([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]);
+		expect(multiPolygon.toGeoJSON().geometry).to.eql({
+			type: 'MultiPolygon',
+			coordinates: [
+				[[[2, 1, 3], [5, 4, 6], [8, 7, 9], [2, 1, 3]]]
+			]
+		});
+	});
 });
 
 describe("L.LayerGroup#toGeoJSON", function () {
-	it("returns a GeometryCollection object", function () {
+	it("returns a 2D FeatureCollection object", function () {
 		var marker = new L.Marker([10, 20]),
 		    polyline = new L.Polyline([[10, 20], [2, 5]]),
 		    layerGroup = new L.LayerGroup([marker, polyline]);
 		expect(layerGroup.toGeoJSON()).to.eql({
-			type: 'GeometryCollection',
-			geometries: [marker.toGeoJSON(), polyline.toGeoJSON()]
+			type: 'FeatureCollection',
+			features: [marker.toGeoJSON(), polyline.toGeoJSON()]
 		});
 	});
 
+	it("returns a 3D FeatureCollection object", function () {
+		var marker = new L.Marker([10, 20, 30]),
+				polyline = new L.Polyline([[10, 20, 30], [2, 5, 10]]),
+				layerGroup = new L.LayerGroup([marker, polyline]);
+		expect(layerGroup.toGeoJSON()).to.eql({
+			type: 'FeatureCollection',
+			features: [marker.toGeoJSON(), polyline.toGeoJSON()]
+		});
+	});
+
+	it("ensures that every member is a Feature", function () {
+		var tileLayer = new L.TileLayer(),
+		    layerGroup = new L.LayerGroup([tileLayer]);
+
+		tileLayer.toGeoJSON = function () {
+			return {
+				type: 'Point',
+				coordinates: [20, 10]
+			};
+		};
+
+		expect(layerGroup.toGeoJSON()).to.eql({
+			type: 'FeatureCollection',
+			features: [{
+				type: 'Feature',
+				properties: {},
+				geometry: {
+					type: 'Point',
+					coordinates: [20, 10]
+				}
+			}]
+		});
+	});
+
+	it('roundtrips GeometryCollection features', function () {
+		var json = {
+			"type": "FeatureCollection",
+			"features": [{
+				"type": "Feature",
+				"geometry": {
+					"type": "GeometryCollection",
+					"geometries": [{
+						"type": "LineString",
+						"coordinates": [[-122.4425587930444, 37.80666418607323], [-122.4428379594768, 37.80663578323093]]
+					}, {
+						"type": "LineString",
+						"coordinates": [
+							[-122.4425509770566, 37.80662588061205],
+							[-122.4428340530617, 37.8065999493009]
+						]
+					}]
+				},
+				"properties": {
+					"name": "SF Marina Harbor Master"
+				}
+			}]
+		};
+
+		expect(L.geoJson(json).toGeoJSON()).to.eql(json);
+	});
+
+	it('roundtrips MiltiPoint features', function () {
+		var json = {
+			"type": "FeatureCollection",
+			"features": [{
+				"type": "Feature",
+				"geometry": {
+					"type": "MultiPoint",
+					"coordinates": [[-122.4425587930444, 37.80666418607323], [-122.4428379594768, 37.80663578323093]]
+				},
+				"properties": {
+					"name": "Test MultiPoints"
+				}
+			}]
+		};
+
+		expect(L.geoJson(json).toGeoJSON()).to.eql(json);
+	});
+
 	it("omits layers which do not implement toGeoJSON", function () {
 		var tileLayer = new L.TileLayer(),
 		    layerGroup = new L.LayerGroup([tileLayer]);
 		expect(layerGroup.toGeoJSON()).to.eql({
-			type: 'GeometryCollection',
-			geometries: []
+			type: 'FeatureCollection',
+			features: []
 		});
 	});
 });