decidim 0.26.9 → 0.26.10

data/packages/core/node_modules/leaflet/src/core/Class.leafdoc

@@ -0,0 +1,197 @@
+
+@class Class
+@aka L.Class
+
+L.Class powers the OOP facilities of Leaflet and is used to create almost all of the Leaflet classes documented here.
+
+In addition to implementing a simple classical inheritance model, it introduces several special properties for convenient code organization — options, includes and statics.
+
+
+@example
+
+```js
+var MyClass = L.Class.extend({
+initialize: function (greeter) {
+	this.greeter = greeter;
+	// class constructor
+},
+
+greet: function (name) {
+	alert(this.greeter + ', ' + name)
+	}
+});
+
+// create instance of MyClass, passing "Hello" to the constructor
+var a = new MyClass("Hello");
+
+// call greet method, alerting "Hello, World"
+a.greet("World");
+```
+
+@section Class Factories
+@example
+
+You may have noticed that Leaflet objects are created without using
+the `new` keyword. This is achieved by complementing each class with a
+lowercase factory method:
+
+```js
+new L.Map('map'); // becomes:
+L.map('map');
+```
+
+The factories are implemented very easily, and you can do this for your own classes:
+
+```js
+L.map = function (id, options) {
+    return new L.Map(id, options);
+};
+```
+@section Inheritance
+@example
+
+You use L.Class.extend to define new classes, but you can use the same method on any class to inherit from it:
+
+```js
+var MyChildClass = MyClass.extend({
+    // ... new properties and methods
+});
+```
+
+This will create a class that inherits all methods and properties of the parent class (through a proper prototype chain), adding or overriding the ones you pass to extend. It will also properly react to instanceof:
+
+```js
+var a = new MyChildClass();
+a instanceof MyChildClass; // true
+a instanceof MyClass; // true
+```
+
+You can call parent methods (including constructor) from corresponding child ones (as you do with super calls in other languages) by accessing parent class prototype and using JavaScript's call or apply:
+
+```
+var MyChildClass = MyClass.extend({
+    initialize: function () {
+        MyClass.prototype.initialize.call(this, "Yo");
+    },
+
+    greet: function (name) {
+        MyClass.prototype.greet.call(this, 'bro ' + name + '!');
+    }
+});
+
+var a = new MyChildClass();
+a.greet('Jason'); // alerts "Yo, bro Jason!"
+```
+
+@section Options
+@example
+
+`options` is a special property that unlike other objects that you pass
+to `extend` will be merged with the parent one instead of overriding it
+completely, which makes managing configuration of objects and default
+values convenient:
+
+```js
+var MyClass = L.Class.extend({
+    options: {
+        myOption1: 'foo',
+        myOption2: 'bar'
+    }
+});
+
+var MyChildClass = MyClass.extend({
+    options: {
+        myOption1: 'baz',
+        myOption3: 5
+    }
+});
+
+var a = new MyChildClass();
+a.options.myOption1; // 'baz'
+a.options.myOption2; // 'bar'
+a.options.myOption3; // 5
+```
+
+There's also [`L.Util.setOptions`](#util-setoptions), a method for
+conveniently merging options passed to constructor with the defaults
+defines in the class:
+
+```js
+var MyClass = L.Class.extend({
+    options: {
+        foo: 'bar',
+        bla: 5
+    },
+
+    initialize: function (options) {
+        L.Util.setOptions(this, options);
+        ...
+    }
+});
+
+var a = new MyClass({bla: 10});
+a.options; // {foo: 'bar', bla: 10}
+```
+
+Note that the options object allows any keys, not just
+the options defined by the class and its base classes.
+This means you can use the options object to store
+application specific information, as long as you avoid
+keys that are already used by the class in question.
+
+@section Includes
+@example
+
+`includes` is a special class property that merges all specified objects into the class (such objects are called mixins).
+
+```js
+ var MyMixin = {
+    foo: function () { ... },
+    bar: 5
+};
+
+var MyClass = L.Class.extend({
+    includes: MyMixin
+});
+
+var a = new MyClass();
+a.foo();
+```
+
+You can also do such includes in runtime with the `include` method:
+
+```js
+MyClass.include(MyMixin);
+```
+
+`statics` is just a convenience property that injects specified object properties as the static properties of the class, useful for defining constants:
+
+```js
+var MyClass = L.Class.extend({
+    statics: {
+        FOO: 'bar',
+        BLA: 5
+    }
+});
+
+MyClass.FOO; // 'bar'
+```
+
+
+@section Constructor hooks
+@example
+
+If you're a plugin developer, you often need to add additional initialization code to existing classes (e.g. editing hooks for `L.Polyline`). Leaflet comes with a way to do it easily using the `addInitHook` method:
+
+```js
+MyClass.addInitHook(function () {
+    // ... do something in constructor additionally
+    // e.g. add event listeners, set custom properties etc.
+});
+```
+
+You can also use the following shortcut when you just need to make one additional method call:
+
+```js
+MyClass.addInitHook('methodName', arg1, arg2, …);
+```

