@interactjs/pointer-events - npm Package Compare versions

Comparing version 1.4.0-alpha.20 to 1.4.0-alpha.21

base.d.ts

@@ -0,9 +1,32 @@
+import Eventable from '@interactjs/core/Eventable';
+import Interaction from '@interactjs/core/Interaction';
 import { Scope } from '@interactjs/core/scope';
 import * as utils from '@interactjs/utils';
 import PointerEvent from './PointerEvent';
+declare type EventTargetList = Array<{
+    eventable: Eventable;
+    element: Window | Document | Element;
+    props: {
+        [key: string]: any;
+    };
+}>;
 declare module '@interactjs/core/scope' {
     interface Scope {
-        pointerEvents?: typeof pointerEvents;
+        pointerEvents: typeof pointerEvents;
     }
 }
+declare module '@interactjs/core/Interaction' {
+    interface Interaction {
+        prevTap?: PointerEvent<string>;
+        tapTime?: number;
+    }
+}
+declare module '@interactjs/core/PointerInfo' {
+    interface PointerInfo {
+        hold: {
+            duration: number;
+            timeout: any;
+        };
+    }
+}
 declare module '@interactjs/core/defaultOptions' {
@@ -32,17 +55,26 @@ interface Defaults {
 };
-declare function fire(arg: any): any;
-declare function collectEventTargets({ interaction, pointer, event, eventTarget, type }: {
-    interaction: any;
-    pointer: any;
-    event: any;
-    eventTarget: any;
-    type: any;
-}): any[];
+declare function fire<T extends string>(arg: {
+    interaction: Interaction;
+    pointer: Interact.PointerType;
+    event: Interact.PointerEventType;
+    eventTarget: EventTarget;
+    targets?: EventTargetList;
+    pointerEvent?: PointerEvent<T>;
+    type: T;
+}): PointerEvent<string>;
+declare function collectEventTargets<T extends string>({ interaction, pointer, event, eventTarget, type }: {
+    interaction: Interaction;
+    pointer: Interact.PointerType;
+    event: Interact.PointerEventType;
+    eventTarget: EventTarget;
+    type: T;
+}): {
+    eventable: Eventable;
+    element: Element | Window | Document;
+    props: {
+        [key: string]: any;
+    };
+}[];
 declare function install(scope: Scope): void;
-declare function createSignalListener(type: any): ({ interaction, pointer, event, eventTarget }: {
-    interaction: any;
-    pointer: any;
-    event: any;
-    eventTarget: any;
-}) => void;
+declare function createSignalListener(type: string): ({ interaction, pointer, event, eventTarget }: any) => void;
 export default pointerEvents;

base.js

@@ -30,3 +30,4 @@ import * as utils from '@interactjs/utils';
 function fire(arg) {
-    const { interaction, pointer, event, eventTarget, type = arg.pointerEvent.type, targets = collectEventTargets(arg), pointerEvent = new PointerEvent(type, pointer, event, eventTarget, interaction), } = arg;
+    const { interaction, pointer, event, eventTarget, type = arg.pointerEvent.type, targets = collectEventTargets(arg), } = arg;
+    const { pointerEvent = new PointerEvent(type, pointer, event, eventTarget, interaction), } = arg;
     const signalArg = {
@@ -52,5 +53,5 @@ interaction,
         pointerEvent.addOrigin(origin);
-        if (pointerEvent.immediatePropagationStopped
-            || (pointerEvent.propagationStopped
-                && (i + 1) < targets.length && targets[i + 1].element !== pointerEvent.currentTarget)) {
+        if (pointerEvent.immediatePropagationStopped ||
+            (pointerEvent.propagationStopped &&
+                (i + 1) < targets.length && targets[i + 1].element !== pointerEvent.currentTarget)) {
             break;
@@ -65,3 +66,6 @@ }
             ? fire({
-                interaction, pointer, event, eventTarget,
+                interaction,
+                pointer,
+                event,
+                eventTarget,
                 type: 'doubletap',
@@ -79,5 +83,5 @@ })
     // do not fire a tap event if the pointer was moved before being lifted
-    if (type === 'tap' && (interaction.pointerWasMoved
+    if (type === 'tap' && (interaction.pointerWasMoved ||
         // or if the pointerup target is different to the pointerdown target
-        || !(pointerInfo && pointerInfo.downTarget === eventTarget))) {
+        !(pointerInfo && pointerInfo.downTarget === eventTarget))) {
         return [];
@@ -101,3 +105,3 @@ }
     if (type === 'hold') {
-        signalArg.targets = signalArg.targets.filter(target => target.eventable.options.holdDuration === interaction.pointers[pointerIndex].hold.duration);
+        signalArg.targets = signalArg.targets.filter((target) => target.eventable.options.holdDuration === interaction.pointers[pointerIndex].hold.duration);
     }
@@ -110,7 +114,7 @@ return signalArg.targets;
     scope.defaults.pointerEvents = pointerEvents.defaults;
-    interactions.signals.on('new', interaction => {
+    interactions.signals.on('new', (interaction) => {
         interaction.prevTap = null; // the most recent tap event on this interaction
         interaction.tapTime = 0; // time of the most recent tap event
     });
-    interactions.signals.on('update-pointer', function ({ down, pointerInfo }) {
+    interactions.signals.on('update-pointer', ({ down, pointerInfo }) => {
         if (!down && pointerInfo.hold) {
@@ -121,3 +125,3 @@ return;
     });
-    interactions.signals.on('move', function ({ interaction, pointer, event, eventTarget, duplicateMove }) {
+    interactions.signals.on('move', ({ interaction, pointer, event, eventTarget, duplicateMove }) => {
         const pointerIndex = interaction.getPointerIndex(pointer);
@@ -129,3 +133,6 @@ if (!duplicateMove && (!interaction.pointerIsDown || interaction.pointerWasMoved)) {
             fire({
-                interaction, pointer, event, eventTarget,
+                interaction,
+                pointer,
+                event,
+                eventTarget,
                 type: 'move',
@@ -135,3 +142,3 @@ });
     });
-    interactions.signals.on('down', function ({ interaction, pointer, event, eventTarget, pointerIndex }) {
+    interactions.signals.on('down', ({ interaction, pointer, event, eventTarget, pointerIndex }) => {
         const timer = interaction.pointers[pointerIndex].hold;
@@ -164,3 +171,3 @@ const path = utils.dom.getPath(eventTarget);
         timer.duration = minDuration;
-        timer.timeout = setTimeout(function () {
+        timer.timeout = setTimeout(() => {
             fire({
@@ -181,3 +188,3 @@ interaction,
     for (const signalName of ['up', 'cancel']) {
-        interactions.signals.on(signalName, function ({ interaction, pointerIndex }) {
+        interactions.signals.on(signalName, ({ interaction, pointerIndex }) => {
             if (interaction.pointers[pointerIndex].hold) {
@@ -184,0 +191,0 @@ clearTimeout(interaction.pointers[pointerIndex].hold.timeout);

base.ts

@@ -1,11 +0,35 @@
-import { Scope } from '@interactjs/core/scope';
-import * as utils from '@interactjs/utils';
-import PointerEvent from './PointerEvent';
+import Eventable from '@interactjs/core/Eventable'
+import Interaction from '@interactjs/core/Interaction'
+import { Scope } from '@interactjs/core/scope'
+import * as utils from '@interactjs/utils'
+import PointerEvent from './PointerEvent'
 
+type EventTargetList = Array<{
+  eventable: Eventable,
+  element: Window | Document | Element,
+  props: { [key: string]: any },
+}>
+
 declare module '@interactjs/core/scope' {
   interface Scope {
-    pointerEvents?: typeof pointerEvents
+    pointerEvents: typeof pointerEvents
   }
 }
 
+declare module '@interactjs/core/Interaction' {
+  interface Interaction {
+    prevTap?: PointerEvent<string>
+    tapTime?: number
+  }
+}
+
+declare module '@interactjs/core/PointerInfo' {
+  interface PointerInfo {
+    hold: {
+      duration: number
+      timeout: any
+    }
+  }
+}
+
 declare module '@interactjs/core/defaultOptions' {
@@ -17,5 +41,5 @@ interface Defaults {
 
-const signals       = new utils.Signals();
-const simpleSignals = [ 'down', 'up', 'cancel' ];
-const simpleEvents  = [ 'down', 'up', 'cancel' ];
+const signals       = new utils.Signals()
+const simpleSignals = [ 'down', 'up', 'cancel' ]
+const simpleEvents  = [ 'down', 'up', 'cancel' ]
 
@@ -44,11 +68,22 @@ const pointerEvents = {
   ],
-};
+}
 
-function fire (arg) {
+function fire<T extends string> (arg: {
+  interaction: Interaction,
+  pointer: Interact.PointerType,
+  event: Interact.PointerEventType,
+  eventTarget: EventTarget,
+  targets?: EventTargetList,
+  pointerEvent?: PointerEvent<T>,
+  type: T
+}) {
   const {
     interaction, pointer, event, eventTarget,
-    type = arg.pointerEvent.type,
+    type = (arg as any).pointerEvent.type,
     targets = collectEventTargets(arg),
+  } = arg
+
+  const {
     pointerEvent = new PointerEvent(type, pointer, event, eventTarget, interaction),
-  } = arg;
+  } = arg
 
@@ -63,29 +98,29 @@ const signalArg = {
     pointerEvent,
-  };
+  }
 
   for (let i = 0; i < targets.length; i++) {
-    const target = targets[i];
+    const target = targets[i]
 
     for (const prop in target.props || {}) {
-      pointerEvent[prop] = target.props[prop];
+      (pointerEvent as any)[prop] = target.props[prop]
     }
 
-    const origin = utils.getOriginXY(target.eventable, target.element);
+    const origin = utils.getOriginXY(target.eventable, target.element)
 
-    pointerEvent.subtractOrigin(origin);
-    pointerEvent.eventable = target.eventable;
-    pointerEvent.currentTarget = target.element;
+    pointerEvent.subtractOrigin(origin)
+    pointerEvent.eventable = target.eventable
+    pointerEvent.currentTarget = target.element
 
-    target.eventable.fire(pointerEvent);
+    target.eventable.fire(pointerEvent)
 
-    pointerEvent.addOrigin(origin);
+    pointerEvent.addOrigin(origin)
 
-    if (pointerEvent.immediatePropagationStopped
-        || (pointerEvent.propagationStopped
-            && (i + 1) < targets.length && targets[i + 1].element !== pointerEvent.currentTarget)) {
-      break;
+    if (pointerEvent.immediatePropagationStopped ||
+        (pointerEvent.propagationStopped &&
+            (i + 1) < targets.length && targets[i + 1].element !== pointerEvent.currentTarget)) {
+      break
     }
   }
 
-  signals.fire('fired', signalArg);
+  signals.fire('fired', signalArg)
 
@@ -97,26 +132,35 @@ if (type === 'tap') {
       ? fire({
-        interaction, pointer, event, eventTarget,
+        interaction,
+        pointer,
+        event,
+        eventTarget,
         type: 'doubletap',
       })
-      : pointerEvent;
+      : pointerEvent
 
-    interaction.prevTap = prevTap;
-    interaction.tapTime = prevTap.timeStamp;
+    interaction.prevTap = prevTap
+    interaction.tapTime = prevTap.timeStamp
   }
 
-  return pointerEvent;
+  return pointerEvent
 }
 
-function collectEventTargets ({ interaction, pointer, event, eventTarget, type }) {
-  const pointerIndex = interaction.getPointerIndex(pointer);
-  const pointerInfo = interaction.pointers[pointerIndex];
+function collectEventTargets<T extends string> ({ interaction, pointer, event, eventTarget, type }: {
+  interaction: Interaction,
+  pointer: Interact.PointerType,
+  event: Interact.PointerEventType,
+  eventTarget: EventTarget,
+  type: T
+}) {
+  const pointerIndex = interaction.getPointerIndex(pointer)
+  const pointerInfo = interaction.pointers[pointerIndex]
 
   // do not fire a tap event if the pointer was moved before being lifted
-  if (type === 'tap' && (interaction.pointerWasMoved
+  if (type === 'tap' && (interaction.pointerWasMoved ||
       // or if the pointerup target is different to the pointerdown target
-      || !(pointerInfo && pointerInfo.downTarget === eventTarget))) {
-    return [];
+      !(pointerInfo && pointerInfo.downTarget === eventTarget))) {
+    return []
   }
 
-  const path = utils.dom.getPath(eventTarget);
+  const path = utils.dom.getPath(eventTarget)
   const signalArg = {
@@ -129,18 +173,18 @@ interaction,
     path,
-    targets: [],
+    targets: [] as EventTargetList,
     element: null,
-  };
+  }
 
   for (const element of path) {
-    signalArg.element = element;
+    signalArg.element = element
 
-    signals.fire('collect-targets', signalArg);
+    signals.fire('collect-targets', signalArg)
   }
 
   if (type === 'hold') {
-    signalArg.targets = signalArg.targets.filter(target =>
-      target.eventable.options.holdDuration === interaction.pointers[pointerIndex].hold.duration);
+    signalArg.targets = signalArg.targets.filter((target) =>
+      target.eventable.options.holdDuration === interaction.pointers[pointerIndex].hold.duration)
   }
 
-  return signalArg.targets;
+  return signalArg.targets
 }
@@ -151,38 +195,41 @@
     interactions,
-  } = scope;
+  } = scope
 
-  scope.pointerEvents = pointerEvents;
-  scope.defaults.pointerEvents = pointerEvents.defaults;
+  scope.pointerEvents = pointerEvents
+  scope.defaults.pointerEvents = pointerEvents.defaults
 
-  interactions.signals.on('new', interaction => {
-    interaction.prevTap    = null;  // the most recent tap event on this interaction
-    interaction.tapTime    = 0;     // time of the most recent tap event
-  });
+  interactions.signals.on('new', (interaction) => {
+    interaction.prevTap    = null  // the most recent tap event on this interaction
+    interaction.tapTime    = 0     // time of the most recent tap event
+  })
 
-  interactions.signals.on('update-pointer', function ({ down, pointerInfo }) {
+  interactions.signals.on('update-pointer', ({ down, pointerInfo }) => {
     if (!down && pointerInfo.hold) {
-      return;
+      return
     }
 
-    pointerInfo.hold = { duration: Infinity, timeout: null };
-  });
+    pointerInfo.hold = { duration: Infinity, timeout: null }
+  })
 
-  interactions.signals.on('move', function ({ interaction, pointer, event, eventTarget, duplicateMove }) {
-    const pointerIndex = interaction.getPointerIndex(pointer);
+  interactions.signals.on('move', ({ interaction, pointer, event, eventTarget, duplicateMove }) => {
+    const pointerIndex = interaction.getPointerIndex(pointer)
 
     if (!duplicateMove && (!interaction.pointerIsDown || interaction.pointerWasMoved)) {
       if (interaction.pointerIsDown) {
-        clearTimeout(interaction.pointers[pointerIndex].hold.timeout);
+        clearTimeout(interaction.pointers[pointerIndex].hold.timeout)
       }
 
       fire({
-        interaction, pointer, event, eventTarget,
+        interaction,
+        pointer,
+        event,
+        eventTarget,
         type: 'move',
-      });
+      })
     }
-  });
+  })
 
-  interactions.signals.on('down', function ({ interaction, pointer, event, eventTarget, pointerIndex }) {
-    const timer = interaction.pointers[pointerIndex].hold;
-    const path = utils.dom.getPath(eventTarget);
+  interactions.signals.on('down', ({ interaction, pointer, event, eventTarget, pointerIndex }) => {
+    const timer = interaction.pointers[pointerIndex].hold
+    const path = utils.dom.getPath(eventTarget)
     const signalArg = {
@@ -194,27 +241,27 @@ interaction,
       type: 'hold',
-      targets: [],
+      targets: [] as EventTargetList,
       path,
       element: null,
-    };
+    }
 
     for (const element of path) {
-      signalArg.element = element;
+      signalArg.element = element
 
-      signals.fire('collect-targets', signalArg);
+      signals.fire('collect-targets', signalArg)
     }
 
-    if (!signalArg.targets.length) { return; }
+    if (!signalArg.targets.length) { return }
 
-    let minDuration = Infinity;
+    let minDuration = Infinity
 
     for (const target of signalArg.targets) {
-      const holdDuration = target.eventable.options.holdDuration;
+      const holdDuration = target.eventable.options.holdDuration
 
       if (holdDuration < minDuration) {
-        minDuration = holdDuration;
+        minDuration = holdDuration
       }
     }
 
-    timer.duration = minDuration;
-    timer.timeout = setTimeout(function () {
+    timer.duration = minDuration
+    timer.timeout = setTimeout(() => {
       fire({
@@ -226,31 +273,31 @@ interaction,
         type: 'hold',
-      });
-    }, minDuration);
-  });
+      })
+    }, minDuration)
+  })
 
   interactions.signals.on('up', ({ interaction, pointer, event, eventTarget }) => {
     if (!interaction.pointerWasMoved) {
-      fire({ interaction, eventTarget, pointer, event, type: 'tap' });
+      fire({ interaction, eventTarget, pointer, event, type: 'tap' })
     }
-  });
+  })
 
   for (const signalName of ['up', 'cancel']) {
-    interactions.signals.on(signalName, function ({ interaction, pointerIndex }) {
+    interactions.signals.on(signalName, ({ interaction, pointerIndex }) => {
       if (interaction.pointers[pointerIndex].hold) {
-        clearTimeout(interaction.pointers[pointerIndex].hold.timeout);
+        clearTimeout(interaction.pointers[pointerIndex].hold.timeout)
       }
-    });
+    })
   }
 
   for (let i = 0; i < simpleSignals.length; i++) {
-    interactions.signals.on(simpleSignals[i], createSignalListener(simpleEvents[i]));
+    interactions.signals.on(simpleSignals[i], createSignalListener(simpleEvents[i]))
   }
 }
 
-function createSignalListener (type) {
-  return function ({ interaction, pointer, event, eventTarget }) {
-    fire({ interaction, eventTarget, pointer, event, type });
-  };
+function createSignalListener (type: string) {
+  return function ({ interaction, pointer, event, eventTarget }: any) {
+    fire({ interaction, eventTarget, pointer, event, type })
+  }
 }
 
-export default pointerEvents;
+export default pointerEvents

holdRepeat.js

 function install(scope) {
     const { pointerEvents, interactions, } = scope;
     pointerEvents.signals.on('new', onNew);
-    pointerEvents.signals.on('fired', arg => onFired(arg, pointerEvents));
+    pointerEvents.signals.on('fired', (arg) => onFired(arg, pointerEvents));
     for (const signal of ['move', 'up', 'cancel', 'endall']) {
@@ -29,3 +29,3 @@ interactions.signals.on(signal, endHoldRepeat);
     // set a timeout to fire the holdrepeat event
-    interaction.holdIntervalHandle = setTimeout(function () {
+    interaction.holdIntervalHandle = setTimeout(() => {
         pointerEvents.fire({
@@ -32,0 +32,0 @@ interaction,

holdRepeat.ts

@@ -5,33 +5,33 @@ function install (scope) {
     interactions,
-  } = scope;
+  } = scope
 
-  pointerEvents.signals.on('new', onNew);
-  pointerEvents.signals.on('fired', arg => onFired(arg, pointerEvents));
+  pointerEvents.signals.on('new', onNew)
+  pointerEvents.signals.on('fired', (arg) => onFired(arg, pointerEvents))
 
   for (const signal of ['move', 'up', 'cancel', 'endall']) {
-    interactions.signals.on(signal, endHoldRepeat);
+    interactions.signals.on(signal, endHoldRepeat)
   }
 
   // don't repeat by default
-  pointerEvents.defaults.holdRepeatInterval = 0;
-  pointerEvents.types.push('holdrepeat');
+  pointerEvents.defaults.holdRepeatInterval = 0
+  pointerEvents.types.push('holdrepeat')
 }
 
 function onNew ({ pointerEvent }) {
-  if (pointerEvent.type !== 'hold') { return; }
+  if (pointerEvent.type !== 'hold') { return }
 
-  pointerEvent.count = (pointerEvent.count || 0) + 1;
+  pointerEvent.count = (pointerEvent.count || 0) + 1
 }
 
 function onFired ({ interaction, pointerEvent, eventTarget, targets }, pointerEvents) {
-  if (pointerEvent.type !== 'hold' || !targets.length) { return; }
+  if (pointerEvent.type !== 'hold' || !targets.length) { return }
 
   // get the repeat interval from the first eventable
-  const interval = targets[0].eventable.options.holdRepeatInterval;
+  const interval = targets[0].eventable.options.holdRepeatInterval
 
   // don't repeat if the interval is 0 or less
-  if (interval <= 0) { return; }
+  if (interval <= 0) { return }
 
   // set a timeout to fire the holdrepeat event
-  interaction.holdIntervalHandle = setTimeout(function () {
+  interaction.holdIntervalHandle = setTimeout(() => {
     pointerEvents.fire({
@@ -43,4 +43,4 @@ interaction,
       event: pointerEvent,
-    });
-  }, interval);
+    })
+  }, interval)
 }
@@ -52,4 +52,4 @@
   if (interaction.holdIntervalHandle) {
-    clearInterval(interaction.holdIntervalHandle);
-    interaction.holdIntervalHandle = null;
+    clearInterval(interaction.holdIntervalHandle)
+    interaction.holdIntervalHandle = null
   }
@@ -60,2 +60,2 @@ }
   install,
-};
+}

index.d.ts

@@ -5,2 +5,2 @@ import pointerEvents from './base';
 declare function install(scope: any): void;
-export { pointerEvents, holdRepeat, interactableTargets, install, };
+export { pointerEvents, holdRepeat, interactableTargets, install };

index.js

@@ -9,3 +9,3 @@ import pointerEvents from './base';
 }
-export { pointerEvents, holdRepeat, interactableTargets, install, };
+export { pointerEvents, holdRepeat, interactableTargets, install };
 //# sourceMappingURL=index.js.map

index.ts

@@ -1,12 +0,11 @@
-import pointerEvents from './base';
-import holdRepeat from './holdRepeat';
-import interactableTargets from './interactableTargets';
+import pointerEvents from './base'
+import holdRepeat from './holdRepeat'
+import interactableTargets from './interactableTargets'
 
 function install (scope) {
-  pointerEvents.install(scope);
-  holdRepeat.install(scope);
-  interactableTargets.install(scope);
+  pointerEvents.install(scope)
+  holdRepeat.install(scope)
+  interactableTargets.install(scope)
 }
 
-export { pointerEvents, holdRepeat, interactableTargets, install, };
-
+export { pointerEvents, holdRepeat, interactableTargets, install }

interactableTargets.d.ts

 import { Scope } from '@interactjs/core/scope';
+type Interactable = import('@interactjs/core/Interactable').default;
 declare module '@interactjs/core/Interactable' {
     interface Interactable {
         pointerEvents: typeof pointerEventsMethod;
-        __backCompatOption: (string: any, any: any) => any;
+        __backCompatOption: (optionName: string, newValue: any) => any;
     }
 }
 declare function install(scope: Scope): void;
-declare function pointerEventsMethod(options: any): any;
+declare function pointerEventsMethod(this: Interactable, options: any): import("@interactjs/core/Interactable").Interactable;
 declare const _default: {
@@ -11,0 +12,0 @@ install: typeof install;

interactableTargets.js

@@ -6,4 +6,4 @@ import { merge } from '@interactjs/utils/arr';
     const { pointerEvents, actions, Interactable, interactables, } = scope;
-    pointerEvents.signals.on('collect-targets', function ({ targets, element, type, eventTarget }) {
-        scope.interactables.forEachMatch(element, interactable => {
+    pointerEvents.signals.on('collect-targets', ({ targets, element, type, eventTarget }) => {
+        scope.interactables.forEachMatch(element, (interactable) => {
             const eventable = interactable.events;
@@ -23,3 +23,3 @@ const options = eventable.options;
     });
-    interactables.signals.on('new', function ({ interactable }) {
+    interactables.signals.on('new', ({ interactable }) => {
         interactable.events.getRect = function (element) {
@@ -29,3 +29,3 @@ return interactable.getRect(element);
     });
-    interactables.signals.on('set', function ({ interactable, options }) {
+    interactables.signals.on('set', ({ interactable, options }) => {
         extend(interactable.events.options, pointerEvents.defaults);
@@ -32,0 +32,0 @@ extend(interactable.events.options, options.pointerEvents || {});

interactableTargets.ts

@@ -1,5 +0,6 @@
-import { Scope } from '@interactjs/core/scope';
-import { merge } from '@interactjs/utils/arr';
-import extend from '@interactjs/utils/extend';
-import * as is from '@interactjs/utils/is';
+import { Scope } from '@interactjs/core/scope'
+import { merge } from '@interactjs/utils/arr'
+import extend from '@interactjs/utils/extend'
+import * as is from '@interactjs/utils/is'
+type Interactable = import ('@interactjs/core/Interactable').default
 
@@ -9,3 +10,3 @@ declare module '@interactjs/core/Interactable' {
     pointerEvents: typeof pointerEventsMethod
-    __backCompatOption: (string, any) => any
+    __backCompatOption: (optionName: string, newValue: any) => any
   }
@@ -20,8 +21,8 @@ }
     interactables,
-  } = scope;
+  } = scope
 
-  pointerEvents.signals.on('collect-targets', function ({ targets, element, type, eventTarget }) {
-    scope.interactables.forEachMatch(element, interactable => {
-      const eventable = interactable.events;
-      const options = eventable.options;
+  pointerEvents.signals.on('collect-targets', ({ targets, element, type, eventTarget }: any) => {
+    scope.interactables.forEachMatch(element, (interactable: Interactable) => {
+      const eventable = interactable.events
+      const options = eventable.options
 
@@ -33,3 +34,2 @@ if (
         interactable.testIgnoreAllow(options, element, eventTarget)) {
-
         targets.push({
@@ -39,39 +39,39 @@ element,
           props: { interactable },
-        });
+        })
       }
-    });
-  });
+    })
+  })
 
-  interactables.signals.on('new', function ({ interactable }) {
-    interactable.events.getRect = function (element) {
-      return interactable.getRect(element);
-    };
-  });
+  interactables.signals.on('new', ({ interactable }) => {
+    interactable.events.getRect = function (element: Element) {
+      return interactable.getRect(element)
+    }
+  })
 
-  interactables.signals.on('set', function ({ interactable, options }) {
-    extend(interactable.events.options, pointerEvents.defaults);
-    extend(interactable.events.options, options.pointerEvents || {});
-  });
+  interactables.signals.on('set', ({ interactable, options }) => {
+    extend(interactable.events.options, pointerEvents.defaults)
+    extend(interactable.events.options, options.pointerEvents || {})
+  })
 
-  merge(actions.eventTypes, pointerEvents.types);
+  merge(actions.eventTypes, pointerEvents.types)
 
-  Interactable.prototype.pointerEvents = pointerEventsMethod;
+  Interactable.prototype.pointerEvents = pointerEventsMethod
 
-  const __backCompatOption = Interactable.prototype._backCompatOption;
+  const __backCompatOption = Interactable.prototype._backCompatOption
 
   Interactable.prototype._backCompatOption = function (optionName, newValue) {
-    const ret = __backCompatOption.call(this, optionName, newValue);
+    const ret = __backCompatOption.call(this, optionName, newValue)
 
     if (ret === this) {
-      this.events.options[optionName] = newValue;
+      this.events.options[optionName] = newValue
     }
 
-    return ret;
+    return ret
   }
 }
 
-function pointerEventsMethod (options) {
-  extend(this.events.options, options);
+function pointerEventsMethod (this: Interactable, options: any) {
+  extend(this.events.options, options)
 
-  return this;
+  return this
 }
@@ -81,2 +81,2 @@
   install,
-};
+}

package.json

 {
   "name": "@interactjs/pointer-events",
-  "version": "1.4.0-alpha.20+sha.ce0da21",
+  "version": "1.4.0-alpha.21+sha.cdc1d5f",
   "peerDependencies": {
-    "@interactjs/core": "1.4.0-alpha.20+sha.ce0da21",
-    "@interactjs/utils": "1.4.0-alpha.20+sha.ce0da21"
+    "@interactjs/core": "1.4.0-alpha.21+sha.cdc1d5f",
+    "@interactjs/utils": "1.4.0-alpha.21+sha.cdc1d5f"
   },
   "devDependencies": {
-    "@interactjs/_dev": "1.4.0-alpha.20+sha.ce0da21",
-    "@interactjs/core": "1.4.0-alpha.20+sha.ce0da21",
-    "@interactjs/utils": "1.4.0-alpha.20+sha.ce0da21"
+    "@interactjs/_dev": "1.4.0-alpha.21+sha.cdc1d5f",
+    "@interactjs/core": "1.4.0-alpha.21+sha.cdc1d5f",
+    "@interactjs/utils": "1.4.0-alpha.21+sha.cdc1d5f"
   },
@@ -13,0 +13,0 @@ "publishConfig": {

PointerEvent.d.ts

 import Interaction from '@interactjs/core/Interaction';
 /** */
-export default class PointerEvent {
+export default class PointerEvent<T extends string> {
     interaction: Interaction;
     timeStamp: number;
     originalEvent: Interact.PointerEventType;
-    type: string;
+    type: T;
     pointerId: number;
@@ -18,2 +18,3 @@ pointerType: string;
     dt: number;
+    eventable: any;
     propagationStopped: boolean;
@@ -20,0 +21,0 @@ immediatePropagationStopped: boolean;

PointerEvent.js

@@ -24,6 +24,6 @@ import pointerUtils from '@interactjs/utils/pointerUtils';
             const interval = this.timeStamp - interaction.tapTime;
-            this.double = !!(interaction.prevTap
-                && interaction.prevTap.type !== 'doubletap'
-                && interaction.prevTap.target === this.target
-                && interval < 500);
+            this.double = !!(interaction.prevTap &&
+                interaction.prevTap.type !== 'doubletap' &&
+                interaction.prevTap.target === this.target &&
+                interval < 500);
         }
@@ -30,0 +30,0 @@ else if (type === 'doubletap') {

PointerEvent.ts

@@ -1,10 +0,10 @@
-import Interaction from '@interactjs/core/Interaction';
-import pointerUtils from '@interactjs/utils/pointerUtils';
+import Interaction from '@interactjs/core/Interaction'
+import pointerUtils from '@interactjs/utils/pointerUtils'
 
 /** */
-export default class PointerEvent {
+export default class PointerEvent<T extends string> {
   interaction: Interaction
   timeStamp: number
   originalEvent: Interact.PointerEventType
-  type: string
+  type: T
   pointerId: number
@@ -20,2 +20,3 @@ pointerType: string
   dt: number
+  eventable: any
   propagationStopped = false
@@ -26,31 +27,31 @@ immediatePropagationStopped = false
   constructor (type, pointer, event, eventTarget, interaction) {
-    pointerUtils.pointerExtend(this, event);
+    pointerUtils.pointerExtend(this, event)
 
     if (event !== pointer) {
-      pointerUtils.pointerExtend(this, pointer);
+      pointerUtils.pointerExtend(this, pointer)
     }
 
-    this.interaction = interaction;
+    this.interaction = interaction
 
-    this.timeStamp     = new Date().getTime();
-    this.originalEvent = event;
-    this.type          = type;
-    this.pointerId     = pointerUtils.getPointerId(pointer);
-    this.pointerType   = pointerUtils.getPointerType(pointer);
-    this.target        = eventTarget;
-    this.currentTarget = null;
+    this.timeStamp     = new Date().getTime()
+    this.originalEvent = event
+    this.type          = type
+    this.pointerId     = pointerUtils.getPointerId(pointer)
+    this.pointerType   = pointerUtils.getPointerType(pointer)
+    this.target        = eventTarget
+    this.currentTarget = null
 
     if (type === 'tap') {
-      const pointerIndex = interaction.getPointerIndex(pointer);
-      this.dt = this.timeStamp - interaction.pointers[pointerIndex].downTime;
+      const pointerIndex = interaction.getPointerIndex(pointer)
+      this.dt = this.timeStamp - interaction.pointers[pointerIndex].downTime
 
-      const interval = this.timeStamp - interaction.tapTime;
+      const interval = this.timeStamp - interaction.tapTime
 
-      this.double = !!(interaction.prevTap
-        && interaction.prevTap.type !== 'doubletap'
-        && interaction.prevTap.target === this.target
-        && interval < 500);
+      this.double = !!(interaction.prevTap &&
+        interaction.prevTap.type !== 'doubletap' &&
+        interaction.prevTap.target === this.target &&
+        interval < 500)
     }
     else if (type === 'doubletap') {
-      this.dt = pointer.timeStamp - interaction.tapTime;
+      this.dt = pointer.timeStamp - interaction.tapTime
     }
@@ -60,17 +61,17 @@ }
   subtractOrigin ({ x: originX, y: originY }) {
-    this.pageX   -= originX;
-    this.pageY   -= originY;
-    this.clientX -= originX;
-    this.clientY -= originY;
+    this.pageX   -= originX
+    this.pageY   -= originY
+    this.clientX -= originX
+    this.clientY -= originY
 
-    return this;
+    return this
   }
 
   addOrigin ({ x: originX, y: originY }) {
-    this.pageX   += originX;
-    this.pageY   += originY;
-    this.clientX += originX;
-    this.clientY += originY;
+    this.pageX   += originX
+    this.pageY   += originY
+    this.clientX += originX
+    this.clientY += originY
 
-    return this;
+    return this
   }
@@ -82,3 +83,3 @@
   preventDefault () {
-    this.originalEvent.preventDefault();
+    this.originalEvent.preventDefault()
   }
@@ -90,3 +91,3 @@
   stopPropagation () {
-    this.propagationStopped = true;
+    this.propagationStopped = true
   }
@@ -98,4 +99,4 @@
   stopImmediatePropagation () {
-    this.immediatePropagationStopped = this.propagationStopped = true;
+    this.immediatePropagationStopped = this.propagationStopped = true
   }
 }

tests/base.js

@@ -1,12 +0,11 @@
-import test from '@interactjs/_dev/test/test';
-import * as helpers from '@interactjs/core/tests/helpers';
-import interactions from '@interactjs/core/interactions';
+import test from '@interactjs/_dev/test/test'
+import * as helpers from '@interactjs/core/tests/helpers'
+import interactions from '@interactjs/core/interactions'
 
-import Interaction from '@interactjs/core/Interaction';
-import Eventable     from '@interactjs/core/Eventable';
-import Signals from '@interactjs/utils/Signals';
-import pointerEvents from '../base';
+import Interaction from '@interactjs/core/Interaction'
+import Eventable     from '@interactjs/core/Eventable'
+import Signals from '@interactjs/utils/Signals'
+import pointerEvents from '../base'
 
 test('pointerEvents.types', t => {
-
   t.deepEqual(pointerEvents.types,
@@ -22,16 +21,16 @@ [
     ],
-    'pointerEvents.types is as expected');
+    'pointerEvents.types is as expected')
 
-  t.end();
-});
+  t.end()
+})
 
 test('pointerEvents.fire', t => {
-  const eventable = new Eventable(pointerEvents.defaults);
-  const type = 'TEST';
-  const element = {};
-  const eventTarget = {};
-  const TEST_PROP = ['TEST_PROP'];
-  let firedEvent;
+  const eventable = new Eventable(pointerEvents.defaults)
+  const type = 'TEST'
+  const element = {}
+  const eventTarget = {}
+  const TEST_PROP = ['TEST_PROP']
+  let firedEvent
 
-  eventable.on(type, event => firedEvent = event);
+  eventable.on(type, event => { firedEvent = event })
 
@@ -50,25 +49,25 @@ pointerEvents.fire({
       },
-    }]});
+    }] })
 
   t.ok(firedEvent instanceof pointerEvents.PointerEvent,
-    'Fired event is an instance of pointerEvents.PointerEvent');
+    'Fired event is an instance of pointerEvents.PointerEvent')
   t.equal(firedEvent.type, type,
-    'Fired event type is correct');
+    'Fired event type is correct')
   t.equal(firedEvent.currentTarget, element,
-    'Fired event currentTarget is correct');
+    'Fired event currentTarget is correct')
   t.equal(firedEvent.target, eventTarget,
-    'Fired event target is correct');
+    'Fired event target is correct')
   t.equal(firedEvent.TEST_PROP, TEST_PROP,
-    'Fired event has props from target.props');
+    'Fired event has props from target.props')
 
-  const tapTime = 500;
+  const tapTime = 500
   const interaction = Object.assign(
     new Interaction({ signals: new Signals() }),
-    { tapTime: -1, prevTap: null });
+    { tapTime: -1, prevTap: null })
 
-  interaction.updatePointer({}, {});
+  interaction.updatePointer({}, {})
 
   const tapEvent = Object.assign(new pointerEvents.PointerEvent('tap', {}, {}, null, interaction), {
     timeStamp: tapTime,
-  });
+  })
 
@@ -81,28 +80,28 @@ pointerEvents.fire({
       element,
-    }]});
+    }] })
 
   t.equal(interaction.tapTime, tapTime,
-    'interaction.tapTime is updated');
+    'interaction.tapTime is updated')
   t.equal(interaction.prevTap, tapEvent,
-    'interaction.prevTap is updated');
+    'interaction.prevTap is updated')
 
-  t.end();
-});
+  t.end()
+})
 
 test('pointerEvents.collectEventTargets', t => {
-  const type = 'TEST';
-  const TEST_PROP = ['TEST_PROP'];
+  const type = 'TEST'
+  const TEST_PROP = ['TEST_PROP']
   const target = {
     TEST_PROP,
     eventable: new Eventable(pointerEvents.defaults),
-  };
-  let collectedTargets;
+  }
+  let collectedTargets
 
   function onCollect ({ targets }) {
-    targets.push(target);
+    targets.push(target)
 
-    collectedTargets = targets;
+    collectedTargets = targets
   }
 
-  pointerEvents.signals.on('collect-targets', onCollect);
+  pointerEvents.signals.on('collect-targets', onCollect)
   pointerEvents.collectEventTargets({
@@ -114,44 +113,44 @@ interaction: new Interaction({ signals: helpers.mockSignals() }),
     type,
-  });
+  })
 
-  t.deepEqual(collectedTargets, [target]);
+  t.deepEqual(collectedTargets, [target])
 
-  pointerEvents.signals.off('collect-targets', onCollect);
+  pointerEvents.signals.off('collect-targets', onCollect)
 
-  t.end();
-});
+  t.end()
+})
 
 test('pointerEvents Interaction update-pointer signal', t => {
-  const scope = helpers.mockScope();
+  const scope = helpers.mockScope()
 
-  interactions.install(scope);
-  pointerEvents.install(scope);
+  interactions.install(scope)
+  pointerEvents.install(scope)
 
-  const interaction = scope.interactions.new({});
-  const initialHold = { duration: Infinity, timeout: null };
-  const event = {};
+  const interaction = scope.interactions.new({})
+  const initialHold = { duration: Infinity, timeout: null }
+  const event = {}
 
-  interaction.updatePointer(helpers.newPointer(0), event, null, false);
-  t.deepEqual(interaction.pointers.map(p => p.hold), [initialHold], 'set hold info for move on new pointer');
+  interaction.updatePointer(helpers.newPointer(0), event, null, false)
+  t.deepEqual(interaction.pointers.map(p => p.hold), [initialHold], 'set hold info for move on new pointer')
 
-  interaction.removePointer(helpers.newPointer(0), event);
+  interaction.removePointer(helpers.newPointer(0), event)
 
-  interaction.updatePointer(helpers.newPointer(0), event, null, true);
-  t.deepEqual(interaction.pointers.map(p => p.hold), [initialHold]);
+  interaction.updatePointer(helpers.newPointer(0), event, null, true)
+  t.deepEqual(interaction.pointers.map(p => p.hold), [initialHold])
 
-  interaction.updatePointer(helpers.newPointer(5), event, null, true);
-  t.deepEqual(interaction.pointers.map(p => p.hold), [initialHold, initialHold]);
+  interaction.updatePointer(helpers.newPointer(5), event, null, true)
+  t.deepEqual(interaction.pointers.map(p => p.hold), [initialHold, initialHold])
 
-  t.end();
-});
+  t.end()
+})
 
 test('pointerEvents Interaction remove-pointer signal', t => {
-  const scope = helpers.mockScope();
+  const scope = helpers.mockScope()
 
-  interactions.install(scope);
-  pointerEvents.install(scope);
+  interactions.install(scope)
+  pointerEvents.install(scope)
 
-  const interaction = scope.interactions.new({});
+  const interaction = scope.interactions.new({})
 
-  const ids = [0, 1, 2, 3];
+  const ids = [0, 1, 2, 3]
   const removals = [
@@ -162,18 +161,18 @@ { id: 0, remain: [1, 2, 3], message: 'first of 4'  },
     { id: 1, remain: [       ], message: 'final'       },
-  ];
+  ]
 
   for (const id of ids) {
-    const index = interaction.updatePointer({ pointerId: id }, {}, true);
+    const index = interaction.updatePointer({ pointerId: id }, {}, true)
     // use the ids as the pointerInfo.hold value for this test
-    interaction.pointers[index].hold = id;
+    interaction.pointers[index].hold = id
   }
 
   for (const removal of removals) {
-    interaction.removePointer({ pointerId: removal.id });
+    interaction.removePointer({ pointerId: removal.id })
 
     t.deepEqual(interaction.pointers.map(p => p.hold), removal.remain,
-      `${removal.message} - remaining interaction.holdTimers is correct`);
+      `${removal.message} - remaining interaction.holdTimers is correct`)
   }
 
