leaflet-with-dashoffset-canvas-fix 1.9.4

package/src/dom/DomEvent.DoubleTap.js

@@ -0,0 +1,91 @@
+import * as DomEvent from './DomEvent';
+
+/*
+ * Extends the event handling code with double tap support for mobile browsers.
+ *
+ * Note: currently most browsers fire native dblclick, with only a few exceptions
+ * (see https://github.com/Leaflet/Leaflet/issues/7012#issuecomment-595087386)
+ */
+
+function makeDblclick(event) {
+	// in modern browsers `type` cannot be just overridden:
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Getter_only
+	var newEvent = {},
+	    prop, i;
+	for (i in event) {
+		prop = event[i];
+		newEvent[i] = prop && prop.bind ? prop.bind(event) : prop;
+	}
+	event = newEvent;
+	newEvent.type = 'dblclick';
+	newEvent.detail = 2;
+	newEvent.isTrusted = false;
+	newEvent._simulated = true; // for debug purposes
+	return newEvent;
+}
+
+var delay = 200;
+export function addDoubleTapListener(obj, handler) {
+	// Most browsers handle double tap natively
+	obj.addEventListener('dblclick', handler);
+
+	// On some platforms the browser doesn't fire native dblclicks for touch events.
+	// It seems that in all such cases `detail` property of `click` event is always `1`.
+	// So here we rely on that fact to avoid excessive 'dblclick' simulation when not needed.
+	var last = 0,
+	    detail;
+	function simDblclick(e) {
+		if (e.detail !== 1) {
+			detail = e.detail; // keep in sync to avoid false dblclick in some cases
+			return;
+		}
+
+		if (e.pointerType === 'mouse' ||
+			(e.sourceCapabilities && !e.sourceCapabilities.firesTouchEvents)) {
+
+			return;
+		}
+
+		// When clicking on an <input>, the browser generates a click on its
+		// <label> (and vice versa) triggering two clicks in quick succession.
+		// This ignores clicks on elements which are a label with a 'for'
+		// attribute (or children of such a label), but not children of
+		// a <input>.
+		var path = DomEvent.getPropagationPath(e);
+		if (path.some(function (el) {
+			return el instanceof HTMLLabelElement && el.attributes.for;
+		}) &&
+			!path.some(function (el) {
+				return (
+					el instanceof HTMLInputElement ||
+					el instanceof HTMLSelectElement
+				);
+			})
+		) {
+			return;
+		}
+
+		var now = Date.now();
+		if (now - last <= delay) {
+			detail++;
+			if (detail === 2) {
+				handler(makeDblclick(e));
+			}
+		} else {
+			detail = 1;
+		}
+		last = now;
+	}
+
+	obj.addEventListener('click', simDblclick);
+
+	return {
+		dblclick: handler,
+		simDblclick: simDblclick
+	};
+}
+
+export function removeDoubleTapListener(obj, handlers) {
+	obj.removeEventListener('dblclick', handlers.dblclick);
+	obj.removeEventListener('click', handlers.simDblclick);
+}

package/src/dom/DomEvent.Pointer.js