data/packages/core/node_modules/leaflet/src/core/Events.js

@@ -0,0 +1,344 @@
+import {Class} from './Class';
+import * as Util from './Util';
+
+/*
+ * @class Evented
+ * @aka L.Evented
+ * @inherits Class
+ *
+ * A set of methods shared between event-powered classes (like `Map` and `Marker`). Generally, events allow you to execute some function when something happens with an object (e.g. the user clicks on the map, causing the map to fire `'click'` event).
+ *
+ * @example
+ *
+ * ```js
+ * map.on('click', function(e) {
+ * 	alert(e.latlng);
+ * } );
+ * ```
+ *
+ * Leaflet deals with event listeners by reference, so if you want to add a listener and then remove it, define it as a function:
+ *
+ * ```js
+ * function onClick(e) { ... }
+ *
+ * map.on('click', onClick);
+ * map.off('click', onClick);
+ * ```
+ */
+
+export var Events = {
+	/* @method on(type: String, fn: Function, context?: Object): this
+	 * Adds a listener function (`fn`) to a particular event type of the object. You can optionally specify the context of the listener (object the this keyword will point to). You can also pass several space-separated types (e.g. `'click dblclick'`).
+	 *
+	 * @alternative
+	 * @method on(eventMap: Object): this
+	 * Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
+	 */
+	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 = Util.splitWords(types);
+
+			for (var i = 0, len = types.length; i < len; i++) {
+				this._on(types[i], fn, context);
+			}
+		}
+
+		return this;
+	},
+
+	/* @method off(type: String, fn?: Function, context?: Object): this
+	 * Removes a previously added listener function. If no function is specified, it will remove all the listeners of that particular event from the object. Note that if you passed a custom context to `on`, you must pass the same context to `off` in order to remove the listener.
+	 *
+	 * @alternative
+	 * @method off(eventMap: Object): this
+	 * Removes a set of type/listener pairs.
+	 *
+	 * @alternative
+	 * @method off: this
+	 * Removes all listeners to all events on the object. This includes implicitly attached events.
+	 */
+	off: function (types, fn, context) {
+
+		if (!arguments.length) {
+			// 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 = Util.splitWords(types);
+
+			var removeAll = arguments.length === 1;
+			for (var i = 0, len = types.length; i < len; i++) {
+				if (removeAll) {
+					this._off(types[i]);
+				} else {
+					this._off(types[i], fn, context);
+				}
+			}
+		}
+
+		return this;
+	},
+
+	// attach listener (without syntactic sugar now)
+	_on: function (type, fn, context, _once) {
+		if (typeof fn !== 'function') {
+			console.warn('wrong listener type: ' + typeof fn);
+			return;
+		}
+
+		// check if fn already there
+		if (this._listens(type, fn, context) !== false) {
+			return;
+		}
+
+		if (context === this) {
+			// Less memory footprint.
+			context = undefined;
+		}
+
+		var newListener = {fn: fn, ctx: context};
+		if (_once) {
+			newListener.once = true;
+		}
+
+		this._events = this._events || {};
+		this._events[type] = this._events[type] || [];
+		this._events[type].push(newListener);
+	},
+
+	_off: function (type, fn, context) {
+		var listeners,
+		    i,
+		    len;
+
+		if (!this._events) {
+			return;
+		}
+
+		listeners = this._events[type];
+		if (!listeners) {
+			return;
+		}
+
+		if (arguments.length === 1) { // remove all
+			if (this._firingCount) {
+				// Set all removed listeners to noop
+				// so they are not called if remove happens in fire
+				for (i = 0, len = listeners.length; i < len; i++) {
+					listeners[i].fn = Util.falseFn;
+				}
+			}
+			// clear all listeners for a type if function isn't specified
+			delete this._events[type];
+			return;
+		}
+
+		if (typeof fn !== 'function') {
+			console.warn('wrong listener type: ' + typeof fn);
+			return;
+		}
+
+		// find fn and remove it
+		var index = this._listens(type, fn, context);
+		if (index !== false) {
+			var listener = listeners[index];
+			if (this._firingCount) {
+				// set the removed listener to noop so that's not called if remove happens in fire
+				listener.fn = Util.falseFn;
+
+				/* copy array in case events are being fired */
+				this._events[type] = listeners = listeners.slice();
+			}
+			listeners.splice(index, 1);
+		}
+	},
+
+	// @method fire(type: String, data?: Object, propagate?: Boolean): this
+	// Fires an event of the specified type. You can optionally provide a data
+	// object — the first argument of the listener function will contain its
+	// properties. The event can optionally be propagated to event parents.
+	fire: function (type, data, propagate) {
+		if (!this.listens(type, propagate)) { return this; }
+
+		var event = Util.extend({}, data, {
+			type: type,
+			target: this,
+			sourceTarget: data && data.sourceTarget || this
+		});
+
+		if (this._events) {
+			var listeners = this._events[type];
+			if (listeners) {
+				this._firingCount = (this._firingCount + 1) || 1;
+				for (var i = 0, len = listeners.length; i < len; i++) {
+					var l = listeners[i];
+					// off overwrites l.fn, so we need to copy fn to a var
+					var fn = l.fn;
+					if (l.once) {
+						this.off(type, fn, l.ctx);
+					}
+					fn.call(l.ctx || this, event);
+				}
+
+				this._firingCount--;
+			}
+		}
+
+		if (propagate) {
+			// propagate the event to parents (set with addEventParent)
+			this._propagateEvent(event);
+		}
+
+		return this;
+	},
+
+	// @method listens(type: String, propagate?: Boolean): Boolean
+	// @method listens(type: String, fn: Function, context?: Object, propagate?: Boolean): Boolean
+	// Returns `true` if a particular event type has any listeners attached to it.
+	// The verification can optionally be propagated, it will return `true` if parents have the listener attached to it.
+	listens: function (type, fn, context, propagate) {
+		if (typeof type !== 'string') {
+			console.warn('"string" type argument expected');
+		}
+
+		// we don't overwrite the input `fn` value, because we need to use it for propagation
+		var _fn = fn;
+		if (typeof fn !== 'function') {
+			propagate = !!fn;
+			_fn = undefined;
+			context = undefined;
+		}
+
+		var listeners = this._events && this._events[type];
+		if (listeners && listeners.length) {
+			if (this._listens(type, _fn, context) !== false) {
+				return true;
+			}
+		}
+
+		if (propagate) {
+			// also check parents for listeners if event propagates
+			for (var id in this._eventParents) {
+				if (this._eventParents[id].listens(type, fn, context, propagate)) { return true; }
+			}
+		}
+		return false;
+	},
+
+	// returns the index (number) or false
+	_listens: function (type, fn, context) {
+		if (!this._events) {
+			return false;
+		}
+
+		var listeners = this._events[type] || [];
+		if (!fn) {
+			return !!listeners.length;
+		}
+
+		if (context === this) {
+			// Less memory footprint.
+			context = undefined;
+		}
+
+		for (var i = 0, len = listeners.length; i < len; i++) {
+			if (listeners[i].fn === fn && listeners[i].ctx === context) {
+				return i;
+			}
+		}
+		return false;
+
+	},
+
+	// @method once(…): this
+	// Behaves as [`on(…)`](#evented-on), except the listener will only get fired once and then removed.
+	once: 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, true);
+			}
+
+		} else {
+			// types can be a string of space-separated words
+			types = Util.splitWords(types);
+
+			for (var i = 0, len = types.length; i < len; i++) {
+				this._on(types[i], fn, context, true);
+			}
+		}
+
+		return this;
+	},
+
+	// @method addEventParent(obj: Evented): this
+	// Adds an event parent - an `Evented` that will receive propagated events
+	addEventParent: function (obj) {
+		this._eventParents = this._eventParents || {};
+		this._eventParents[Util.stamp(obj)] = obj;
+		return this;
+	},
+
+	// @method removeEventParent(obj: Evented): this
+	// Removes an event parent, so it will stop receiving propagated events
+	removeEventParent: function (obj) {
+		if (this._eventParents) {
+			delete this._eventParents[Util.stamp(obj)];
+		}
+		return this;
+	},
+
+	_propagateEvent: function (e) {
+		for (var id in this._eventParents) {
+			this._eventParents[id].fire(e.type, Util.extend({
+				layer: e.target,
+				propagatedFrom: e.target
+			}, e), true);
+		}
+	}
+};
+
+// aliases; we should ditch those eventually
+
+// @method addEventListener(…): this
+// Alias to [`on(…)`](#evented-on)
+Events.addEventListener = Events.on;
+
+// @method removeEventListener(…): this
+// Alias to [`off(…)`](#evented-off)
+
+// @method clearAllEventListeners(…): this
+// Alias to [`off()`](#evented-off)
+Events.removeEventListener = Events.clearAllEventListeners = Events.off;
+
+// @method addOneTimeEventListener(…): this
+// Alias to [`once(…)`](#evented-once)
+Events.addOneTimeEventListener = Events.once;
+
+// @method fireEvent(…): this
+// Alias to [`fire(…)`](#evented-fire)
+Events.fireEvent = Events.fire;
+
+// @method hasEventListeners(…): Boolean
+// Alias to [`listens(…)`](#evented-listens)
+Events.hasEventListeners = Events.listens;
+
+export var Evented = Class.extend(Events);