-  t.end();
-});
+  t.end()
+})

tests/holdRepeat.js

@@ -1,7 +0,7 @@
-import test from '@interactjs/_dev/test/test';
-import * as helpers from '@interactjs/core/tests/helpers';
-import Signals from '@interactjs/utils/Signals';
-import Eventable from '@interactjs/core/Eventable';
-import interactions from '@interactjs/core/interactions';
-import holdRepeat from '../holdRepeat';
+import test from '@interactjs/_dev/test/test'
+import * as helpers from '@interactjs/core/tests/helpers'
+import Signals from '@interactjs/utils/Signals'
+import Eventable from '@interactjs/core/Eventable'
+import interactions from '@interactjs/core/interactions'
+import holdRepeat from '../holdRepeat'
 
@@ -16,37 +16,37 @@ function mockScope () {
     },
-  });
+  })
 }
 
 test('holdRepeat count', t => {
-  const scope = mockScope();
+  const scope = mockScope()
   const pointerEvent = {
     type: 'hold',
-  };
+  }
 
-  holdRepeat.install(scope);
+  holdRepeat.install(scope)
 
-  scope.pointerEvents.signals.fire('new', { pointerEvent });
-  t.equal(pointerEvent.count, 1, 'first hold count is 1 with count previously undefined');
+  scope.pointerEvents.signals.fire('new', { pointerEvent })
+  t.equal(pointerEvent.count, 1, 'first hold count is 1 with count previously undefined')
 
-  const count = 20;
-  pointerEvent.count = count;
-  scope.pointerEvents.signals.fire('new', { pointerEvent });
-  t.equal(pointerEvent.count, count + 1, 'existing hold count is incremented');
+  const count = 20
+  pointerEvent.count = count
+  scope.pointerEvents.signals.fire('new', { pointerEvent })
+  t.equal(pointerEvent.count, count + 1, 'existing hold count is incremented')
 
-  t.end();
-});
+  t.end()
+})
 
 test('holdRepeat onFired', t => {
-  const scope = mockScope();
-  interactions.install(scope);
-  holdRepeat.install(scope);
+  const scope = mockScope()
+  interactions.install(scope)
+  holdRepeat.install(scope)
 
-  const interaction = scope.interactions.new({});
+  const interaction = scope.interactions.new({})
   const pointerEvent = {
     type: 'hold',
-  };
-  const eventTarget = {};
+  }
+  const eventTarget = {}
   const eventable = new Eventable(Object.assign({}, scope.pointerEvents.defaults, {
     holdRepeatInterval: 0,
-  }));
+  }))
   const signalArg = {
@@ -59,22 +59,22 @@ interaction,
     }],