@@ -0,0 +1,97 @@
+import * as DomEvent from './DomEvent';
+import Browser from '../core/Browser';
+import {falseFn} from '../core/Util';
+
+/*
+ * Extends L.DomEvent to provide touch support for Internet Explorer and Windows-based devices.
+ */
+
+var POINTER_DOWN =   Browser.msPointer ? 'MSPointerDown'   : 'pointerdown';
+var POINTER_MOVE =   Browser.msPointer ? 'MSPointerMove'   : 'pointermove';
+var POINTER_UP =     Browser.msPointer ? 'MSPointerUp'     : 'pointerup';
+var POINTER_CANCEL = Browser.msPointer ? 'MSPointerCancel' : 'pointercancel';
+var pEvent = {
+	touchstart  : POINTER_DOWN,
+	touchmove   : POINTER_MOVE,
+	touchend    : POINTER_UP,
+	touchcancel : POINTER_CANCEL
+};
+var handle = {
+	touchstart  : _onPointerStart,
+	touchmove   : _handlePointer,
+	touchend    : _handlePointer,
+	touchcancel : _handlePointer
+};
+var _pointers = {};
+var _pointerDocListener = false;
+
+// Provides a touch events wrapper for (ms)pointer events.
+// ref https://www.w3.org/TR/pointerevents/ https://www.w3.org/Bugs/Public/show_bug.cgi?id=22890
+
+export function addPointerListener(obj, type, handler) {
+	if (type === 'touchstart') {
+		_addPointerDocListener();
+	}
+	if (!handle[type]) {
+		console.warn('wrong event specified:', type);
+		return falseFn;
+	}
+	handler = handle[type].bind(this, handler);
+	obj.addEventListener(pEvent[type], handler, false);
+	return handler;
+}
+
+export function removePointerListener(obj, type, handler) {
+	if (!pEvent[type]) {
+		console.warn('wrong event specified:', type);
+		return;
+	}
+	obj.removeEventListener(pEvent[type], handler, false);
+}
+
+function _globalPointerDown(e) {
+	_pointers[e.pointerId] = e;
+}
+
+function _globalPointerMove(e) {
+	if (_pointers[e.pointerId]) {
+		_pointers[e.pointerId] = e;
+	}
+}
+
+function _globalPointerUp(e) {
+	delete _pointers[e.pointerId];
+}
+
+function _addPointerDocListener() {
+	// need to keep track of what pointers and how many are active to provide e.touches emulation
+	if (!_pointerDocListener) {
+		// we listen document as any drags that end by moving the touch off the screen get fired there
+		document.addEventListener(POINTER_DOWN, _globalPointerDown, true);
+		document.addEventListener(POINTER_MOVE, _globalPointerMove, true);
+		document.addEventListener(POINTER_UP, _globalPointerUp, true);
+		document.addEventListener(POINTER_CANCEL, _globalPointerUp, true);
+
+		_pointerDocListener = true;
+	}
+}
+
+function _handlePointer(handler, e) {
+	if (e.pointerType === (e.MSPOINTER_TYPE_MOUSE || 'mouse')) { return; }
+
+	e.touches = [];
+	for (var i in _pointers) {
+		e.touches.push(_pointers[i]);
+	}
+	e.changedTouches = [e];
+
+	handler(e);
+}
+
+function _onPointerStart(handler, e) {
+	// IE10 specific: MsTouch needs preventDefault. See #2000
+	if (e.MSPOINTER_TYPE_TOUCH && e.pointerType === e.MSPOINTER_TYPE_TOUCH) {
+		DomEvent.preventDefault(e);
+	}
+	_handlePointer(handler, e);
+}

package/src/dom/DomEvent.js