data/packages/core/node_modules/leaflet/src/core/Events.leafdoc

@@ -0,0 +1,143 @@
+
+@namespace Event objects
+
+
+Whenever a class inheriting from `Evented` fires an event, a listener function
+will be called with an event argument, which is a plain object containing
+information about the event. For example:
+
+```js
+map.on('click', function(ev) {
+    alert(ev.latlng); // ev is an event object (MouseEvent in this case)
+});
+```
+
+The information available depends on the event type:
+
+
+@miniclass Event (Event objects)
+@section
+The base event object. All other event objects contain these properties too.
+@property type: String
+The event type (e.g. `'click'`).
+@property target: Object
+The object that fired the event. For propagated events, the last object in
+the propagation chain that fired the event.
+@property sourceTarget: Object
+The object that originally fired the event. For non-propagated events, this will
+be the same as the `target`.
+@property propagatedFrom: Object
+For propagated events, the last object that propagated the event to its
+event parent.
+@property layer: Object
+**Deprecated.** The same as `propagatedFrom`.
+
+
+@miniclass KeyboardEvent (Event objects)
+@inherits Event
+@property originalEvent: DOMEvent
+The original [DOM `KeyboardEvent`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent) that triggered this Leaflet event.
+
+@miniclass MouseEvent (Event objects)
+@inherits Event
+@property latlng: LatLng
+The geographical point where the mouse event occurred.
+@property layerPoint: Point
+Pixel coordinates of the point where the mouse event occurred relative to the map layer.
+@property containerPoint: Point
+Pixel coordinates of the point where the mouse event occurred relative to the map сontainer.
+@property originalEvent: DOMEvent
+The original [DOM `MouseEvent`](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent) or [DOM `TouchEvent`](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent) that triggered this Leaflet event.
+
+@miniclass LocationEvent (Event objects)
+@inherits Event
+@property latlng: LatLng
+Detected geographical location of the user.
+@property bounds: LatLngBounds
+Geographical bounds of the area user is located in (with respect to the accuracy of location).
+@property accuracy: Number
+Accuracy of location in meters.
+@property altitude: Number
+Height of the position above the WGS84 ellipsoid in meters.
+@property altitudeAccuracy: Number
+Accuracy of altitude in meters.
+@property heading: Number
+The direction of travel in degrees counting clockwise from true North.
+@property speed: Number
+Current velocity in meters per second.
+@property timestamp: Number
+The time when the position was acquired.
+
+@miniclass ErrorEvent (Event objects)
+@inherits Event
+@property message: String
+Error message.
+@property code: Number
+Error code (if applicable).
+
+@miniclass LayerEvent (Event objects)
+@inherits Event
+@property layer: Layer
+The layer that was added or removed.
+
+@miniclass LayersControlEvent (Event objects)
+@inherits Event
+@property layer: Layer
+The layer that was added or removed.
+@property name: String
+The name of the layer that was added or removed.
+
+@miniclass TileEvent (Event objects)
+@inherits Event
+@property tile: HTMLElement
+The tile element (image).
+@property coords: Point
+Point object with the tile's `x`, `y`, and `z` (zoom level) coordinates.
+
+@miniclass TileErrorEvent (Event objects)
+@inherits Event
+@property tile: HTMLElement
+The tile element (image).
+@property coords: Point
+Point object with the tile's `x`, `y`, and `z` (zoom level) coordinates.
+@property error: *
+Error passed to the tile's `done()` callback.
+
+@miniclass ResizeEvent (Event objects)
+@inherits Event
+@property oldSize: Point
+The old size before resize event.
+@property newSize: Point
+The new size after the resize event.
+
+@miniclass GeoJSONEvent (Event objects)
+@inherits Event
+@property layer: Layer
+The layer for the GeoJSON feature that is being added to the map.
+@property properties: Object
+GeoJSON properties of the feature.
+@property geometryType: String
+GeoJSON geometry type of the feature.
+@property id: String
+GeoJSON ID of the feature (if present).
+
+@miniclass PopupEvent (Event objects)
+@inherits Event
+@property popup: Popup
+The popup that was opened or closed.
+
+@miniclass TooltipEvent (Event objects)
+@inherits Event
+@property tooltip: Tooltip
+The tooltip that was opened or closed.
+
+@miniclass DragEndEvent (Event objects)
+@inherits Event
+@property distance: Number
+The distance in pixels the draggable element was moved by.
+
+@miniclass ZoomAnimEvent (Event objects)
+@inherits Event
+@property center: LatLng; The current center of the map
+@property zoom: Number; The current zoom level of the map
+@property noUpdate: Boolean; Whether layers should update their contents due to this event