-  };
+  }
 
-  scope.pointerEvents.signals.fire('fired', signalArg);
+  scope.pointerEvents.signals.fire('fired', signalArg)
   t.notOk('holdIntervalHandle' in interaction,
-    'interaction interval handle was not saved with 0 holdRepeatInterval');
+    'interaction interval handle was not saved with 0 holdRepeatInterval')
 
-  eventable.options.holdRepeatInterval = 10;
-  scope.pointerEvents.signals.fire('fired', signalArg);
+  eventable.options.holdRepeatInterval = 10
+  scope.pointerEvents.signals.fire('fired', signalArg)
   t.ok('holdIntervalHandle' in interaction,
-    'interaction interval handle was saved with interval > 0');
+    'interaction interval handle was saved with interval > 0')
 
-  clearInterval(interaction.holdIntervalHandle);
+  clearInterval(interaction.holdIntervalHandle)
 
-  pointerEvent.type = 'NOT_HOLD';
-  delete interaction.holdIntervalHandle;
-  scope.pointerEvents.signals.fire('fired', signalArg);
+  pointerEvent.type = 'NOT_HOLD'
+  delete interaction.holdIntervalHandle
+  scope.pointerEvents.signals.fire('fired', signalArg)
   t.notOk('holdIntervalHandle' in interaction,
-    'interaction interval handle is not saved if pointerEvent.type is not "hold"');
+    'interaction interval handle is not saved if pointerEvent.type is not "hold"')
 
