A simple swipe detection on vanilla js

swipe.js

var touchstartX = 0;
var touchstartY = 0;
var touchendX = 0;
var touchendY = 0;

var gesuredZone = document.getElementById('gesuredZone');

gesuredZone.addEventListener('touchstart', function(event) {
    touchstartX = event.screenX;
    touchstartY = event.screenY;
}, false);

gesuredZone.addEventListener('touchend', function(event) {
    touchendX = event.screenX;
    touchendY = event.screenY;
    handleGesure();
}, false); 

function handleGesure() {
    var swiped = 'swiped: ';
    if (touchendX < touchstartX) {
        alert(swiped + 'left!');
    }
    if (touchendX > touchstartX) {
        alert(swiped + 'right!');
    }
    if (touchendY < touchstartY) {
        alert(swiped + 'down!');
    }
    if (touchendY > touchstartY) {
        alert(swiped + 'left!');
    }
    if (touchendY == touchstartY) {
        alert('tap!');
    }
}

Hello,

This api event.screen does not work any more.

Change to e.changedTouches[0].screenY; and e.changedTouches[0].screenX;

Also line 31 should say up.

Actually, in this script, it should be : event.changedTouches[0].screenY; and event.changedTouches[0].screenX;

THX
with some errors, but still better than jQuery

@SleepWalker also line 31 should be the 'up' direction

Useless.

Worked for me thanks! :)

Thanks! I made some small tweaks to this, based on the comments above:

let touchstartX = 0;
let touchstartY = 0;
let touchendX = 0;
let touchendY = 0;

const gestureZone = document.getElementById('gestureZone');

gestureZone.addEventListener('touchstart', function(event) {
    touchstartX = event.changedTouches[0].screenX;
    touchstartY = event.changedTouches[0].screenY;
}, false);

gestureZone.addEventListener('touchend', function(event) {
    touchendX = event.changedTouches[0].screenX;
    touchendY = event.changedTouches[0].screenY;
    handleGesture();
}, false); 

function handleGesture() {
    if (touchendX <= touchstartX) {
        console.log('Swiped left');
    }
    
    if (touchendX >= touchstartX) {
        console.log('Swiped right');
    }
    
    if (touchendY <= touchstartY) {
        console.log('Swiped up');
    }
    
    if (touchendY >= touchstartY) {
        console.log('Swiped down');
    }
    
    if (touchendY === touchstartY) {
        console.log('Tap');
    }
}

Thank you, it was very helpful!

Thx!

