leaflet-js 0.7.9 → 0.8.dev2

data/{vendor/assets/Leaflet → lib/leaflet}/src/control/Control.js

@@ -54,17 +54,15 @@ L.Control = L.Class.extend({
 		return this;
 	},
 
-	removeFrom: function (map) {
-		var pos = this.getPosition(),
-		    corner = map._controlCorners[pos];
-
-		corner.removeChild(this._container);
-		this._map = null;
+	remove: function () {
+		L.DomUtil.remove(this._container);
 
 		if (this.onRemove) {
-			this.onRemove(map);
+			this.onRemove(this._map);
 		}
 
+		this._map = null;
+
 		return this;
 	},
 
@@ -89,7 +87,7 @@ L.Map.include({
 	},
 
 	removeControl: function (control) {
-		control.removeFrom(this);
+		control.remove();
 		return this;
 	},
 
@@ -112,6 +110,6 @@ L.Map.include({
 	},
 
 	_clearControlPos: function () {
-		this._container.removeChild(this._controlContainer);
+		L.DomUtil.remove(this._controlContainer);
 	}
 });

data/lib/leaflet/src/copyright.js

@@ -0,0 +1,4 @@
+/*
+ Leaflet {VERSION}, a JS library for interactive maps. http://leafletjs.com
+ (c) 2010-2014 Vladimir Agafonkin, (c) 2010-2011 CloudMade
+*/

data/lib/leaflet/src/core/Browser.js

@@ -0,0 +1,65 @@
+/*
+ * L.Browser handles different browser and feature detections for internal Leaflet use.
+ */
+
+(function () {
+
+	var ua = navigator.userAgent.toLowerCase(),
+	    doc = document.documentElement,
+
+	    ie = 'ActiveXObject' in window,
+
+	    webkit    = ua.indexOf('webkit') !== -1,
+	    phantomjs = ua.indexOf('phantom') !== -1,
+	    android23 = ua.search('android [23]') !== -1,
+	    chrome    = ua.indexOf('chrome') !== -1,
+
+	    mobile = typeof orientation !== 'undefined',
+	    msPointer = navigator.msPointerEnabled && navigator.msMaxTouchPoints && !window.PointerEvent,
+	    pointer = (window.PointerEvent && navigator.pointerEnabled && navigator.maxTouchPoints) || msPointer,
+
+	    ie3d = ie && ('transition' in doc.style),
+	    webkit3d = ('WebKitCSSMatrix' in window) && ('m11' in new window.WebKitCSSMatrix()) && !android23,
+	    gecko3d = 'MozPerspective' in doc.style,
+	    opera3d = 'OTransition' in doc.style;
+
+
+	var retina = 'devicePixelRatio' in window && window.devicePixelRatio > 1;
+
+	if (!retina && 'matchMedia' in window) {
+		var matches = window.matchMedia('(min-resolution:144dpi)');
+		retina = matches && matches.matches;
+	}
+
+	var touch = !window.L_NO_TOUCH && !phantomjs && (pointer || 'ontouchstart' in window ||
+			(window.DocumentTouch && document instanceof window.DocumentTouch));
+
+	L.Browser = {
+		ie: ie,
+		ielt9: ie && !document.addEventListener,
+		webkit: webkit,
+		gecko: (ua.indexOf('gecko') !== -1) && !webkit && !window.opera && !ie,
+		android: ua.indexOf('android') !== -1,
+		android23: android23,
+		chrome: chrome,
+		safari: !chrome && ua.indexOf('safari') !== -1,
+
+		ie3d: ie3d,
+		webkit3d: webkit3d,
+		gecko3d: gecko3d,
+		opera3d: opera3d,
+		any3d: !window.L_DISABLE_3D && (ie3d || webkit3d || gecko3d || opera3d) && !phantomjs,
+
+		mobile: mobile,
+		mobileWebkit: mobile && webkit,
+		mobileWebkit3d: mobile && webkit3d,
+		mobileOpera: mobile && window.opera,
+
+		touch: !!touch,
+		msPointer: !!msPointer,
+		pointer: !!pointer,
+
+		retina: !!retina
+	};
+
+}());

data/{vendor/assets/Leaflet → lib/leaflet}/src/core/Class.js

@@ -16,16 +16,15 @@ L.Class.extend = function (props) {
 		}
 
 		// call all constructor hooks
-		if (this._initHooks) {
+		if (this._initHooks.length) {
 			this.callInitHooks();
 		}
 	};
 
-	// instantiate class without calling constructor
-	var F = function () {};
-	F.prototype = this.prototype;
+	// jshint camelcase: false
+	var parentProto = NewClass.__super__ = this.prototype;
 
-	var proto = new F();
+	var proto = L.Util.create(parentProto);
 	proto.constructor = NewClass;
 
 	NewClass.prototype = proto;
@@ -50,8 +49,8 @@ L.Class.extend = function (props) {
 	}
 
 	// merge options
-	if (props.options && proto.options) {
-		props.options = L.extend({}, proto.options, props.options);
+	if (proto.options) {
+		props.options = L.Util.extend(L.Util.create(proto.options), props.options);
 	}
 
 	// mix given properties into the prototype
@@ -59,17 +58,13 @@ L.Class.extend = function (props) {
 
 	proto._initHooks = [];
 
-	var parent = this;
-	// jshint camelcase: false
-	NewClass.__super__ = parent.prototype;
-
 	// add method for calling all hooks
 	proto.callInitHooks = function () {
 
 		if (this._initHooksCalled) { return; }
 
-		if (parent.prototype.callInitHooks) {
-			parent.prototype.callInitHooks.call(this);
+		if (parentProto.callInitHooks) {
+			parentProto.callInitHooks.call(this);
 		}
 
 		this._initHooksCalled = true;

data/lib/leaflet/src/core/Events.js

@@ -0,0 +1,226 @@
+/*
+ * L.Evented is a base class that Leaflet classes inherit from to handle custom events.
+ */
+
+L.Evented = L.Class.extend({
+
+	on: function (types, fn, context) {
+
+		// types can be a map of types/handlers
+		if (typeof types === 'object') {
+			for (var type in types) {
+				// we don't process space-separated events here for performance;
+				// it's a hot path since Layer uses the on(obj) syntax
+				this._on(type, types[type], fn);
+			}
+
+		} else {
+			// types can be a string of space-separated words
+			types = L.Util.splitWords(types);
+
+			for (var i = 0, len = types.length; i < len; i++) {
+				this._on(types[i], fn, context);
+			}
+		}
+
+		return this;
+	},
+
+	off: function (types, fn, context) {
+
+		if (!types) {
+			// clear all listeners if called without arguments
+			delete this._events;
+
+		} else if (typeof types === 'object') {
+			for (var type in types) {
+				this._off(type, types[type], fn);
+			}
+
+		} else {
+			types = L.Util.splitWords(types);
+
+			for (var i = 0, len = types.length; i < len; i++) {
+				this._off(types[i], fn, context);
+			}
+		}
+
+		return this;
+	},
+
+	// attach listener (without syntactic sugar now)
+	_on: function (type, fn, context) {
+
+		var events = this._events = this._events || {},
+		    contextId = context && context !== this && L.stamp(context);
+
+		if (contextId) {
+			// store listeners with custom context in a separate hash (if it has an id);
+			// gives a major performance boost when firing and removing events (e.g. on map object)
+
+			var indexKey = type + '_idx',
+			    indexLenKey = type + '_len',
+			    typeIndex = events[indexKey] = events[indexKey] || {},
+			    id = L.stamp(fn) + '_' + contextId;
+
+			if (!typeIndex[id]) {
+				typeIndex[id] = {fn: fn, ctx: context};
+
+				// keep track of the number of keys in the index to quickly check if it's empty
+				events[indexLenKey] = (events[indexLenKey] || 0) + 1;
+			}
+
+		} else {
+			// individual layers mostly use "this" for context and don't fire listeners too often
+			// so simple array makes the memory footprint better while not degrading performance
+
+			events[type] = events[type] || [];
+			events[type].push({fn: fn});
+		}
+	},
+
+	_off: function (type, fn, context) {
+		var events = this._events,
+		    indexKey = type + '_idx',
+		    indexLenKey = type + '_len';
+
+		if (!events) { return; }
+
+		if (!fn) {
+			// clear all listeners for a type if function isn't specified
+			delete events[type];
+			delete events[indexKey];
+			delete events[indexLenKey];
+			return;
+		}
+
+		var contextId = context && context !== this && L.stamp(context),
+		    listeners, i, len, listener, id;
+
+		if (contextId) {
+			id = L.stamp(fn) + '_' + contextId;
+			listeners = events[indexKey];
+
+			if (listeners && listeners[id]) {
+				listener = listeners[id];
+				delete listeners[id];
+				events[indexLenKey]--;
+			}
+
+		} else {
+			listeners = events[type];
+
+			for (i = 0, len = listeners.length; i < len; i++) {
+				if (listeners[i].fn === fn) {
+					listener = listeners[i];
+					listeners.splice(i, 1);
+					break;
+				}
+			}
+		}
+
+		// set the removed listener to noop so that's not called if remove happens in fire
+		if (listener) {
+			listener.fn = L.Util.falseFn;
+		}
+	},
+
+	fire: function (type, data, propagate) {
+		if (!this.listens(type, propagate)) { return this; }
+
+		var event = L.Util.extend({}, data, {type: type, target: this}),
+		    events = this._events;
+
+		if (events) {
+		    var typeIndex = events[type + '_idx'],
+		        i, len, listeners, id;
+
+			if (events[type]) {
+				// make sure adding/removing listeners inside other listeners won't cause infinite loop
+				listeners = events[type].slice();
+
+				for (i = 0, len = listeners.length; i < len; i++) {
+					listeners[i].fn.call(this, event);
+				}
+			}
+
+			// fire event for the context-indexed listeners as well
+			for (id in typeIndex) {
+				typeIndex[id].fn.call(typeIndex[id].ctx, event);
+			}
+		}
+
+		if (propagate) {
+			// propagate the event to parents (set with addEventParent)
+			this._propagateEvent(event);
+		}
+
+		return this;
+	},
+
+	listens: function (type, propagate) {
+		var events = this._events;
+
+		if (events && (events[type] || events[type + '_len'])) { return true; }
+
+		if (propagate) {
+			// also check parents for listeners if event propagates
+			for (var id in this._eventParents) {
+				if (this._eventParents[id].listens(type)) { return true; }
+			}
+		}
+		return false;
+	},
+
+	once: function (types, fn, context) {
+
+		if (typeof types === 'object') {
+			for (var type in types) {
+				this.once(type, types[type], fn);
+			}
+			return this;
+		}
+
+		var handler = L.bind(function () {
+			this
+			    .off(types, fn, context)
+			    .off(types, handler, context);
+		}, this);
+
+		// add a listener that's executed once and removed after that
+		return this
+		    .on(types, fn, context)
+		    .on(types, handler, context);
+	},
+
+	// adds a parent to propagate events to (when you fire with true as a 3rd argument)
+	addEventParent: function (obj) {
+		this._eventParents = this._eventParents || {};
+		this._eventParents[L.stamp(obj)] = obj;
+		return this;
+	},
+
+	removeEventParent: function (obj) {
+		if (this._eventParents) {
+			delete this._eventParents[L.stamp(obj)];
+		}
+		return this;
+	},
+
+	_propagateEvent: function (e) {
+		for (var id in this._eventParents) {
+			this._eventParents[id].fire(e.type, L.extend({layer: e.target}, e));
+		}
+	}
+});
+
+var proto = L.Evented.prototype;
+
+// aliases; we should ditch those eventually
+proto.addEventListener = proto.on;
+proto.removeEventListener = proto.clearAllEventListeners = proto.off;
+proto.addOneTimeEventListener = proto.once;
+proto.fireEvent = proto.fire;
+proto.hasEventListeners = proto.listens;
+
+L.Mixin = {Events: proto};

data/lib/leaflet/src/core/Util.js

@@ -0,0 +1,196 @@
+/*
+ * L.Util contains various utility functions used throughout Leaflet code.
+ */
+
+L.Util = {
+	// extend an object with properties of one or more other objects
+	extend: function (dest) {
+		var sources = Array.prototype.slice.call(arguments, 1),
+		    i, j, len, src;
+
+		for (j = 0, len = sources.length; j < len; j++) {
+			src = sources[j];
+			for (i in src) {
+				dest[i] = src[i];
+			}
+		}
+		return dest;
+	},
+
+	// create an object from a given prototype
+	create: Object.create || (function () {
+		function F() {}
+		return function (proto) {
+			F.prototype = proto;
+			return new F();
+		};
+	})(),
+
+	// bind a function to be called with a given context
+	bind: function (fn, obj) {
+		var slice = Array.prototype.slice;
+
+		if (fn.bind) {
+			return fn.bind.apply(fn, slice.call(arguments, 1));
+		}
+
+		var args = slice.call(arguments, 2);
+
+		return function () {
+			return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
+		};
+	},
+
+	// return unique ID of an object
+	stamp: function (obj) {
+		// jshint camelcase: false
+		obj._leaflet_id = obj._leaflet_id || ++L.Util.lastId;
+		return obj._leaflet_id;
+	},
+
+	lastId: 0,
+
+	// return a function that won't be called more often than the given interval
+	throttle: function (fn, time, context) {
+		var lock, args, wrapperFn, later;
+
+		later = function () {
+			// reset lock and call if queued
+			lock = false;
+			if (args) {
+				wrapperFn.apply(context, args);
+				args = false;
+			}
+		};
+
+		wrapperFn = function () {
+			if (lock) {
+				// called too soon, queue to call later
+				args = arguments;
+
+			} else {
+				// call and lock until later
+				fn.apply(context, arguments);
+				setTimeout(later, time);
+				lock = true;
+			}
+		};
+
+		return wrapperFn;
+	},
+
+	// wrap the given number to lie within a certain range (used for wrapping longitude)
+	wrapNum: function (x, range, includeMax) {
+		var max = range[1],
+		    min = range[0],
+		    d = max - min;
+		return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
+	},
+
+	// do nothing (used as a noop throughout the code)
+	falseFn: function () { return false; },
+
+	// round a given number to a given precision
+	formatNum: function (num, digits) {
+		var pow = Math.pow(10, digits || 5);
+		return Math.round(num * pow) / pow;
+	},
+
+	// trim whitespace from both sides of a string
+	trim: function (str) {
+		return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
+	},
+
+	// split a string into words
+	splitWords: function (str) {
+		return L.Util.trim(str).split(/\s+/);
+	},
+
+	// set options to an object, inheriting parent's options as well
+	setOptions: function (obj, options) {
+		if (!obj.hasOwnProperty('options')) {
+			obj.options = obj.options ? L.Util.create(obj.options) : {};
+		}
+		for (var i in options) {
+			obj.options[i] = options[i];
+		}
+		return obj.options;
+	},
+
+	// make an URL with GET parameters out of a set of properties/values
+	getParamString: function (obj, existingUrl, uppercase) {
+		var params = [];
+		for (var i in obj) {
+			params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + '=' + encodeURIComponent(obj[i]));
+		}
+		return ((!existingUrl || existingUrl.indexOf('?') === -1) ? '?' : '&') + params.join('&');
+	},
+
+	// super-simple templating facility, used for TileLayer URLs
+	template: function (str, data) {
+		return str.replace(L.Util.templateRe, function (str, key) {
+			var value = data[key];
+
+			if (value === undefined) {
+				throw new Error('No value provided for variable ' + str);
+
+			} else if (typeof value === 'function') {
+				value = value(data);
+			}
+			return value;
+		});
+	},
+
+	templateRe: /\{ *([\w_]+) *\}/g,
+
+	isArray: Array.isArray || function (obj) {
+		return (Object.prototype.toString.call(obj) === '[object Array]');
+	},
+
+	// minimal image URI, set to an image when disposing to flush memory
+	emptyImageUrl: 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs='
+};
+
+(function () {
+	// inspired by http://paulirish.com/2011/requestanimationframe-for-smart-animating/
+
+	function getPrefixed(name) {
+		return window['webkit' + name] || window['moz' + name] || window['ms' + name];
+	}
+
+	var lastTime = 0;
+
+	// fallback for IE 7-8
+	function timeoutDefer(fn) {
+		var time = +new Date(),
+		    timeToCall = Math.max(0, 16 - (time - lastTime));
+
+		lastTime = time + timeToCall;
+		return window.setTimeout(fn, timeToCall);
+	}
+
+	var requestFn = window.requestAnimationFrame || getPrefixed('RequestAnimationFrame') || timeoutDefer,
+	    cancelFn = window.cancelAnimationFrame || getPrefixed('CancelAnimationFrame') ||
+	               getPrefixed('CancelRequestAnimationFrame') || function (id) { window.clearTimeout(id); };
+
+
+	L.Util.requestAnimFrame = function (fn, context, immediate, element) {
+		if (immediate && requestFn === timeoutDefer) {
+			fn.call(context);
+		} else {
+			return requestFn.call(window, L.bind(fn, context), element);
+		}
+	};
+
+	L.Util.cancelAnimFrame = function (id) {
+		if (id) {
+			cancelFn.call(window, id);
+		}
+	};
+})();
+
+// shortcuts for most used utility functions
+L.extend = L.Util.extend;
+L.bind = L.Util.bind;
+L.stamp = L.Util.stamp;
+L.setOptions = L.Util.setOptions;