-  t.end();
-});
+  t.end()
+})

tests/PointerEvent.js

@@ -1,14 +0,13 @@
-import test from '@interactjs/_dev/test/test';
-import * as helpers from '@interactjs/core/tests/helpers';
+import test from '@interactjs/_dev/test/test'
+import * as helpers from '@interactjs/core/tests/helpers'
 
-import pointerUtils from '@interactjs/utils/pointerUtils';
-import Interaction from '@interactjs/core/Interaction';
-import Signals from '@interactjs/utils/Signals';
-import PointerEvent from '../PointerEvent';
+import pointerUtils from '@interactjs/utils/pointerUtils'
+import Interaction from '@interactjs/core/Interaction'
+import Signals from '@interactjs/utils/Signals'
+import PointerEvent from '../PointerEvent'
 
-
 test('PointerEvent constructor', t => {
-  const type = 'TEST_EVENT';
-  const pointerId = -100;
-  const testPointerProp = ['TEST_POINTER_PROP'];
+  const type = 'TEST_EVENT'
+  const pointerId = -100
+  const testPointerProp = ['TEST_POINTER_PROP']
   const pointer = {
@@ -18,76 +17,76 @@ pointerId,
     pointerType: 'TEST_POINTER_TYPE',
-  };
-  const testEventProp = ['TEST_EVENT_PROP'];
+  }
+  const testEventProp = ['TEST_EVENT_PROP']
   const event = {
     testEventProp,
-  };
-  const interaction = new Interaction({ signals: new Signals() });
-  const eventTarget = {};
-  const pointerEvent = new PointerEvent(type, pointer, event, eventTarget, interaction);
+  }
+  const interaction = new Interaction({ signals: new Signals() })
+  const eventTarget = {}
+  const pointerEvent = new PointerEvent(type, pointer, event, eventTarget, interaction)
 
   t.equal(pointerEvent.testPointerProp, testPointerProp,
-    'pointerEvent is extended form pointer');
+    'pointerEvent is extended form pointer')
   t.equal(pointerEvent.testEventProp, testEventProp,
-    'pointerEvent is extended form Event');
+    'pointerEvent is extended form Event')
 
   t.equal(pointerEvent.type, type,
-    'type is set correctly');
+    'type is set correctly')
   t.equal(pointerEvent.pointerType, pointerUtils.getPointerType(pointer),
-    'pointerType is set correctly');
+    'pointerType is set correctly')
   t.equal(pointerEvent.pointerId, pointerId,
-    'pointerId is set correctly');
+    'pointerId is set correctly')
   t.equal(pointerEvent.originalEvent, event,
-    'originalEvent is set correctly');
+    'originalEvent is set correctly')
   t.equal(pointerEvent.interaction, interaction,
-    'interaction is set correctly');
+    'interaction is set correctly')
   t.equal(pointerEvent.target, eventTarget,
-    'target is set correctly');
+    'target is set correctly')
   t.equal(pointerEvent.currentTarget, null,
-    'currentTarget is null');
+    'currentTarget is null')
 