@@ -0,0 +1,315 @@
+import {Point} from '../geometry/Point';
+import * as Util from '../core/Util';
+import Browser from '../core/Browser';
+import {addPointerListener, removePointerListener} from './DomEvent.Pointer';
+import {addDoubleTapListener, removeDoubleTapListener} from './DomEvent.DoubleTap';
+import {getScale} from './DomUtil';
+
+/*
+ * @namespace DomEvent
+ * Utility functions to work with the [DOM events](https://developer.mozilla.org/docs/Web/API/Event), used by Leaflet internally.
+ */
+
+// Inspired by John Resig, Dean Edwards and YUI addEvent implementations.
+
+// @function on(el: HTMLElement, types: String, fn: Function, context?: Object): this
+// Adds a listener function (`fn`) to a particular DOM event type of the
+// element `el`. 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
+// @function on(el: HTMLElement, eventMap: Object, context?: Object): this
+// Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
+export function on(obj, types, fn, context) {
+
+	if (types && typeof types === 'object') {
+		for (var type in types) {
+			addOne(obj, type, types[type], fn);
+		}
+	} else {
+		types = Util.splitWords(types);
+
+		for (var i = 0, len = types.length; i < len; i++) {
+			addOne(obj, types[i], fn, context);
+		}
+	}
+
+	return this;
+}
+
+var eventsKey = '_leaflet_events';
+
+// @function off(el: HTMLElement, types: String, fn: Function, context?: Object): this
+// Removes a previously added listener function.
+// 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
+// @function off(el: HTMLElement, eventMap: Object, context?: Object): this
+// Removes a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
+
+// @alternative
+// @function off(el: HTMLElement, types: String): this
+// Removes all previously added listeners of given types.
+
+// @alternative
+// @function off(el: HTMLElement): this
+// Removes all previously added listeners from given HTMLElement
+export function off(obj, types, fn, context) {
+
+	if (arguments.length === 1) {
+		batchRemove(obj);
+		delete obj[eventsKey];
+
+	} else if (types && typeof types === 'object') {
+		for (var type in types) {
+			removeOne(obj, type, types[type], fn);
+		}
+
+	} else {
+		types = Util.splitWords(types);
+
+		if (arguments.length === 2) {
+			batchRemove(obj, function (type) {
+				return Util.indexOf(types, type) !== -1;
+			});
+		} else {
+			for (var i = 0, len = types.length; i < len; i++) {
+				removeOne(obj, types[i], fn, context);
+			}
+		}
+	}
+
+	return this;
+}
+
+function batchRemove(obj, filterFn) {
+	for (var id in obj[eventsKey]) {
+		var type = id.split(/\d/)[0];
+		if (!filterFn || filterFn(type)) {
+			removeOne(obj, type, null, null, id);
+		}
+	}
+}
+
+var mouseSubst = {
+	mouseenter: 'mouseover',
+	mouseleave: 'mouseout',
+	wheel: !('onwheel' in window) && 'mousewheel'
+};
+
+function addOne(obj, type, fn, context) {
+	var id = type + Util.stamp(fn) + (context ? '_' + Util.stamp(context) : '');
+
+	if (obj[eventsKey] && obj[eventsKey][id]) { return this; }
+
+	var handler = function (e) {
+		return fn.call(context || obj, e || window.event);
+	};
+
+	var originalHandler = handler;
+
+	if (!Browser.touchNative && Browser.pointer && type.indexOf('touch') === 0) {
+		// Needs DomEvent.Pointer.js
+		handler = addPointerListener(obj, type, handler);
+
+	} else if (Browser.touch && (type === 'dblclick')) {
+		handler = addDoubleTapListener(obj, handler);
+
+	} else if ('addEventListener' in obj) {
+
+		if (type === 'touchstart' || type === 'touchmove' || type === 'wheel' ||  type === 'mousewheel') {
+			obj.addEventListener(mouseSubst[type] || type, handler, Browser.passiveEvents ? {passive: false} : false);
+
+		} else if (type === 'mouseenter' || type === 'mouseleave') {
+			handler = function (e) {
+				e = e || window.event;
+				if (isExternalTarget(obj, e)) {
+					originalHandler(e);
+				}
+			};
+			obj.addEventListener(mouseSubst[type], handler, false);
+
+		} else {
+			obj.addEventListener(type, originalHandler, false);
+		}
+
+	} else {
+		obj.attachEvent('on' + type, handler);
+	}
+
+	obj[eventsKey] = obj[eventsKey] || {};
+	obj[eventsKey][id] = handler;
+}
+
+function removeOne(obj, type, fn, context, id) {
+	id = id || type + Util.stamp(fn) + (context ? '_' + Util.stamp(context) : '');
+	var handler = obj[eventsKey] && obj[eventsKey][id];
+
+	if (!handler) { return this; }
+
+	if (!Browser.touchNative && Browser.pointer && type.indexOf('touch') === 0) {
+		removePointerListener(obj, type, handler);
+
+	} else if (Browser.touch && (type === 'dblclick')) {
+		removeDoubleTapListener(obj, handler);
+
+	} else if ('removeEventListener' in obj) {
+
+		obj.removeEventListener(mouseSubst[type] || type, handler, false);
+
+	} else {
+		obj.detachEvent('on' + type, handler);
+	}
+
+	obj[eventsKey][id] = null;
+}
+
+// @function stopPropagation(ev: DOMEvent): this
+// Stop the given event from propagation to parent elements. Used inside the listener functions:
+// ```js
+// L.DomEvent.on(div, 'click', function (ev) {
+// 	L.DomEvent.stopPropagation(ev);
+// });
+// ```
+export function stopPropagation(e) {
+
+	if (e.stopPropagation) {
+		e.stopPropagation();
+	} else if (e.originalEvent) {  // In case of Leaflet event.
+		e.originalEvent._stopped = true;
+	} else {
+		e.cancelBubble = true;
+	}
+
+	return this;
+}
+
+// @function disableScrollPropagation(el: HTMLElement): this
+// Adds `stopPropagation` to the element's `'wheel'` events (plus browser variants).
+export function disableScrollPropagation(el) {
+	addOne(el, 'wheel', stopPropagation);
+	return this;
+}
+
+// @function disableClickPropagation(el: HTMLElement): this
+// Adds `stopPropagation` to the element's `'click'`, `'dblclick'`, `'contextmenu'`,
+// `'mousedown'` and `'touchstart'` events (plus browser variants).
+export function disableClickPropagation(el) {
+	on(el, 'mousedown touchstart dblclick contextmenu', stopPropagation);
+	el['_leaflet_disable_click'] = true;
+	return this;
+}
+
+// @function preventDefault(ev: DOMEvent): this
+// Prevents the default action of the DOM Event `ev` from happening (such as
+// following a link in the href of the a element, or doing a POST request
+// with page reload when a `<form>` is submitted).
+// Use it inside listener functions.
+export function preventDefault(e) {
+	if (e.preventDefault) {
+		e.preventDefault();
+	} else {
+		e.returnValue = false;
+	}
+	return this;
+}
+
+// @function stop(ev: DOMEvent): this
+// Does `stopPropagation` and `preventDefault` at the same time.
+export function stop(e) {
+	preventDefault(e);
+	stopPropagation(e);
+	return this;
+}
+
+// @function getPropagationPath(ev: DOMEvent): Array
+// Compatibility polyfill for [`Event.composedPath()`](https://developer.mozilla.org/en-US/docs/Web/API/Event/composedPath).
+// Returns an array containing the `HTMLElement`s that the given DOM event
+// should propagate to (if not stopped).
+export function getPropagationPath(ev) {
+	if (ev.composedPath) {
+		return ev.composedPath();
+	}
+
+	var path = [];
+	var el = ev.target;
+
+	while (el) {
+		path.push(el);
+		el = el.parentNode;
+	}
+	return path;
+}
+
+
+// @function getMousePosition(ev: DOMEvent, container?: HTMLElement): Point
+// Gets normalized mouse position from a DOM event relative to the
+// `container` (border excluded) or to the whole page if not specified.
+export function getMousePosition(e, container) {
+	if (!container) {
+		return new Point(e.clientX, e.clientY);
+	}
+
+	var scale = getScale(container),
+	    offset = scale.boundingClientRect; // left and top  values are in page scale (like the event clientX/Y)
+
+	return new Point(
+		// offset.left/top values are in page scale (like clientX/Y),
+		// whereas clientLeft/Top (border width) values are the original values (before CSS scale applies).
+		(e.clientX - offset.left) / scale.x - container.clientLeft,
+		(e.clientY - offset.top) / scale.y - container.clientTop
+	);
+}
+
+
+//  except , Safari and
+// We need double the scroll pixels (see #7403 and #4538) for all Browsers
+// except OSX (Mac) -> 3x, Chrome running on Linux 1x
+
+var wheelPxFactor =
+	(Browser.linux && Browser.chrome) ? window.devicePixelRatio :
+	Browser.mac ? window.devicePixelRatio * 3 :
+	window.devicePixelRatio > 0 ? 2 * window.devicePixelRatio : 1;
+// @function getWheelDelta(ev: DOMEvent): Number
+// Gets normalized wheel delta from a wheel DOM event, in vertical
+// pixels scrolled (negative if scrolling down).
+// Events from pointing devices without precise scrolling are mapped to
+// a best guess of 60 pixels.
+export function getWheelDelta(e) {
+	return (Browser.edge) ? e.wheelDeltaY / 2 : // Don't trust window-geometry-based delta
+	       (e.deltaY && e.deltaMode === 0) ? -e.deltaY / wheelPxFactor : // Pixels
+	       (e.deltaY && e.deltaMode === 1) ? -e.deltaY * 20 : // Lines
+	       (e.deltaY && e.deltaMode === 2) ? -e.deltaY * 60 : // Pages
+	       (e.deltaX || e.deltaZ) ? 0 :	// Skip horizontal/depth wheel events
+	       e.wheelDelta ? (e.wheelDeltaY || e.wheelDelta) / 2 : // Legacy IE pixels
+	       (e.detail && Math.abs(e.detail) < 32765) ? -e.detail * 20 : // Legacy Moz lines
+	       e.detail ? e.detail / -32765 * 60 : // Legacy Moz pages
+	       0;
+}
+
+// check if element really left/entered the event target (for mouseenter/mouseleave)
+export function isExternalTarget(el, e) {
+
+	var related = e.relatedTarget;
+
+	if (!related) { return true; }
+
+	try {
+		while (related && (related !== el)) {
+			related = related.parentNode;
+		}
+	} catch (err) {
+		return false;
+	}
+	return (related !== el);
+}
+
+// @function addListener(…): this
+// Alias to [`L.DomEvent.on`](#domevent-on)
+export {on as addListener};
+
+// @function removeListener(…): this
+// Alias to [`L.DomEvent.off`](#domevent-off)
+export {off as removeListener};