leaflet-js 0.7.9 → 0.8.dev2

data/{vendor/assets/Leaflet → lib/leaflet}/src/dom/Draggable.js

@@ -2,8 +2,7 @@
  * L.Draggable allows you to add dragging capabilities to any element. Supports mobile devices too.
  */
 
-L.Draggable = L.Class.extend({
-	includes: L.Mixin.Events,
+L.Draggable = L.Evented.extend({
 
 	statics: {
 		START: L.Browser.touch ? ['touchstart', 'mousedown'] : ['mousedown'],
@@ -29,9 +28,7 @@ L.Draggable = L.Class.extend({
 	enable: function () {
 		if (this._enabled) { return; }
 
-		for (var i = L.Draggable.START.length - 1; i >= 0; i--) {
-			L.DomEvent.on(this._dragStartTarget, L.Draggable.START[i], this._onDown, this);
-		}
+		L.DomEvent.on(this._dragStartTarget, L.Draggable.START.join(' '), this._onDown, this);
 
 		this._enabled = true;
 	},
@@ -39,9 +36,7 @@ L.Draggable = L.Class.extend({
 	disable: function () {
 		if (!this._enabled) { return; }
 
-		for (var i = L.Draggable.START.length - 1; i >= 0; i--) {
-			L.DomEvent.off(this._dragStartTarget, L.Draggable.START[i], this._onDown, this);
-		}
+		L.DomEvent.off(this._dragStartTarget, L.Draggable.START.join(' '), this._onDown, this);
 
 		this._enabled = false;
 		this._moved = false;
@@ -61,6 +56,8 @@ L.Draggable = L.Class.extend({
 
 		if (this._moving) { return; }
 
+		this.fire('down');
+
 		var first = e.touches ? e.touches[0] : e;
 
 		this._startPoint = new L.Point(first.clientX, first.clientY);
@@ -82,7 +79,6 @@ L.Draggable = L.Class.extend({
 		    offset = newPoint.subtract(this._startPoint);
 
 		if (!offset.x && !offset.y) { return; }
-		if (L.Browser.touch && Math.abs(offset.x) + Math.abs(offset.y) < 3) { return; }
 
 		L.DomEvent.preventDefault(e);
 
@@ -93,8 +89,7 @@ L.Draggable = L.Class.extend({
 			this._startPos = L.DomUtil.getPosition(this._element).subtract(offset);
 
 			L.DomUtil.addClass(document.body, 'leaflet-dragging');
-			this._lastTarget = e.target || e.srcElement;
-			L.DomUtil.addClass(this._lastTarget, 'leaflet-drag-target');
+			L.DomUtil.addClass(e.target || e.srcElement, 'leaflet-drag-target');
 		}
 
 		this._newPos = this._startPos.add(offset);
@@ -110,18 +105,14 @@ L.Draggable = L.Class.extend({
 		this.fire('drag');
 	},
 
-	_onUp: function () {
+	_onUp: function (e) {
 		L.DomUtil.removeClass(document.body, 'leaflet-dragging');
-
-		if (this._lastTarget) {
-			L.DomUtil.removeClass(this._lastTarget, 'leaflet-drag-target');
-			this._lastTarget = null;
-		}
+		L.DomUtil.removeClass(e.target || e.srcElement, 'leaflet-drag-target');
 
 		for (var i in L.Draggable.MOVE) {
 			L.DomEvent
-			    .off(document, L.Draggable.MOVE[i], this._onMove)
-			    .off(document, L.Draggable.END[i], this._onUp);
+			    .off(document, L.Draggable.MOVE[i], this._onMove, this)
+			    .off(document, L.Draggable.END[i], this._onUp, this);
 		}
 
 		L.DomUtil.enableImageDrag();

data/{vendor/assets/Leaflet → lib/leaflet}/src/dom/PosAnimation.js

@@ -2,8 +2,7 @@
  * L.PosAnimation is used by Leaflet internally for pan animations.
  */
 
-L.PosAnimation = L.Class.extend({
-	includes: L.Mixin.Events,
+L.PosAnimation = L.Evented.extend({
 
 	run: function (el, newPos, duration, easeLinearity) { // (HTMLElement, Point[, Number, Number])
 		this.stop();
@@ -33,7 +32,9 @@ L.PosAnimation = L.Class.extend({
 		// if we just removed the transition property, the element would jump to its final position,
 		// so we need to make it stay at the current position
 
-		L.DomUtil.setPosition(this._el, this._getPos());
+		this._newPos = this._getPos();
+		L.DomUtil.setPosition(this._el, this._newPos);
+
 		this._onTransitionEnd();
 		L.Util.falseFn(this._el.offsetWidth); // force reflow in case we are about to start a new animation
 	},

data/lib/leaflet/src/geo/LatLng.js

@@ -0,0 +1,67 @@
+/*
+ * L.LatLng represents a geographical point with latitude and longitude coordinates.
+ */
+
+L.LatLng = function (lat, lng, alt) {
+	if (isNaN(lat) || isNaN(lng)) {
+		throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
+	}
+
+	this.lat = +lat;
+	this.lng = +lng;
+
+	if (alt !== undefined) {
+		this.alt = +alt;
+	}
+};
+
+L.LatLng.prototype = {
+	equals: function (obj, maxMargin) {
+		if (!obj) { return false; }
+
+		obj = L.latLng(obj);
+
+		var margin = Math.max(
+		        Math.abs(this.lat - obj.lat),
+		        Math.abs(this.lng - obj.lng));
+
+		return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
+	},
+
+	toString: function (precision) {
+		return 'LatLng(' +
+		        L.Util.formatNum(this.lat, precision) + ', ' +
+		        L.Util.formatNum(this.lng, precision) + ')';
+	},
+
+	distanceTo: function (other) {
+		return L.CRS.Earth.distance(this, L.latLng(other));
+	}
+};
+
+
+// constructs LatLng with different signatures
+// (LatLng) or ([Number, Number]) or (Number, Number) or (Object)
+
+L.latLng = function (a, b) {
+	if (a instanceof L.LatLng) {
+		return a;
+	}
+	if (L.Util.isArray(a) && typeof a[0] !== 'object') {
+		if (a.length === 3) {
+			return new L.LatLng(a[0], a[1], a[2]);
+		}
+		return new L.LatLng(a[0], a[1]);
+	}
+	if (a === undefined || a === null) {
+		return a;
+	}
+	if (typeof a === 'object' && 'lat' in a) {
+		return new L.LatLng(a.lat, 'lng' in a ? a.lng : a.lon);
+	}
+	if (b === undefined) {
+		return null;
+	}
+	return new L.LatLng(a, b);
+};
+

data/lib/leaflet/src/geo/crs/CRS.EPSG3395.js

@@ -0,0 +1,13 @@
+/*
+ * L.CRS.EPSG3857 (World Mercator) CRS implementation.
+ */
+
+L.CRS.EPSG3395 = L.extend({}, L.CRS.Earth, {
+	code: 'EPSG:3395',
+	projection: L.Projection.Mercator,
+
+	transformation: (function () {
+		var scale = 0.5 / (Math.PI * L.Projection.Mercator.R);
+		return new L.Transformation(scale, 0.5, -scale, 0.5);
+	}())
+});

data/lib/leaflet/src/geo/crs/CRS.EPSG3857.js

@@ -0,0 +1,17 @@
+/*
+ * L.CRS.EPSG3857 (Spherical Mercator) is the most common CRS for web mapping and is used by Leaflet by default.
+ */
+
+L.CRS.EPSG3857 = L.extend({}, L.CRS.Earth, {
+	code: 'EPSG:3857',
+	projection: L.Projection.SphericalMercator,
+
+	transformation: (function () {
+		var scale = 0.5 / (Math.PI * L.Projection.SphericalMercator.R);
+		return new L.Transformation(scale, 0.5, -scale, 0.5);
+	}())
+});
+
+L.CRS.EPSG900913 = L.extend({}, L.CRS.EPSG3857, {
+	code: 'EPSG:900913'
+});

data/{vendor/assets/Leaflet → lib/leaflet}/src/geo/crs/CRS.EPSG4326.js

@@ -2,9 +2,8 @@
  * L.CRS.EPSG4326 is a CRS popular among advanced GIS specialists.
  */
 
-L.CRS.EPSG4326 = L.extend({}, L.CRS, {
+L.CRS.EPSG4326 = L.extend({}, L.CRS.Earth, {
 	code: 'EPSG:4326',
-
 	projection: L.Projection.LonLat,
-	transformation: new L.Transformation(1 / 360, 0.5, -1 / 360, 0.5)
+	transformation: new L.Transformation(1 / 180, 1, -1 / 180, 0.5)
 });

data/lib/leaflet/src/geo/crs/CRS.Earth.js

@@ -0,0 +1,19 @@
+/*
+ * L.CRS.Earth is the base class for all CRS representing Earth.
+ */
+
+L.CRS.Earth = L.extend({}, L.CRS, {
+	wrapLng: [-180, 180],
+
+	R: 6378137,
+
+	// distane between two geographical points using spherical law of cosines approximation
+	distance: function (latlng1, latlng2) {
+		var rad = Math.PI / 180,
+		    lat1 = latlng1.lat * rad,
+		    lat2 = latlng2.lat * rad;
+
+		return this.R * Math.acos(Math.sin(lat1) * Math.sin(lat2) +
+				Math.cos(lat1) * Math.cos(lat2) * Math.cos((latlng2.lng - latlng1.lng) * rad));
+	}
+});

data/{vendor/assets/Leaflet → lib/leaflet}/src/geo/crs/CRS.Simple.js

@@ -8,5 +8,14 @@ L.CRS.Simple = L.extend({}, L.CRS, {
 
 	scale: function (zoom) {
 		return Math.pow(2, zoom);
-	}
+	},
+
+	distance: function (latlng1, latlng2) {
+		var dx = latlng2.lng - latlng1.lng,
+		    dy = latlng2.lat - latlng1.lat;
+
+		return Math.sqrt(dx * dx + dy * dy);
+	},
+
+	infinite: true
 });

data/lib/leaflet/src/geo/crs/CRS.js

@@ -0,0 +1,63 @@
+/*
+ * L.CRS is the base object for all defined CRS (Coordinate Reference Systems) in Leaflet.
+ */
+
+L.CRS = {
+	// converts geo coords to pixel ones
+	latLngToPoint: function (latlng, zoom) {
+		var projectedPoint = this.projection.project(latlng),
+		    scale = this.scale(zoom);
+
+		return this.transformation._transform(projectedPoint, scale);
+	},
+
+	// converts pixel coords to geo coords
+	pointToLatLng: function (point, zoom) {
+		var scale = this.scale(zoom),
+		    untransformedPoint = this.transformation.untransform(point, scale);
+
+		return this.projection.unproject(untransformedPoint);
+	},
+
+	// converts geo coords to projection-specific coords (e.g. in meters)
+	project: function (latlng) {
+		return this.projection.project(latlng);
+	},
+
+	// converts projected coords to geo coords
+	unproject: function (point) {
+		return this.projection.unproject(point);
+	},
+
+	// defines how the world scales with zoom
+	scale: function (zoom) {
+		return 256 * Math.pow(2, zoom);
+	},
+
+	// returns the bounds of the world in projected coords if applicable
+	getProjectedBounds: function (zoom) {
+		if (this.infinite) { return null; }
+
+		var b = this.projection.bounds,
+		    s = this.scale(zoom),
+		    min = this.transformation.transform(b.min, s),
+		    max = this.transformation.transform(b.max, s);
+
+		return L.bounds(min, max);
+	},
+
+	// whether a coordinate axis wraps in a given range (e.g. longitude from -180 to 180); depends on CRS
+	// wrapLng: [min, max],
+	// wrapLat: [min, max],
+
+	// if true, the coordinate space will be unbounded (infinite in all directions)
+	// infinite: false,
+
+	// wraps geo coords in certain ranges if applicable
+	wrapLatLng: function (latlng) {
+		var lng = this.wrapLng ? L.Util.wrapNum(latlng.lng, this.wrapLng, true) : latlng.lng,
+		    lat = this.wrapLat ? L.Util.wrapNum(latlng.lat, this.wrapLat, true) : latlng.lat;
+
+		return L.latLng(lat, lng);
+	}
+};

data/{vendor/assets/Leaflet → lib/leaflet}/src/geo/projection/Projection.LonLat.js

@@ -2,6 +2,8 @@
  * Simple equirectangular (Plate Carree) projection, used by CRS like EPSG:4326 and Simple.
  */
 
+L.Projection = {};
+
 L.Projection.LonLat = {
 	project: function (latlng) {
 		return new L.Point(latlng.lng, latlng.lat);
@@ -9,5 +11,7 @@ L.Projection.LonLat = {
 
 	unproject: function (point) {
 		return new L.LatLng(point.y, point.x);
-	}
+	},
+
+	bounds: L.bounds([-180, -90], [180, 90])
 };

data/lib/leaflet/src/geo/projection/Projection.Mercator.js

@@ -0,0 +1,43 @@
+/*
+ * Mercator projection that takes into account that the Earth is not a perfect sphere.
+ * Less popular than spherical mercator; used by projections like EPSG:3395.
+ */
+
+L.Projection.Mercator = {
+	R: 6378137,
+	R_MINOR: 6356752.314245179,
+
+	bounds: L.bounds([-20037508.34279, -15496570.73972], [20037508.34279, 18764656.23138]),
+
+	project: function (latlng) {
+		var d = Math.PI / 180,
+		    r = this.R,
+		    y = latlng.lat * d,
+		    tmp = this.R_MINOR / r,
+		    e = Math.sqrt(1 - tmp * tmp),
+		    con = e * Math.sin(y);
+
+		var ts = Math.tan(Math.PI / 4 - y / 2) / Math.pow((1 - con) / (1 + con), e / 2);
+		y = -r * Math.log(Math.max(ts, 1E-10));
+
+		return new L.Point(latlng.lng * d * r, y);
+	},
+
+	unproject: function (point) {
+		var d = 180 / Math.PI,
+		    r = this.R,
+		    tmp = this.R_MINOR / r,
+		    e = Math.sqrt(1 - tmp * tmp),
+		    ts = Math.exp(-point.y / r),
+		    phi = Math.PI / 2 - 2 * Math.atan(ts);
+
+		for (var i = 0, dphi = 0.1, con; i < 15 && Math.abs(dphi) > 1e-7; i++) {
+			con = e * Math.sin(phi);
+			con = Math.pow((1 - con) / (1 + con), e / 2);
+			dphi = Math.PI / 2 - 2 * Math.atan(ts * con) - phi;
+			phi += dphi;
+		}
+
+		return new L.LatLng(phi * d, point.x * d / r);
+	}
+};

data/lib/leaflet/src/geo/projection/Projection.SphericalMercator.js

@@ -0,0 +1,31 @@
+/*
+ * Spherical Mercator is the most popular map projection, used by EPSG:3857 CRS used by default.
+ */
+
+L.Projection.SphericalMercator = {
+
+	R: 6378137,
+
+	project: function (latlng) {
+		var d = Math.PI / 180,
+		    max = 1 - 1E-15,
+		    sin = Math.max(Math.min(Math.sin(latlng.lat * d), max), -max);
+
+		return new L.Point(
+				this.R * latlng.lng * d,
+				this.R * Math.log((1 + sin) / (1 - sin)) / 2);
+	},
+
+	unproject: function (point) {
+		var d = 180 / Math.PI;
+
+		return new L.LatLng(
+			(2 * Math.atan(Math.exp(point.y / this.R)) - (Math.PI / 2)) * d,
+			point.x * d / this.R);
+	},
+
+	bounds: (function () {
+		var d = 6378137 * Math.PI;
+		return L.bounds([-d, -d], [d, d]);
+	})()
+};

data/{vendor/assets/Leaflet → lib/leaflet}/src/geometry/LineUtil.js

@@ -136,17 +136,27 @@ L.LineUtil = {
 		var dx = b.x - a.x,
 		    dy = b.y - a.y,
 		    min = bounds.min,
-		    max = bounds.max;
+		    max = bounds.max,
+		    x, y;
 
 		if (code & 8) { // top
-			return new L.Point(a.x + dx * (max.y - a.y) / dy, max.y);
+			x = a.x + dx * (max.y - a.y) / dy;
+			y = max.y;
+
 		} else if (code & 4) { // bottom
-			return new L.Point(a.x + dx * (min.y - a.y) / dy, min.y);
+			x = a.x + dx * (min.y - a.y) / dy;
+			y = min.y;
+
 		} else if (code & 2) { // right
-			return new L.Point(max.x, a.y + dy * (max.x - a.x) / dx);
+			x = max.x;
+			y = a.y + dy * (max.x - a.x) / dx;
+
 		} else if (code & 1) { // left
-			return new L.Point(min.x, a.y + dy * (min.x - a.x) / dx);
+			x = min.x;
+			y = a.y + dy * (min.x - a.x) / dx;
 		}
+
+		return new L.Point(x, y, true);
 	},
 
 	_getBitCode: function (/*Point*/ p, bounds) {
@@ -157,6 +167,7 @@ L.LineUtil = {
 		} else if (p.x > bounds.max.x) { // right
 			code |= 2;
 		}
+
 		if (p.y < bounds.min.y) { // bottom
 			code |= 4;
 		} else if (p.y > bounds.max.y) { // top