-  t.end();
-});
+  t.end()
+})
 
 test('PointerEvent methods', t => {
-  const methodContexts = {};
+  const methodContexts = {}
   const event = ['preventDefault', 'stopPropagation', 'stopImmediatePropagation']
     .reduce((acc, methodName) => {
-      acc[methodName] = function () { methodContexts[methodName] = this; };
-      return acc;
-    }, helpers.newPointer());
-  const pointerEvent = new PointerEvent('TEST', {}, event, null, {});
+      acc[methodName] = function () { methodContexts[methodName] = this }
+      return acc
+    }, helpers.newPointer())
+  const pointerEvent = new PointerEvent('TEST', {}, event, null, {})
 
-  pointerEvent.preventDefault();
+  pointerEvent.preventDefault()
   t.equal(methodContexts.preventDefault, event,
-    'PointerEvent.preventDefault() calls preventDefault of originalEvent');
+    'PointerEvent.preventDefault() calls preventDefault of originalEvent')
 
   t.notOk(pointerEvent.propagationStopped,
-    'propagationStopped is false before call to stopPropagation');
-  pointerEvent.stopPropagation();
+    'propagationStopped is false before call to stopPropagation')
+  pointerEvent.stopPropagation()
   t.ok(pointerEvent.propagationStopped,
-    'stopPropagation sets propagationStopped to true');
+    'stopPropagation sets propagationStopped to true')
   t.equal(methodContexts.stopPropagation, undefined,
-    'PointerEvent.stopPropagation() does not call stopPropagation of originalEvent');
+    'PointerEvent.stopPropagation() does not call stopPropagation of originalEvent')
 
   t.notOk(pointerEvent.immediatePropagationStopped,
-    'immediatePropagationStopped is false before call to stopImmediatePropagation');
-  pointerEvent.stopImmediatePropagation();
+    'immediatePropagationStopped is false before call to stopImmediatePropagation')
+  pointerEvent.stopImmediatePropagation()
   t.equal(methodContexts.stopImmediatePropagation, undefined,
-    'PointerEvent.stopImmediatePropagation() does not call stopImmediatePropagation of originalEvent');
+    'PointerEvent.stopImmediatePropagation() does not call stopImmediatePropagation of originalEvent')
   t.ok(pointerEvent.immediatePropagationStopped,
-    'stopImmediatePropagation sets immediatePropagationStopped to true');
+    'stopImmediatePropagation sets immediatePropagationStopped to true')
 