I have a different approach for the handleGesture ( does not include the tap though ) that works with the dimensions of the element that the events are occuring on ( because let's face it, users do not swipe in a straight line most of the time, and we should account for this )

const { width, height } = dom_el.getBoundingClientRect();

const ratio_horizontal = (end.screenX - start.screenX) / width;
const ratio_vertical = (end.screenY - start.screenY) / height;

if (ratio_horizontal > ratio_vertical && ratio_horizontal > 0.25) {
    return console.log('swipe-right');
}
if (ratio_vertical > ratio_horizontal && ratio_vertical > 0.25) {
    return console.log('swipe-down');
}
if (ratio_horizontal < ratio_vertical && ratio_horizontal < -0.25) {
    return console.log('swipe-left');
}
if (ratio_vertical < ratio_horizontal && ratio_vertical < -0.25) {
    return console.log('swipe-up');
}

return false;

@mocon heads up on your revisions if you haven't already noticed

Seems to me that including using touchendX <= touchstartX etc instead of touchendX < touchstartX etc in the handleGesture code means that any "tap" will also register every swipe event

@IanRr thanks for that correction. @mocon thanks for tweak
It works fine now

let touchstartX = 0;
let touchstartY = 0;
let touchendX = 0;
let touchendY = 0;

const gestureZone = document.getElementById('modalContent');

gestureZone.addEventListener('touchstart', function(event) {
    touchstartX = event.changedTouches[0].screenX;
    touchstartY = event.changedTouches[0].screenY;
}, false);

gestureZone.addEventListener('touchend', function(event) {
    touchendX = event.changedTouches[0].screenX;
    touchendY = event.changedTouches[0].screenY;
    handleGesture();
}, false); 

function handleGesture() {
    if (touchendX < touchstartX) {
        console.log('Swiped left');
    }
    
    if (touchendX > touchstartX) {
        console.log('Swiped right');
    }
    
    if (touchendY < touchstartY) {
        console.log('Swiped up');
    }
    
    if (touchendY > touchstartY) {
       console.log('Swiped down');
    }
    
    if (touchendY === touchstartY) {
       console.log('Tap');
    }
}

Small modification of @stephenjude using angles (45° for each of the 8 directions) to determine the direction and a treshold of 1px or 1% of page width:

let pageWidth = window.innerWidth || document.body.clientWidth;
let treshold = Math.max(1,Math.floor(0.01 * (pageWidth)));
let touchstartX = 0;
let touchstartY = 0;
let touchendX = 0;
let touchendY = 0;

const limit = Math.tan(45 * 1.5 / 180 * Math.PI);
const gestureZone = document.getElementById('modalContent');

gestureZone.addEventListener('touchstart', function(event) {
    touchstartX = event.changedTouches[0].screenX;
    touchstartY = event.changedTouches[0].screenY;
}, false);

gestureZone.addEventListener('touchend', function(event) {
    touchendX = event.changedTouches[0].screenX;
    touchendY = event.changedTouches[0].screenY;
    handleGesture(event);
}, false);

function handleGesture(e) {
    let x = touchendX - touchstartX;
    let y = touchendY - touchstartY;
    let xy = Math.abs(x / y);
    let yx = Math.abs(y / x);
    if (Math.abs(x) > treshold || Math.abs(y) > treshold) {
        if (yx <= limit) {
            if (x < 0) {
                console.log("left");
            } else {
                console.log("right");
            }
        }
        if (xy <= limit) {
            if (y < 0) {
                console.log("top");
            } else {
                console.log("bottom");
            }
        }
    } else {
        console.log("tap");
    }
}

Like !

i add this script to npm

npm link:
https://www.npmjs.com/package/xwiper

github link:
https://github.com/uxitten/xwiper

Hello , actually won't work on some Android Chrome newer versions... If someone could add browser interogation for Pointer Events and a solution for the it , would be our hero !

Idk... I tried to modify uxitten approach with Pointer Events ... If someone could write a more elegant version of this with pinch and multiple taps would be awesome ...

class Xwiper {
    constructor(element) {
        this.element = null;
        this.touchStartX = 0;
        this.touchStartY = 0;
        this.touchEndX = 0;
        this.touchEndY = 0;
        this.touchMovedX = 0;
        this.touchMovedY = 0;
        this.sensitive = 5;
        this.onSwipeLeftAgent = null;
        this.onSwipeRightAgent = null;
        this.onSwipeUpAgent = null;
        this.onSwipeDownAgent = null;
        this.onTapAgent = null;
        this.onTouchStart = this.onTouchStart.bind(this);
        this.onTouchEnd = this.onTouchEnd.bind(this);
        this.onPointerStart = this.onPointerStart.bind(this);
        this.onPointerMoved = this.onPointerMoved.bind(this);
        this.onPointerEnd = this.onPointerEnd.bind(this);
        this.onSwipeLeft = this.onSwipeLeft.bind(this);
        this.onSwipeRight = this.onSwipeRight.bind(this);
        this.onSwipeUp = this.onSwipeUp.bind(this);
        this.onSwipeDown = this.onSwipeDown.bind(this);
        this.onTap = this.onTap.bind(this);
        this.destroy = this.destroy.bind(this);
        this.handleGesture = this.handleGesture.bind(this);

        this.element = document.querySelector(element);
		if (window.PointerEvent) {
			this.element.addEventListener( 'pointerdown', this.onPointerStart,false);

			this.element.addEventListener( 'pointermove', this.onPointerMoved,false);
				
			this.element.addEventListener( 'pointercancel', this.onPointerEnd,false);
		} else {
			this.element.addEventListener('touchstart', this.onTouchStart ,false);
			this.element.addEventListener('touchend', this.onTouchEnd, false);	
		}
    }

    onTouchStart(event) {
        this.touchStartX = event.changedTouches[0].screenX;
        this.touchStartY = event.changedTouches[0].screenY;
    }

    onTouchEnd(event) {
        this.touchEndX = event.changedTouches[0].screenX;
        this.touchEndY = event.changedTouches[0].screenY;
        this.handleGesture();
    }

    onPointerStart(event) {
		switch ( event.pointerType ) {
			case 'mouse':
				//add code
			break;

			case 'touch':
				this.touchStartX = event.screenX;
				this.touchStartY = event.screenY;
			break;
			case 'pen':
				//add code
			break;
			default:
				//add code
			break;
			}
    }

    onPointerMoved(event) {
		switch ( event.pointerType ) {
			case 'mouse':
				//add code
			break;
			case 'touch':
				this.touchMovedX = event.screenX;
				this.touchMovedY = event.screenY;
			break;
			case 'pen':
				//add code
			break;
			default:
				//add code
			break;
		}
    }
    onPointerEnd(event) {
		switch ( event.pointerType ) {
			case 'mouse':
				//add code
			break;

			case 'touch':
				this.touchEndX = this.touchMovedX;
				this.touchEndY = this.touchMovedY;
			break;

			case 'pen':
				//add code
			break;

			default:
				//add code
			break;
		}
        this.handleGesture();
    }

    onSwipeLeft(func) {
        this.onSwipeLeftAgent = func;
    }
    onSwipeRight(func) {
        this.onSwipeRightAgent = func;
    }
    onSwipeUp(func) {
        this.onSwipeUpAgent = func;
    }
    onSwipeDown(func) {
        this.onSwipeDownAgent = func;
    }
    onTap(func) {
        this.onTapAgent = func;
    }

    destroy() {
        this.element.removeEventListener('touchstart', this.onTouchStart);
        this.element.removeEventListener('touchend', this.onTouchEnd);
        this.element.removeEventListener('pointerstart', this.onTouchStart);
        this.element.removeEventListener('pointermove', this.onTouchMove);
        this.element.removeEventListener('touchover', this.onTouchEnd);
    }

	handleGesture() {
        /**
         * swiped left
         */
        if (this.touchEndX + this.sensitive < this.touchStartX) {
            this.onSwipeLeftAgent &&
                this.onSwipeLeftAgent();
            return 'swiped left';
        }

        /**
         * swiped right
         */
        if (this.touchEndX - this.sensitive > this.touchStartX) {
            this.onSwipeRightAgent &&
                this.onSwipeRightAgent();
            return 'swiped right';
        }

        /**
         * swiped up
         */
        if (this.touchEndY + this.sensitive < this.touchStartY) {
            this.onSwipeUpAgent &&
                this.onSwipeUpAgent();
            return 'swiped up';
        }

        /**
         * swiped down
         */
        if (this.touchEndY - this.sensitive > this.touchStartY) {
            this.onSwipeDownAgent &&
                this.onSwipeDownAgent();
            return 'swiped down';
        }

        /**
         * tap
         */
        if (this.touchEndY === this.touchStartY) {
            this.onTapAgent &&
                this.onTapAgent();
            return 'tap';
        }
    }
}

I took a shot at improving this too. I added multiple listeners support, long press, mouse support, velocity threshold, and customization. It's on NPM and GitHub:

https://www.npmjs.com/package/tinygesture
https://github.com/sciactive/tinygesture

Here's a demo:
https://sciactive.github.io/tinygesture/

Thank you @SleepWalker, @uxitten, @c7x43t.

Thank you so much.
Pretty usefull !~

Here I leave you some code I use, some of it was initially based on the code listed here, then modified to adjust to my needs and new events.

TlakDev.EventHandler.prototype._defaults = {
	touch: {
		x: 0,
		y: 0
	},
	touchEnd: {
		x: 0,
		y: 0
	}
}
TlakDev.EventHandler.prototype.sendTouchEvent = function (event, element) {
	let t = this;
	switch(true){
		case ((Math.abs(t.touch.x) - Math.abs(t.touchEnd.x)) === 0) && ((Math.abs(t.touch.y) - Math.abs(t.touchEnd.y)) === 0):
			event.direction = "tap";
		break;
		case Math.abs(t.touch.x - t.touchEnd.x) > Math.abs(t.touch.y - t.touchEnd.y):
			/*left/right*/
			if(t.touch.x > t.touchEnd.x){
				event.direction = "left";
			} else {
				event.direction = "right";
			}
		break;
		default:
			/*up/down*/
			if(t.touch.y < t.touchEnd.y){
				event.direction = "down";
			} else {
				event.direction = "up";
			}
		break;
	}
	switch(true){
		case ((Math.abs(t.touch.x) - Math.abs(t.touchEnd.x)) === 0) && ((Math.abs(t.touch.y) - Math.abs(t.touchEnd.y)) === 0):
			event.directionPrecision = "tap";
		break;
		case t.touch.x > t.touchEnd.x:
			/*left*/
			if(t.touch.y > t.touchEnd.y){
				event.directionPrecision = "upLeft";
			} else {
				event.directionPrecision = "downLeft";
			}
		break;
		default:
			/*right*/
			if(t.touch.y > t.touchEnd.y){
				event.directionPrecision = "upRight";
			} else {
				event.directionPrecision = "downRight";
			}
		break;
	}
	/*
	 * Do whatever you need with the event/element
	 * The event contains 2 properties
	 * 1. direction  = tap|left|right|up|down
	 * 2. directionPrecision tap|upRight|upLeft|downRight|downLeft
	*/
}
TlakDev.EventHandler.prototype.setTouch = function (event) {
	let e = {};
	if(event.screenY){
		e.x = event.screenX;
		e.y = event.screenY;
	} else if(typeof event.touches !== "undefined" && event.touches.length > 0){
		e.x = event.touches[0].pageX;
		e.y = event.touches[0].pageY;
	} else if(typeof event.changedTouches !== "undefined" && event.changedTouches.length > 0) {
		e.x = event.changedTouches[0].pageX;
		e.y = event.changedTouches[0].pageY;
	} else {
		e.x = 0;
		e.y = 0;
	}
	return e;
}
/*
@param nodes is an array of javascript elements to which apply the events
*/
TlakDev.EventHandler.prototype.handleSwipes = function (nodes) {
	let t = this;
	nodes.forEach(function(element){
		element.addEventListener("touchstart", function (event) {
			let e = t.setTouch(event);
			t.touch = e;
		});
		element.addEventListener("touchend", function (event) {
			let e = t.setTouch(event);
			t.touchEnd = e;
			t.sendTouchEvent(event, element);
		});
	});
}

Function that only listen the y down event.

`
var swipe = document.getElementById('swipe');

  var touchstartY = 0;
  var touchendY = 0;

  swipe.addEventListener('touchstart', function(event) {
    touchstartY = event.changedTouches[0].screenY;
  }, false);

  swipe.addEventListener('touchend', function(event) {
    touchendY = event.changedTouches[0].screenY;
      handleSwipe();
  }, false); 

  function handleSwipe() {
      var swiped = 'swiped: ';
      if (touchendY > touchstartY) {
          alert(swiped + 'down!');
      }
  }

`

Thanks a lot ;)