barsa-user-workspace 0.0.0-watch

package/esm2022/lib/utils/pointer.utils.mjs

@@ -0,0 +1,110 @@
+import { fromEvent, iif, merge } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { ktdNormalizePassiveListenerOptions } from './passive-listeners';
+/** Options that can be used to bind a passive event listener. */
+const passiveEventListenerOptions = ktdNormalizePassiveListenerOptions({ passive: true });
+/** Options that can be used to bind an active event listener. */
+const activeEventListenerOptions = ktdNormalizePassiveListenerOptions({ passive: false });
+let isMobile = null;
+export function ktdIsMobileOrTablet() {
+    if (isMobile != null) {
+        return isMobile;
+    }
+    // Generic match pattern to identify mobile or tablet devices
+    const isMobileDevice = /Android|webOS|BlackBerry|Windows Phone|iPad|iPhone|iPod/i.test(navigator.userAgent);
+    // Since IOS 13 is not safe to just check for the generic solution. See: https://stackoverflow.com/questions/58019463/how-to-detect-device-name-in-safari-on-ios-13-while-it-doesnt-show-the-correct
+    const isIOSMobileDevice = /iPad|iPhone|iPod/.test(navigator.platform) || (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
+    isMobile = isMobileDevice || isIOSMobileDevice;
+    return isMobile;
+}
+export function ktdIsMouseEvent(event) {
+    return event.clientX != null;
+}
+export function ktdIsTouchEvent(event) {
+    return event.touches != null && event.touches.length != null;
+}
+export function ktdPointerClientX(event) {
+    return ktdIsMouseEvent(event) ? event.clientX : event.touches[0].clientX;
+}
+export function ktdPointerClientY(event) {
+    return ktdIsMouseEvent(event) ? event.clientY : event.touches[0].clientY;
+}
+export function ktdPointerClient(event) {
+    return {
+        clientX: ktdIsMouseEvent(event) ? event.clientX : event.touches[0].clientX,
+        clientY: ktdIsMouseEvent(event) ? event.clientY : event.touches[0].clientY
+    };
+}
+export function ktdIsMouseEventOrMousePointerEvent(event) {
+    return event.type === 'mousedown'
+        || (event.type === 'pointerdown' && event.pointerType === 'mouse');
+}
+/** Returns true if browser supports pointer events */
+export function ktdSupportsPointerEvents() {
+    return !!window.PointerEvent;
+}
+/**
+ * Emits when a mousedown or touchstart emits. Avoids conflicts between both events.
+ * @param element, html element where to  listen the events.
+ * @param touchNumber number of the touch to track the event, default to the first one.
+ */
+function ktdMouseOrTouchDown(element, touchNumber = 1) {
+    return iif(() => ktdIsMobileOrTablet(), fromEvent(element, 'touchstart', passiveEventListenerOptions).pipe(filter((touchEvent) => touchEvent.touches.length === touchNumber)), fromEvent(element, 'mousedown', activeEventListenerOptions).pipe(filter((mouseEvent) => {
+        /**
+         * 0 : Left mouse button
+         * 1 : Wheel button or middle button (if present)
+         * 2 : Right mouse button
+         */
+        return mouseEvent.button === 0; // Mouse down to be only fired if is left click
+    })));
+}
+/**
+ * Emits when a 'mousemove' or a 'touchmove' event gets fired.
+ * @param element, html element where to  listen the events.
+ * @param touchNumber number of the touch to track the event, default to the first one.
+ */
+function ktdMouseOrTouchMove(element, touchNumber = 1) {
+    return iif(() => ktdIsMobileOrTablet(), fromEvent(element, 'touchmove', activeEventListenerOptions).pipe(filter((touchEvent) => touchEvent.touches.length === touchNumber)), fromEvent(element, 'mousemove', activeEventListenerOptions));
+}
+export function ktdTouchEnd(element, touchNumber = 1) {
+    return merge(fromEvent(element, 'touchend').pipe(filter((touchEvent) => touchEvent.touches.length === touchNumber - 1)), fromEvent(element, 'touchcancel').pipe(filter((touchEvent) => touchEvent.touches.length === touchNumber - 1)));
+}
+/**
+ * Emits when a there is a 'mouseup' or the touch ends.
+ * @param element, html element where to  listen the events.
+ * @param touchNumber number of the touch to track the event, default to the first one.
+ */
+function ktdMouserOrTouchEnd(element, touchNumber = 1) {
+    return iif(() => ktdIsMobileOrTablet(), ktdTouchEnd(element, touchNumber), fromEvent(element, 'mouseup'));
+}
+/**
+ * Emits when a 'pointerdown' event occurs (only for the primary pointer). Fallbacks to 'mousemove' or a 'touchmove' if pointer events are not supported.
+ * @param element, html element where to listen the events.
+ */
+export function ktdPointerDown(element) {
+    if (!ktdSupportsPointerEvents()) {
+        return ktdMouseOrTouchDown(element);
+    }
+    return fromEvent(element, 'pointerdown', activeEventListenerOptions).pipe(filter((pointerEvent) => pointerEvent.isPrimary));
+}
+/**
+ * Emits when a 'pointermove' event occurs (only for the primary pointer). Fallbacks to 'mousemove' or a 'touchmove' if pointer events are not supported.
+ * @param element, html element where to listen the events.
+ */
+export function ktdPointerMove(element) {
+    if (!ktdSupportsPointerEvents()) {
+        return ktdMouseOrTouchMove(element);
+    }
+    return fromEvent(element, 'pointermove', activeEventListenerOptions).pipe(filter((pointerEvent) => pointerEvent.isPrimary));
+}
+/**
+ * Emits when a 'pointerup' event occurs (only for the primary pointer). Fallbacks to 'mousemove' or a 'touchmove' if pointer events are not supported.
+ * @param element, html element where to listen the events.
+ */
+export function ktdPointerUp(element) {
+    if (!ktdSupportsPointerEvents()) {
+        return ktdMouserOrTouchEnd(element);
+    }
+    return fromEvent(element, 'pointerup').pipe(filter(pointerEvent => pointerEvent.isPrimary));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pointer.utils.js","sourceRoot":"","sources":["../../../../../projects/barsa-user-workspace/src/lib/utils/pointer.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,EAAc,MAAM,MAAM,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAEzE,iEAAiE;AACjE,MAAM,2BAA2B,GAAG,kCAAkC,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC,CAAC;AAExF,iEAAiE;AACjE,MAAM,0BAA0B,GAAG,kCAAkC,CAAC,EAAC,OAAO,EAAE,KAAK,EAAC,CAAC,CAAC;AAExF,IAAI,QAAQ,GAAmB,IAAI,CAAC;AAEpC,MAAM,UAAU,mBAAmB;IAE/B,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;QACnB,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,6DAA6D;IAC7D,MAAM,cAAc,GAAG,0DAA0D,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IAE5G,oMAAoM;IACpM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,KAAK,UAAU,IAAI,SAAS,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC;IAE7I,QAAQ,GAAG,cAAc,IAAI,iBAAiB,CAAC;IAE/C,OAAO,QAAQ,CAAC;AACpB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAU;IACtC,OAAQ,KAAoB,CAAC,OAAO,IAAI,IAAI,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAU;IACtC,OAAQ,KAAoB,CAAC,OAAO,IAAI,IAAI,IAAK,KAAoB,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC;AACjG,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAA8B;IAC5D,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;AAC7E,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAA8B;IAC5D,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;AAC7E,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,KAA8B;IAC3D,OAAO;QACH,OAAO,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO;QAC1E,OAAO,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO;KAC7E,CAAC;AACN,CAAC;AAED,MAAM,UAAU,kCAAkC,CAAC,KAA6C;IAC5F,OAAO,KAAK,CAAC,IAAI,KAAK,WAAW;WAC1B,CAAC,KAAK,CAAC,IAAI,KAAK,aAAa,IAAK,KAAsB,CAAC,WAAW,KAAK,OAAO,CAAC,CAAC;AAC7F,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,wBAAwB;IACpC,OAAO,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC;AACjC,CAAC;AAED;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,CAAC;IACjD,OAAO,GAAG,CACN,GAAG,EAAE,CAAC,mBAAmB,EAAE,EAC3B,SAAS,CAAa,OAAO,EAAE,YAAY,EAAE,2BAAsD,CAAC,CAAC,IAAI,CACrG,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,KAAK,WAAW,CAAC,CACpE,EACD,SAAS,CAAa,OAAO,EAAE,WAAW,EAAE,0BAAqD,CAAC,CAAC,IAAI,CACnG,MAAM,CAAC,CAAC,UAAsB,EAAE,EAAE;QAC9B;;;;WAIG;QACH,OAAO,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,+CAA+C;IACnF,CAAC,CAAC,CACL,CACJ,CAAC;AACN,CAAC;AAED;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,OAAoB,EAAE,WAAW,GAAG,CAAC;IAC9D,OAAO,GAAG,CACN,GAAG,EAAE,CAAC,mBAAmB,EAAE,EAC3B,SAAS,CAAa,OAAO,EAAE,WAAW,EAAE,0BAAqD,CAAC,CAAC,IAAI,CACnG,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,KAAK,WAAW,CAAC,CACpE,EACD,SAAS,CAAa,OAAO,EAAE,WAAW,EAAE,0BAAqD,CAAC,CACrG,CAAC;AACN,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,CAAC;IAChD,OAAO,KAAK,CACR,SAAS,CAAa,OAAO,EAAE,UAAU,CAAC,CAAC,IAAI,CAC3C,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,KAAK,WAAW,GAAG,CAAC,CAAC,CACxE,EACD,SAAS,CAAa,OAAO,EAAE,aAAa,CAAC,CAAC,IAAI,CAC9C,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,KAAK,WAAW,GAAG,CAAC,CAAC,CACxE,CACJ,CAAC;AACN,CAAC;AAED;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,OAAoB,EAAE,WAAW,GAAG,CAAC;IAC9D,OAAO,GAAG,CACN,GAAG,EAAE,CAAC,mBAAmB,EAAE,EAC3B,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,EACjC,SAAS,CAAa,OAAO,EAAE,SAAS,CAAC,CAC5C,CAAC;AACN,CAAC;AAGD;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,OAAO;IAClC,IAAI,CAAC,wBAAwB,EAAE,EAAE,CAAC;QAC9B,OAAO,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IAED,OAAO,SAAS,CAAe,OAAO,EAAE,aAAa,EAAE,0BAAqD,CAAC,CAAC,IAAI,CAC9G,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,CACnD,CAAA;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,OAAO;IAClC,IAAI,CAAC,wBAAwB,EAAE,EAAE,CAAC;QAC9B,OAAO,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,SAAS,CAAe,OAAO,EAAE,aAAa,EAAE,0BAAqD,CAAC,CAAC,IAAI,CAC9G,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,CACnD,CAAC;AACN,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,OAAO;IAChC,IAAI,CAAC,wBAAwB,EAAE,EAAE,CAAC;QAC9B,OAAO,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,SAAS,CAAe,OAAO,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;AAC9G,CAAC","sourcesContent":["import { fromEvent, iif, merge, Observable } from 'rxjs';\nimport { filter } from 'rxjs/operators';\nimport { ktdNormalizePassiveListenerOptions } from './passive-listeners';\n\n/** Options that can be used to bind a passive event listener. */\nconst passiveEventListenerOptions = ktdNormalizePassiveListenerOptions({passive: true});\n\n/** Options that can be used to bind an active event listener. */\nconst activeEventListenerOptions = ktdNormalizePassiveListenerOptions({passive: false});\n\nlet isMobile: boolean | null = null;\n\nexport function ktdIsMobileOrTablet(): boolean {\n\n    if (isMobile != null) {\n        return isMobile;\n    }\n\n    // Generic match pattern to identify mobile or tablet devices\n    const isMobileDevice = /Android|webOS|BlackBerry|Windows Phone|iPad|iPhone|iPod/i.test(navigator.userAgent);\n\n    // Since IOS 13 is not safe to just check for the generic solution. See: https://stackoverflow.com/questions/58019463/how-to-detect-device-name-in-safari-on-ios-13-while-it-doesnt-show-the-correct\n    const isIOSMobileDevice = /iPad|iPhone|iPod/.test(navigator.platform) || (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);\n\n    isMobile = isMobileDevice || isIOSMobileDevice;\n\n    return isMobile;\n}\n\nexport function ktdIsMouseEvent(event: any): event is MouseEvent {\n    return (event as MouseEvent).clientX != null;\n}\n\nexport function ktdIsTouchEvent(event: any): event is TouchEvent {\n    return (event as TouchEvent).touches != null && (event as TouchEvent).touches.length != null;\n}\n\nexport function ktdPointerClientX(event: MouseEvent | TouchEvent): number {\n    return ktdIsMouseEvent(event) ? event.clientX : event.touches[0].clientX;\n}\n\nexport function ktdPointerClientY(event: MouseEvent | TouchEvent): number {\n    return ktdIsMouseEvent(event) ? event.clientY : event.touches[0].clientY;\n}\n\nexport function ktdPointerClient(event: MouseEvent | TouchEvent): { clientX: number, clientY: number } {\n    return {\n        clientX: ktdIsMouseEvent(event) ? event.clientX : event.touches[0].clientX,\n        clientY: ktdIsMouseEvent(event) ? event.clientY : event.touches[0].clientY\n    };\n}\n\nexport function ktdIsMouseEventOrMousePointerEvent(event: MouseEvent | TouchEvent | PointerEvent): boolean {\n    return event.type === 'mousedown'\n        || (event.type === 'pointerdown' && (event as PointerEvent).pointerType === 'mouse');\n}\n\n/** Returns true if browser supports pointer events */\nexport function ktdSupportsPointerEvents(): boolean {\n    return !!window.PointerEvent;\n}\n\n/**\n * Emits when a mousedown or touchstart emits. Avoids conflicts between both events.\n * @param element, html element where to  listen the events.\n * @param touchNumber number of the touch to track the event, default to the first one.\n */\nfunction ktdMouseOrTouchDown(element, touchNumber = 1): Observable<MouseEvent | TouchEvent> {\n    return iif(\n        () => ktdIsMobileOrTablet(),\n        fromEvent<TouchEvent>(element, 'touchstart', passiveEventListenerOptions as AddEventListenerOptions).pipe(\n            filter((touchEvent) => touchEvent.touches.length === touchNumber)\n        ),\n        fromEvent<MouseEvent>(element, 'mousedown', activeEventListenerOptions as AddEventListenerOptions).pipe(\n            filter((mouseEvent: MouseEvent) => {\n                /**\n                 * 0 : Left mouse button\n                 * 1 : Wheel button or middle button (if present)\n                 * 2 : Right mouse button\n                 */\n                return mouseEvent.button === 0; // Mouse down to be only fired if is left click\n            })\n        )\n    );\n}\n\n/**\n * Emits when a 'mousemove' or a 'touchmove' event gets fired.\n * @param element, html element where to  listen the events.\n * @param touchNumber number of the touch to track the event, default to the first one.\n */\nfunction ktdMouseOrTouchMove(element: HTMLElement, touchNumber = 1): Observable<MouseEvent | TouchEvent> {\n    return iif(\n        () => ktdIsMobileOrTablet(),\n        fromEvent<TouchEvent>(element, 'touchmove', activeEventListenerOptions as AddEventListenerOptions).pipe(\n            filter((touchEvent) => touchEvent.touches.length === touchNumber),\n        ),\n        fromEvent<MouseEvent>(element, 'mousemove', activeEventListenerOptions as AddEventListenerOptions)\n    );\n}\n\nexport function ktdTouchEnd(element, touchNumber = 1): Observable<TouchEvent> {\n    return merge(\n        fromEvent<TouchEvent>(element, 'touchend').pipe(\n            filter((touchEvent) => touchEvent.touches.length === touchNumber - 1)\n        ),\n        fromEvent<TouchEvent>(element, 'touchcancel').pipe(\n            filter((touchEvent) => touchEvent.touches.length === touchNumber - 1)\n        )\n    );\n}\n\n/**\n * Emits when a there is a 'mouseup' or the touch ends.\n * @param element, html element where to  listen the events.\n * @param touchNumber number of the touch to track the event, default to the first one.\n */\nfunction ktdMouserOrTouchEnd(element: HTMLElement, touchNumber = 1): Observable<MouseEvent | TouchEvent> {\n    return iif(\n        () => ktdIsMobileOrTablet(),\n        ktdTouchEnd(element, touchNumber),\n        fromEvent<MouseEvent>(element, 'mouseup'),\n    );\n}\n\n\n/**\n * Emits when a 'pointerdown' event occurs (only for the primary pointer). Fallbacks to 'mousemove' or a 'touchmove' if pointer events are not supported.\n * @param element, html element where to listen the events.\n */\nexport function ktdPointerDown(element): Observable<MouseEvent | TouchEvent | PointerEvent> {\n    if (!ktdSupportsPointerEvents()) {\n        return ktdMouseOrTouchDown(element);\n    }\n\n    return fromEvent<PointerEvent>(element, 'pointerdown', activeEventListenerOptions as AddEventListenerOptions).pipe(\n        filter((pointerEvent) => pointerEvent.isPrimary)\n    )\n}\n\n/**\n * Emits when a 'pointermove' event occurs (only for the primary pointer). Fallbacks to 'mousemove' or a 'touchmove' if pointer events are not supported.\n * @param element, html element where to listen the events.\n */\nexport function ktdPointerMove(element): Observable<MouseEvent | TouchEvent | PointerEvent> {\n    if (!ktdSupportsPointerEvents()) {\n        return ktdMouseOrTouchMove(element);\n    }\n    return fromEvent<PointerEvent>(element, 'pointermove', activeEventListenerOptions as AddEventListenerOptions).pipe(\n        filter((pointerEvent) => pointerEvent.isPrimary),\n    );\n}\n\n/**\n * Emits when a 'pointerup' event occurs (only for the primary pointer). Fallbacks to 'mousemove' or a 'touchmove' if pointer events are not supported.\n * @param element, html element where to listen the events.\n */\nexport function ktdPointerUp(element): Observable<MouseEvent | TouchEvent | PointerEvent> {\n    if (!ktdSupportsPointerEvents()) {\n        return ktdMouserOrTouchEnd(element);\n    }\n    return fromEvent<PointerEvent>(element, 'pointerup').pipe(filter(pointerEvent => pointerEvent.isPrimary));\n}\n"]}