leaflet-rotate 0.4.0 → 0.5.1

package/src/map/handler/CompassBearing.js

@@ -1,11 +1,19 @@
 /**
- * Rotates the map according to a smartphone's compass.
+ * Sets map bearing from device orientation when the browser exposes compass data.
  * 
  * @typedef L.Map.CompassBearing
+ * @property {L.Map.CompassBearing} compassBearing Map handler, enabled to follow device heading.
+ * 
+ * @since leaflet-rotate (v0.1.0)
  */
 
 L.Map.CompassBearing = L.Handler.extend({
 
+    /**
+     * @param {L.Map} map Map whose bearing follows device orientation.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     initialize(map) {
         this._map = map;
         /** @see https://caniuse.com/?search=DeviceOrientation */
@@ -17,9 +25,21 @@ L.Map.CompassBearing = L.Handler.extend({
         this._throttled = L.Util.throttle(this._onDeviceOrientation, 100, this);
     },
 
+    /**
+     * Subscribe to the supported device-orientation event, if available.
+     * On iOS, permission is requested first (call `enable()` from a user gesture).
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     addHooks() {
         if (this._map._rotate && this.__deviceOrientationEvent) {
             L.DomEvent.on(window, this.__deviceOrientationEvent, this._throttled, this);
+            const DOE = window.DeviceOrientationEvent;
+            if (DOE && DOE.requestPermission) {
+                DOE.requestPermission()
+                    .then(state => 'denied' === state && this.enabled() && this.disable())
+                    .catch(() => {});
+            }
         } else {
             // L.Map.CompassBearing handler will be automatically
             // disabled if device orientation is not supported.
@@ -27,6 +47,11 @@ L.Map.CompassBearing = L.Handler.extend({
         }
     },
 
+    /**
+     * Unsubscribe from device orientation when the handler is disabled.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     removeHooks() {
         if (this._map._rotate && this.__deviceOrientationEvent) {
             L.DomEvent.off(window, this.__deviceOrientationEvent, this._throttled, this);
@@ -34,6 +59,8 @@ L.Map.CompassBearing = L.Handler.extend({
     },
 
     /**
+     * Apply a device orientation reading to the map bearing.
+     *
      * `DeviceOrientationEvent.absolute` - Indicates whether the device is providing absolute
      *                                     orientation values (relatives to Magnetic North) or
      *                                     using some arbitrary frame determined by the device.
@@ -50,6 +77,10 @@ L.Map.CompassBearing = L.Handler.extend({
      * @see https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent/absolute
      * @see https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent/alpha
      * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/orientation
+     *
+     * @param {DeviceOrientationEvent} e Orientation reading from the browser.
+     * 
+     * @since leaflet-rotate (v0.1.0)
      */
     _onDeviceOrientation(e) {
         let angle = e.webkitCompassHeading != null ? e.webkitCompassHeading : e.alpha;
@@ -76,5 +107,7 @@ L.Map.CompassBearing = L.Handler.extend({
  * Add Compass bearing handler to L.Map (disabled unless `window.DeviceOrientationEvent` is set).
  * 
  * @property {L.Map.CompassBearing} compassBearing
+ * 
+ * @since leaflet-rotate (v0.1.0)
  */
 L.Map.addInitHook('addHandler', 'compassBearing', L.Map.CompassBearing);

package/src/map/handler/ContainerMutation.js

@@ -1,7 +1,10 @@
 /**
- * Triggers `invalidateResize` when the map's DOM container mutates.
+ * Calls `invalidateSize()` when the map container's inline style changes.
  * 
  * @typedef L.Map.ContainerMutation
+ * @property {boolean} [trackContainerMutation=false] Observe inline style changes on the map container.
+ * 
+ * @since leaflet-rotate (v0.1.0)
  */
 
 /**
@@ -19,6 +22,8 @@ L.Map.mergeOptions({
      *
      * @type {Boolean}
      * 
+     * @since leaflet-rotate (v0.1.0)
+     * 
      * @see https://developer.mozilla.org/docs/Web/API/MutationObserver
      */
     trackContainerMutation: false
@@ -27,6 +32,11 @@ L.Map.mergeOptions({
 
 L.Map.ContainerMutation = L.Handler.extend({
 
+    /**
+     * Start observing the map container's style attribute.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     addHooks() {
         // if (!L.Browser.mutation) { return; }
         if (!this._observer) {
@@ -41,6 +51,11 @@ L.Map.ContainerMutation = L.Handler.extend({
         });
     },
 
+    /**
+     * Stop observing container mutations.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     removeHooks() {
         // if (!L.Browser.mutation) { return; }
         this._observer.disconnect();
@@ -52,5 +67,7 @@ L.Map.ContainerMutation = L.Handler.extend({
  * Add Container mutation handler to L.Map (disabled unless `trackContainerMutation` is set).
  * 
  * @property {L.Map.ContainerMutation} trackContainerMutation
+ * 
+ * @since leaflet-rotate (v0.1.0)
  */
 L.Map.addInitHook('addHandler', 'trackContainerMutation', L.Map.ContainerMutation);

package/src/map/handler/ShiftKeyRotate.js

@@ -1,55 +1,246 @@
 
 /**
- * Rotates the map on shift key + mousewheel scrolling (desktop).
+ * Handles Shift+wheel bearing changes and Ctrl+drag / right-drag bearing/pitch changes.
  * 
  * @typedef L.Map.ShiftKeyRotate
+ * @property {boolean} [shiftKeyRotate=true] Enable Shift+wheel bearing rotation.
+ * 
+ * @since leaflet-rotate (v0.1.0)
  */
 
 L.Map.mergeOptions({
 
     /**
-     * Whether the map can be rotated with shift + wheel scroll
+     * Whether Shift+wheel changes the map bearing.
+     * 
      * @type {Boolean}
+     * 
+     * @since leaflet-rotate (v0.1.0)
      */
     shiftKeyRotate: true,
 
+    /**
+     * Whether Ctrl+drag (or right-button drag) changes bearing and pitch.
+     * 
+     * @type {Boolean}
+     * 
+     * @since leaflet-rotate (0.5.0)
+     */
+    pitchDrag: true,
+
 });
 
 L.Map.ShiftKeyRotate = L.Handler.extend({
 
+    /**
+     * @param {L.Map} map Map controlled by this handler.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
+    initialize(map) {
+        this._map = map;
+        this._onMouseDownBound = this._onMouseDown.bind(this);
+        this._onMouseMoveBound = this._onMouseMove.bind(this);
+        this._onMouseUpBound = this._onMouseUp.bind(this);
+        this._onContextMenuBound = this._onContextMenu.bind(this);
+        this._applyBound = this._apply.bind(this);
+    },
+
+    /**
+     * Attach enabled wheel and pointer/mouse gesture listeners.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     addHooks() {
-        L.DomEvent.on(this._map._container, "wheel", this._handleShiftScroll, this);
-        // this._map.shiftKeyRotate.enable();
-        this._map.shiftKeyRotate.rotate = true;
+        if (this._map.options.shiftKeyRotate) {
+            L.DomEvent.on(this._map._container, "wheel", this._handleShiftScroll, this);
+        }
+        if (this._map.options.pitchDrag) {
+            this.addPitchHooks();
+        }
     },
 
+    /**
+     * Detach gesture listeners and cancel any active drag.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     removeHooks() {
         L.DomEvent.off(this._map._container, "wheel", this._handleShiftScroll, this);
-        this._map.shiftKeyRotate.rotate = false;
+        this.removePitchHooks();
+    },
+
+    /**
+     * Listen for the start of Ctrl+drag pitch gestures.
+     * 
+     * @since leaflet-rotate (0.5.0)
+     */
+    addPitchHooks() {
+        if (this._pitchHooksAdded) { return; }
+        this._pitchEvents = L.version.startsWith('2.')
+            ? ['pointerdown', 'pointermove', 'pointerup pointercancel']
+            : ['mousedown', 'mousemove', 'mouseup'];
+        this._map._container.addEventListener(this._pitchEvents[0], this._onMouseDownBound, true);
+        this._map._container.addEventListener('contextmenu', this._onContextMenuBound, true);
+        this._pitchHooksAdded = true;
+    },
+
+    /**
+     * Stop listening for pitch gestures and remove active document listeners.
+     * 
+     * @since leaflet-rotate (0.5.0)
+     */
+    removePitchHooks() {
+        if (!this._pitchHooksAdded) { return; }
+        this._map._container.removeEventListener(this._pitchEvents[0], this._onMouseDownBound, true);
+        this._map._container.removeEventListener('contextmenu', this._onContextMenuBound, true);
+        this._onMouseUp();
+        delete this._pitchEvents;
+        this._pitchHooksAdded = false;
     },
 
+    /**
+     * Rotate the map in fixed increments while Shift is held during wheel input.
+     * 
+     * @param {WheelEvent} e Wheel event from the map container.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     _handleShiftScroll(e) {
         if (e.shiftKey) {
             e.preventDefault();
             this._map.scrollWheelZoom.disable();
-            this._map.setBearing((this._map._bearing * (180 / Math.PI)) + Math.sign(e.deltaY) * 5);
+            this._map.setBearing(this._map.getBearing() + Math.sign(e.deltaY) * 5);
         } else {
             this._map.scrollWheelZoom.enable();
         }
     },
 
+    /**
+     * Start Ctrl+drag (or right-button drag) and capture subsequent movement outside the map.
+     * 
+     * @param {MouseEvent|PointerEvent} e Gesture start event.
+     * 
+     * @since leaflet-rotate (0.5.0)
+     */
+    _onMouseDown(e) {
+        if (this._dragging) { return; }
+        this._moved = false;
+        if (!this._map._rotate || !this._map.options.pitchDrag || !(e.button === 2 || (e.ctrlKey && e.button === 0))) { return; }
+
+        const scrollWheelZoom = this._map.scrollWheelZoom;
+        if (scrollWheelZoom && scrollWheelZoom._timer) {
+            clearTimeout(scrollWheelZoom._timer);
+            scrollWheelZoom._timer = null;
+            scrollWheelZoom._delta = 0;
+            scrollWheelZoom._startTime = null;
+        }
+
+        e.preventDefault();
+        e.stopPropagation();
+        e.stopImmediatePropagation();
+        this._map._stopPitchBearingAnimation();
+        this._dragging = true;
+        this._lastX = e.clientX;
+        this._lastY = e.clientY;
+        this._pitchDelta = this._bearingDelta = 0;
+        document.addEventListener(this._pitchEvents[1], this._onMouseMoveBound);
+        for (const event of this._pitchEvents[2].split(' ')) {
+            document.addEventListener(event, this._onMouseUpBound);
+        }
+    },
+
+    /**
+     * Accumulate pointer movement as pitch (vertical) and bearing (horizontal).
+     * Far from the horizontal center line the bearing follows the pointer angle
+     * around the map center.
+     * 
+     * @param {MouseEvent|PointerEvent} e Gesture movement event.
+     * 
+     * @since leaflet-rotate (0.5.0)
+     */
+    _onMouseMove(e) {
+        const rect = this._map._container.getBoundingClientRect(),
+            cx = rect.left + rect.width / 2,
+            cy = rect.top + rect.height / 2,
+            x = e.clientX,
+            y = e.clientY;
+
+        this._pitchDelta += (this._lastY - y) * 0.5;
+        this._bearingDelta += Math.abs(cy - this._lastY) > 100
+            ? (Math.atan2(y - cy, x - cx) - Math.atan2(y - cy, this._lastX - cx)) * (180 / Math.PI)
+            : (x - this._lastX) * 0.8 * (y < cy ? 1 : -1);
+        this._lastX = x;
+        this._lastY = y;
+        this._moved = true;
+        if (!this._frame) {
+            this._frame = requestAnimationFrame(this._applyBound);
+        }
+        e.preventDefault();
+    },
+
+    /**
+     * Apply accumulated movement once per animation frame.
+     * 
+     * @since leaflet-rotate (0.5.1)
+     */
+    _apply() {
+        this._frame = null;
+        if (!this._pitchDelta && !this._bearingDelta) { return; }
+        this._map._setPitchAndBearing(this._map.getPitch() + this._pitchDelta, this._map.getBearing() + this._bearingDelta);
+        this._pitchDelta = this._bearingDelta = 0;
+    },
+
+    /**
+     * Suppress the context menu that follows a right-button drag.
+     * 
+     * @param {MouseEvent} e Context menu event.
+     * 
+     * @since leaflet-rotate (0.5.1)
+     */
+    _onContextMenu(e) {
+        if (this._dragging || this._moved) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+    },
+
+    /**
+     * End Ctrl+drag, flush pending movement and clear document-level listeners.
+     * 
+     * @since leaflet-rotate (0.5.0)
+     */
+    _onMouseUp() {
+        if (!this._pitchEvents || !this._dragging) { return; }
+        document.removeEventListener(this._pitchEvents[1], this._onMouseMoveBound);
+        for (const event of this._pitchEvents[2].split(' ')) {
+            document.removeEventListener(event, this._onMouseUpBound);
+        }
+        cancelAnimationFrame(this._frame);
+        if (this._map._mapPane) { this._apply(); }
+        this._frame = null;
+        this._dragging = false;
+        delete this._lastX;
+        delete this._lastY;
+    },
+
 });
 
 /**
- * Add ShiftKey handler to L.Map (enabled unless `shiftKeyRotate` is unset).
+ * Create the handler when either desktop rotation gesture is enabled.
  * 
- * @property {L.Map.ShiftKeyRotate} shiftKeyRotate
+ * @since leaflet-rotate (v0.1.0)
  */
-L.Map.addInitHook('addHandler', 'shiftKeyRotate', L.Map.ShiftKeyRotate);
-
-// decrease `scrollWheelZoom` handler priority over `shiftKeyRotate` handler
 L.Map.addInitHook(function() {
-    if (this.scrollWheelZoom.enabled() && this.shiftKeyRotate.enabled()) {
+    if (this.options.shiftKeyRotate) {
+        this.shiftKeyRotate = new L.Map.ShiftKeyRotate(this);
+        this.shiftKeyRotate.enable();
+    } else if (this.options.pitchDrag) {
+        this.shiftKeyRotate = new L.Map.ShiftKeyRotate(this);
+        this.shiftKeyRotate.addPitchHooks();
+        this.on('unload', this.shiftKeyRotate.removePitchHooks, this.shiftKeyRotate);
+    }
+    if (this.scrollWheelZoom.enabled() && this.options.shiftKeyRotate) {
         this.scrollWheelZoom.disable();
         this.scrollWheelZoom.enable();
     }

package/src/map/handler/TouchGestures.js

@@ -1,12 +1,27 @@
 /**
- * TouchGestures is both TouchZoom plus TouchRotate
+ * Shared implementation for two-finger pinch zoom and map rotation.
  * 
  * @see https://github.com/fnicollet/Leaflet/commit/a77af51a6b10f308d1b9a16552091d1d0aee8834
  * @see https://github.com/Leaflet/Leaflet/blob/v1.9.3/src/map/handler/Map.TouchZoom.js
  * 
  * @typedef L.Map.TouchGestures
+ * @property {boolean} [bounceAtZoomLimits] Whether pinch zoom may temporarily exceed zoom limits.
+ * @property {boolean} zoom Whether pinch zoom is enabled.
+ * @property {boolean} rotate Whether touch rotation is enabled.
+ * 
+ * @since leaflet-rotate (v0.1.0)
  */
 
+/**
+ * Convert a touch's client coordinates to coordinates relative to the map container.
+ * 
+ * @param {L.Map} map
+ * @param {Touch} touch
+ * 
+ * @returns {L.Point}
+ * 
+ * @since leaflet-rotate (v0.1.0)
+ */
 function touchToContainerPoint(map, touch) {
     const container = map.getContainer(),
         rect = container.getBoundingClientRect();
@@ -20,11 +35,11 @@ function touchToContainerPoint(map, touch) {
 L.Map.mergeOptions({
 
     /**
-     * Set it to false if you don't want the map to
-     * zoom beyond min/max zoom and then bounce back
-     * when pinch-zooming.
+     * Whether pinch zoom may temporarily exceed min/max zoom and bounce back.
      * 
      * @type {Boolean}
+     * 
+     * @since leaflet-rotate (v0.1.0)
      */
     bounceAtZoomLimits: true,
 
@@ -32,29 +47,62 @@ L.Map.mergeOptions({
 
 L.Map.TouchGestures = L.Handler.extend({
 
+    /**
+     * Initialize the shared handler from the map's touch zoom/rotation options.
+     * 
+     * @param {L.Map} map Map whose touch gestures are handled.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     initialize(map) {
         this._map = map;
         this.rotate = !!this._map.options.touchRotate;
         this.zoom = !!this._map.options.touchZoom;
+        this.pitch = !!this._map.options.touchPitch;
     },
 
+    /**
+     * Listen for the start of two-finger gestures on the map container.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     addHooks() {
         L.DomEvent.on(this._map._container, 'touchstart', this._onTouchStart, this);
     },
 
+    /**
+     * Remove the touch-start listener.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     removeHooks() {
         L.DomEvent.off(this._map._container, 'touchstart', this._onTouchStart, this);
     },
 
+    /**
+     * Record initial touch points and start tracking a two-finger gesture.
+     * 
+     * @param {TouchEvent} e Touch-start event.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     _onTouchStart(e) {
         const map = this._map;
 
-        if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming || this._rotating) { return; }
+        if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming || this._rotating || this._gesture) { return; }
 
         const p1 = touchToContainerPoint(map, e.touches[0]),
             p2 = touchToContainerPoint(map, e.touches[1]),
             vector = p1.subtract(p2);
 
+        // Two horizontally aligned fingers moving vertically together change the pitch
+        const canPitch = this.pitch && map._rotate && Math.abs(vector.x) > Math.abs(vector.y);
+        if (!canPitch && !this.zoom && !this.rotate) { return; }
+        this._gesture = canPitch ? 'pending' : 'pinch';
+        this._startP1 = p1;
+        this._startP2 = p2;
+        map._stopPitchBearingAnimation();
+
         this._centerPoint = map.getSize()._divideBy(2);
         this._startLatLng = map.containerPointToLatLng(this._centerPoint);
 
@@ -89,8 +137,15 @@ L.Map.TouchGestures = L.Handler.extend({
         L.DomEvent.preventDefault(e);
     },
 
+    /**
+     * Update bearing and/or zoom while the two touch points move.
+     * 
+     * @param {TouchEvent} e Touch-move event.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     _onTouchMove(e) {
-        if (!e.touches || e.touches.length !== 2 || !(this._zooming || this._rotating)) { return; }
+        if (!e.touches || e.touches.length !== 2 || !this._gesture) { return; }
 
         const map = this._map,
             p1 = touchToContainerPoint(map, e.touches[0]),
@@ -99,6 +154,33 @@ L.Map.TouchGestures = L.Handler.extend({
             scale = p1.distanceTo(p2) / this._startDist;
         let delta;
 
+        if (this._gesture === 'pending') {
+            const d1 = p1.subtract(this._startP1),
+                d2 = p2.subtract(this._startP2);
+            if (Math.max(d1.x * d1.x + d1.y * d1.y, d2.x * d2.x + d2.y * d2.y) < 25) {
+                L.DomEvent.preventDefault(e);
+                return;
+            }
+            const vertical = d => Math.abs(d.y) > Math.abs(d.x);
+            if (vertical(d1) && vertical(d2) && Math.sign(d1.y) === Math.sign(d2.y)) {
+                this._gesture = 'pitch';
+                this._lastPitchY = (this._startP1.y + this._startP2.y) / 2;
+                this._zooming = this._rotating = false;
+            } else {
+                this._gesture = 'pinch';
+            }
+        }
+
+        if (this._gesture === 'pitch') {
+            const y = (p1.y + p2.y) / 2;
+            map._setPitchAndBearing(map.getPitch() - (y - this._lastPitchY) * 0.5, map.getBearing());
+            this._lastPitchY = y;
+            L.DomEvent.preventDefault(e);
+            return;
+        }
+
+        if (!(this._zooming || this._rotating)) { return; }
+
         if (this._rotating) {
             const theta = Math.atan(vector.x / vector.y);
             let bearingDelta = (theta - this._startTheta) * (180 / Math.PI);
@@ -133,9 +215,12 @@ L.Map.TouchGestures = L.Handler.extend({
                 delta = p1._add(p2)._divideBy(2)._subtract(this._centerPoint);
                 if (scale === 1 && delta.x === 0 && delta.y === 0) { return; }
 
-                const alpha = -map.getBearing() * (Math.PI / 180);
+                const mapDelta = map._pitch
+                    ? map.containerPointToLayerPoint(this._centerPoint.add(delta))
+                        .subtract(map.containerPointToLayerPoint(this._centerPoint))
+                    : delta.rotate(-map.getBearing() * (Math.PI / 180));
 
-                this._center = map.unproject(map.project(this._pinchStartLatLng).subtract(delta.rotate(alpha)));
+                this._center = map.unproject(map.project(this._pinchStartLatLng).subtract(mapDelta));
             }
 
         }
@@ -159,9 +244,20 @@ L.Map.TouchGestures = L.Handler.extend({
         L.DomEvent.preventDefault(e);
     },
 
+    /**
+     * Finish the gesture, settle the zoom and remove document listeners.
+     * 
+     * @since leaflet-rotate (v0.1.0)
+     */
     _onTouchEnd() {
-        if (!this._moved || !(this._zooming || this._rotating)) {
+        const gesture = this._gesture;
+        delete this._gesture;
+        if (gesture === 'pitch' || gesture === 'pending' || !this._moved || !(this._zooming || this._rotating)) {
             this._zooming = false;
+            this._rotating = false;
+            L.DomEvent
+                .off(document, 'touchmove', this._onTouchMove, this)
+                .off(document, 'touchend touchcancel', this._onTouchEnd, this);
             return;
         }
 
@@ -184,8 +280,10 @@ L.Map.TouchGestures = L.Handler.extend({
 });
 
 /**
- * Add Touch Gestures handler (enabled unless `touchGestures` is unset).
+ * Add the shared touch gesture handler to the map.
  * 
  * @property {L.Map.TouchGestures} touchGestures
+ * 
+ * @since leaflet-rotate (v0.1.0)
  */
 L.Map.addInitHook('addHandler', 'touchGestures', L.Map.TouchGestures);

package/src/map/handler/TouchPitch.js

@@ -0,0 +1,53 @@
+/**
+ * Enables MapLibre-like two-finger pitch (both fingers dragged vertically) through the shared touch-gesture handler.
+ * 
+ * @typedef L.Map.TouchPitch
+ * @property {boolean} [touchPitch=false] Enable two-finger map pitch (vertical drag).
+ * 
+ * @since leaflet-rotate (0.5.1)
+ */
+
+L.Map.mergeOptions({
+
+    /**
+     * Whether the map can be pitched by dragging two fingers vertically
+     * 
+     * @type {Boolean}
+     * 
+     * @since leaflet-rotate (0.5.1)
+     */
+    touchPitch: false,
+
+});
+
+L.Map.TouchPitch = L.Handler.extend({
+
+    /**
+     * Enable pitch handling in the map's shared touch gesture handler.
+     * 
+     * @since leaflet-rotate (0.5.1)
+     */
+    addHooks() {
+        this._map.touchGestures.enable();
+        this._map.touchGestures.pitch = true;
+    },
+
+    /**
+     * Disable pitch handling without affecting pinch zoom and rotation.
+     * 
+     * @since leaflet-rotate (0.5.1)
+     */
+    removeHooks() {
+        this._map.touchGestures.pitch = false;
+    },
+
+});
+
+/**
+ * Add Touch Pitch handler (disabled unless `touchGestures` is set).
+ * 
+ * @property {L.Map.TouchGestures} touchGestures
+ * 
+ * @since leaflet-rotate (0.5.1)
+ */
+L.Map.addInitHook('addHandler', 'touchPitch', L.Map.TouchPitch);