-  const origin = { x: 20, y: 30 };
-  pointerEvent.subtractOrigin(origin);
+  const origin = { x: 20, y: 30 }
+  pointerEvent.subtractOrigin(origin)
 
-  t.equal(pointerEvent.pageX,   event.pageX   - origin.x, 'subtractOrigin updates pageX correctly');
-  t.equal(pointerEvent.pageY,   event.pageY   - origin.y, 'subtractOrigin updates pageY correctly');
-  t.equal(pointerEvent.clientX, event.clientX - origin.x, 'subtractOrigin updates clientX correctly');
-  t.equal(pointerEvent.clientY, event.clientY - origin.y, 'subtractOrigin updates clientY correctly');
+  t.equal(pointerEvent.pageX,   event.pageX   - origin.x, 'subtractOrigin updates pageX correctly')
+  t.equal(pointerEvent.pageY,   event.pageY   - origin.y, 'subtractOrigin updates pageY correctly')
+  t.equal(pointerEvent.clientX, event.clientX - origin.x, 'subtractOrigin updates clientX correctly')
+  t.equal(pointerEvent.clientY, event.clientY - origin.y, 'subtractOrigin updates clientY correctly')
 
-  pointerEvent.addOrigin(origin);
+  pointerEvent.addOrigin(origin)
   t.ok(['pageX', 'pageY', 'clientX', 'clientY'].reduce((allEqual, prop) => allEqual && pointerEvent[prop] === event[prop], true),
-    'addOrigin with the subtracted origin reverts to original coordinates');
+    'addOrigin with the subtracted origin reverts to original coordinates')
 
-  t.end();
-});
+  t.end()
+})

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Manifest confusion

Supply chain risk

This package has inconsistent metadata. This could be malicious or caused by an error when publishing the package.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Manifest confusion

Supply chain risk

This package has inconsistent metadata. This could be malicious or caused by an error when publishing the package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

55247

increased by4.08%

Lines of code

1234

increased by7.21%

Worsened metrics

Number of package files

25

decreased by-3.85%

No dependency changes