@interactjs/pointer-events - npm Package Compare versions

Comparing version 1.6.3 to 1.7.0

base.d.ts

@@ -1,6 +0,5 @@
-import { PerActionDefaults } from '@interactjs/core/defaultOptions';
-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 { PerActionDefaults } from '../core/defaultOptions';
+import Eventable from '../core/Eventable';
+import Interaction from '../core/Interaction';
+import { Scope } from '../core/scope';
 import PointerEvent from './PointerEvent';
@@ -45,10 +44,42 @@ export declare type EventTargetList = Array<{
 }
+declare module '@interactjs/core/scope' {
+    interface SignalArgs {
+        'pointerEvents:new': {
+            pointerEvent: PointerEvent<any>;
+        };
+        'pointerEvents:fired': {
+            interaction: Interaction;
+            pointer: Interact.PointerType | PointerEvent<any>;
+            event: Interact.PointerEventType | PointerEvent<any>;
+            eventTarget: Interact.EventTarget;
+            pointerEvent: PointerEvent<any>;
+            targets?: EventTargetList;
+            type: string;
+        };
+        'pointerEvents:collect-targets': {
+            interaction: Interaction;
+            pointer: Interact.PointerType | PointerEvent<any>;
+            event: Interact.PointerEventType | PointerEvent<any>;
+            eventTarget: Interact.EventTarget;
+            targets?: EventTargetList;
+            type: string;
+            path: Node[];
+            node: null;
+        };
+    }
+}
 declare const pointerEvents: {
     id: string;
     install: typeof install;
-    signals: utils.Signals;
+    listeners: {
+        'interactions:new': typeof addInteractionProps;
+        'interactions:update-pointer': typeof addHoldInfo;
+        'interactions:move': typeof moveAndClearHold;
+        'interactions:down': (arg: any, scope: any) => void;
+        'interactions:up': (arg: any, scope: any) => void;
+        'interactions:cancel': (arg: any, scope: any) => void;
+    };
     PointerEvent: typeof PointerEvent;
     fire: typeof fire;
     collectEventTargets: typeof collectEventTargets;
-    createSignalListener: typeof createSignalListener;
     defaults: PointerEventOptions;
@@ -58,25 +89,22 @@ types: string[];
 declare function fire<T extends string>(arg: {
+    pointer: Interact.PointerType | PointerEvent<any>;
+    event: Interact.PointerEventType | PointerEvent<any>;
+    eventTarget: Interact.EventTarget;
     interaction: Interaction;
-    pointer: Interact.PointerType;
-    event: Interact.PointerEventType;
-    eventTarget: Interact.EventTarget;
+    type: T;
     targets?: EventTargetList;
-    pointerEvent?: PointerEvent<T>;
-    type: T;
-}, scope: Interact.Scope): PointerEvent<any>;
+}, scope: Interact.Scope): PointerEvent<T>;
 declare function collectEventTargets<T extends string>({ interaction, pointer, event, eventTarget, type }: {
     interaction: Interaction;
-    pointer: Interact.PointerType;
-    event: Interact.PointerEventType;
+    pointer: Interact.PointerType | PointerEvent<any>;
+    event: Interact.PointerEventType | PointerEvent<any>;
     eventTarget: Interact.EventTarget;
     type: T;
-}): {
-    node: Node;
-    eventable: Eventable;
-    props: {
-        [key: string]: any;
-    };
-}[];
+}, scope: Interact.Scope): EventTargetList;
+declare function addInteractionProps({ interaction }: {
+    interaction: any;
+}): void;
+declare function addHoldInfo({ down, pointerInfo }: Interact.SignalArgs['interactions:update-pointer']): void;
+declare function moveAndClearHold({ interaction, pointer, event, eventTarget, duplicate }: Interact.SignalArgs['interactions:move'], scope: Interact.Scope): void;
 declare function install(scope: Scope): void;
-declare function createSignalListener(type: string, scope: any): ({ interaction, pointer, event, eventTarget }: any) => void;
 export default pointerEvents;

base.js

@@ -1,196 +0,274 @@
-import * as utils from '@interactjs/utils';
-import PointerEvent from './PointerEvent';
-const signals = new utils.Signals();
-const simpleSignals = ['down', 'up', 'cancel'];
-const simpleEvents = ['down', 'up', 'cancel'];
+import Interaction from "../core/Interaction.js";
+import { Scope } from "../core/scope.js";
+import * as utils from "../utils/index.js";
+import PointerEvent from "./PointerEvent.js";
 const defaults = {
-    holdDuration: 600,
-    ignoreFrom: null,
-    allowFrom: null,
-    origin: { x: 0, y: 0 },
+  holdDuration: 600,
+  ignoreFrom: null,
+  allowFrom: null,
+  origin: {
+    x: 0,
+    y: 0
+  }
 };
 const pointerEvents = {
-    id: 'pointer-events/base',
-    install,
-    signals,
-    PointerEvent,
-    fire,
-    collectEventTargets,
-    createSignalListener,
-    defaults,
-    types: [
-        'down',
-        'move',
-        'up',
-        'cancel',
-        'tap',
-        'doubletap',
-        'hold',
-    ],
+  id: 'pointer-events/base',
+  install,
+  listeners: {
+    'interactions:new': addInteractionProps,
+    'interactions:update-pointer': addHoldInfo,
+    'interactions:move': moveAndClearHold,
+    'interactions:down': (arg, scope) => {
+      downAndStartHold(arg, scope);
+      fire(arg, scope);
+    },
+    'interactions:up': (arg, scope) => {
+      clearHold(arg);
+      fire(arg, scope);
+      tapAfterUp(arg, scope);
+    },
+    'interactions:cancel': (arg, scope) => {
+      clearHold(arg);
+      fire(arg, scope);
+    }
+  },
+  PointerEvent,
+  fire,
+  collectEventTargets,
+  defaults,
+  types: ['down', 'move', 'up', 'cancel', 'tap', 'doubletap', 'hold']
 };
+
 function fire(arg, scope) {
-    const { interaction, pointer, event, eventTarget, type = arg.pointerEvent.type, targets = collectEventTargets(arg), } = arg;
-    const { pointerEvent = new PointerEvent(type, pointer, event, eventTarget, interaction, scope.now()), } = arg;
-    const signalArg = {
-        interaction,
-        pointer,
-        event,
-        eventTarget,
-        targets,
-        type,
-        pointerEvent,
-    };
-    for (let i = 0; i < targets.length; i++) {
-        const target = targets[i];
-        for (const prop in target.props || {}) {
-            pointerEvent[prop] = target.props[prop];
-        }
-        const origin = utils.getOriginXY(target.eventable, target.node);
-        pointerEvent._subtractOrigin(origin);
-        pointerEvent.eventable = target.eventable;
-        pointerEvent.currentTarget = target.node;
-        target.eventable.fire(pointerEvent);
-        pointerEvent._addOrigin(origin);
-        if (pointerEvent.immediatePropagationStopped ||
-            (pointerEvent.propagationStopped &&
-                (i + 1) < targets.length && targets[i + 1].node !== pointerEvent.currentTarget)) {
-            break;
-        }
+  const {
+    interaction,
+    pointer,
+    event,
+    eventTarget,
+    type,
+    targets = collectEventTargets(arg, scope)
+  } = arg;
+  const pointerEvent = new PointerEvent(type, pointer, event, eventTarget, interaction, scope.now());
+  scope.fire('pointerEvents:new', {
+    pointerEvent
+  });
+  const signalArg = {
+    interaction,
+    pointer,
+    event,
+    eventTarget,
+    targets,
+    type,
+    pointerEvent
+  };
+
+  for (let i = 0; i < targets.length; i++) {
+    const target = targets[i];
+
+    for (const prop in target.props || {}) {
+      pointerEvent[prop] = target.props[prop];
     }
-    signals.fire('fired', signalArg);
-    if (type === 'tap') {
-        // if pointerEvent should make a double tap, create and fire a doubletap
-        // PointerEvent and use that as the prevTap
-        const prevTap = pointerEvent.double
-            ? fire({
-                interaction,
-                pointer,
-                event,
-                eventTarget,
-                type: 'doubletap',
-            }, scope)
-            : pointerEvent;
-        interaction.prevTap = prevTap;
-        interaction.tapTime = prevTap.timeStamp;
+
+    const origin = utils.getOriginXY(target.eventable, target.node);
+
+    pointerEvent._subtractOrigin(origin);
+
+    pointerEvent.eventable = target.eventable;
+    pointerEvent.currentTarget = target.node;
+    target.eventable.fire(pointerEvent);
+
+    pointerEvent._addOrigin(origin);
+
+    if (pointerEvent.immediatePropagationStopped || pointerEvent.propagationStopped && i + 1 < targets.length && targets[i + 1].node !== pointerEvent.currentTarget) {
+      break;
     }
-    return pointerEvent;
+  }
+
+  scope.fire('pointerEvents:fired', signalArg);
+
+  if (type === 'tap') {
+    // if pointerEvent should make a double tap, create and fire a doubletap
+    // PointerEvent and use that as the prevTap
+    const prevTap = pointerEvent.double ? fire({
+      interaction,
+      pointer,
+      event,
+      eventTarget,
+      type: 'doubletap'
+    }, scope) : pointerEvent;
+    interaction.prevTap = prevTap;
+    interaction.tapTime = prevTap.timeStamp;
+  }
+
+  return pointerEvent;
 }
-function collectEventTargets({ interaction, pointer, event, eventTarget, type }) {
-    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 ||
-        // or if the pointerup target is different to the pointerdown target
-        !(pointerInfo && pointerInfo.downTarget === eventTarget))) {
-        return [];
+
+function collectEventTargets({
+  interaction,
+  pointer,
+  event,
+  eventTarget,
+  type
+}, scope) {
+  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 || // or if the pointerup target is different to the pointerdown target
+  !(pointerInfo && pointerInfo.downTarget === eventTarget))) {
+    return [];
+  }
+
+  const path = utils.dom.getPath(eventTarget);
+  const signalArg = {
+    interaction,
+    pointer,
+    event,
+    eventTarget,
+    type,
+    path,
+    targets: [],
+    node: null
+  };
+
+  for (const node of path) {
+    signalArg.node = node;
+    scope.fire('pointerEvents:collect-targets', signalArg);
+  }
+
+  if (type === 'hold') {
+    signalArg.targets = signalArg.targets.filter(target => target.eventable.options.holdDuration === interaction.pointers[pointerIndex].hold.duration);
+  }
+
+  return signalArg.targets;
+}
+
+function addInteractionProps({
+  interaction
+}) {
+  interaction.prevTap = null; // the most recent tap event on this interaction
+
+  interaction.tapTime = 0; // time of the most recent tap event
+}
+
+function addHoldInfo({
+  down,
+  pointerInfo
+}) {
+  if (!down && pointerInfo.hold) {
+    return;
+  }
+
+  pointerInfo.hold = {
+    duration: Infinity,
+    timeout: null
+  };
+}
+
+function clearHold({
+  interaction,
+  pointerIndex
+}) {
+  if (interaction.pointers[pointerIndex].hold) {
+    clearTimeout(interaction.pointers[pointerIndex].hold.timeout);
+  }
+}
+
+function moveAndClearHold({
+  interaction,
+  pointer,
+  event,
+  eventTarget,
+  duplicate
+}, scope) {
+  const pointerIndex = interaction.getPointerIndex(pointer);
+
+  if (!duplicate && (!interaction.pointerIsDown || interaction.pointerWasMoved)) {
+    if (interaction.pointerIsDown) {
+      clearTimeout(interaction.pointers[pointerIndex].hold.timeout);
     }
-    const path = utils.dom.getPath(eventTarget);
-    const signalArg = {
-        interaction,
-        pointer,
-        event,
-        eventTarget,
-        type,
-        path,
-        targets: [],
-        node: null,
-    };
-    for (const node of path) {
-        signalArg.node = node;
-        signals.fire('collect-targets', signalArg);
+
+    fire({
+      interaction,
+      pointer,
+      event,
+      eventTarget: eventTarget,
+      type: 'move'
+    }, scope);
+  }
+}
+
+function downAndStartHold({
+  interaction,
+  pointer,
+  event,
+  eventTarget,
+  pointerIndex
+}, scope) {
+  const timer = interaction.pointers[pointerIndex].hold;
+  const path = utils.dom.getPath(eventTarget);
+  const signalArg = {
+    interaction,
+    pointer,
+    event,
+    eventTarget,
+    type: 'hold',
+    targets: [],
+    path,
+    node: null
+  };
+
+  for (const node of path) {
+    signalArg.node = node;
+    scope.fire('pointerEvents:collect-targets', signalArg);
+  }
+
+  if (!signalArg.targets.length) {
+    return;
+  }
+
+  let minDuration = Infinity;
+
+  for (const target of signalArg.targets) {
+    const holdDuration = target.eventable.options.holdDuration;
+
+    if (holdDuration < minDuration) {
+      minDuration = holdDuration;
     }
-    if (type === 'hold') {
-        signalArg.targets = signalArg.targets.filter(target => target.eventable.options.holdDuration === interaction.pointers[pointerIndex].hold.duration);
-    }
-    return signalArg.targets;
+  }
+
+  timer.duration = minDuration;
+  timer.timeout = setTimeout(() => {
+    fire({
+      interaction,
+      eventTarget,
+      pointer,
+      event,
+      type: 'hold'
+    }, scope);
+  }, minDuration);
 }
+
+function tapAfterUp({
+  interaction,
+  pointer,
+  event,
+  eventTarget
+}, scope) {
+  if (!interaction.pointerWasMoved) {
+    fire({
+      interaction,
+      eventTarget,
+      pointer,
+      event,
+      type: 'tap'
+    }, scope);
+  }
+}
+
 function install(scope) {
-    const { interactions, } = scope;
-    scope.pointerEvents = pointerEvents;
-    scope.defaults.actions.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('update-pointer', ({ down, pointerInfo }) => {
-        if (!down && pointerInfo.hold) {
-            return;
-        }
-        pointerInfo.hold = { duration: Infinity, timeout: null };
-    });
-    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);
-            }
-            fire({
-                interaction,
-                pointer,
-                event,
-                eventTarget,
-                type: 'move',
-            }, scope);
-        }
-    });
-    interactions.signals.on('down', ({ interaction, pointer, event, eventTarget, pointerIndex }) => {
-        const timer = interaction.pointers[pointerIndex].hold;
-        const path = utils.dom.getPath(eventTarget);
-        const signalArg = {
-            interaction,
-            pointer,
-            event,
-            eventTarget,
-            type: 'hold',
-            targets: [],
-            path,
-            node: null,
-        };
-        for (const node of path) {
-            signalArg.node = node;
-            signals.fire('collect-targets', signalArg);
-        }
-        if (!signalArg.targets.length) {
-            return;
-        }
-        let minDuration = Infinity;
-        for (const target of signalArg.targets) {
-            const holdDuration = target.eventable.options.holdDuration;
-            if (holdDuration < minDuration) {
-                minDuration = holdDuration;
-            }
-        }
-        timer.duration = minDuration;
-        timer.timeout = setTimeout(() => {
-            fire({
-                interaction,
-                eventTarget,
-                pointer,
-                event,
-                type: 'hold',
-            }, scope);
-        }, minDuration);
-    });
-    for (const signalName of ['up', 'cancel']) {
-        interactions.signals.on(signalName, ({ interaction, pointerIndex }) => {
-            if (interaction.pointers[pointerIndex].hold) {
-                clearTimeout(interaction.pointers[pointerIndex].hold.timeout);
-            }
-        });
-    }
-    for (let i = 0; i < simpleSignals.length; i++) {
-        interactions.signals.on(simpleSignals[i], createSignalListener(simpleEvents[i], scope));
-    }
-    interactions.signals.on('up', ({ interaction, pointer, event, eventTarget }) => {
-        if (!interaction.pointerWasMoved) {
-            fire({ interaction, eventTarget, pointer, event, type: 'tap' }, scope);
-        }
-    });
+  scope.pointerEvents = pointerEvents;
+  scope.defaults.actions.pointerEvents = pointerEvents.defaults;
 }
-function createSignalListener(type, scope) {
-    return function ({ interaction, pointer, event, eventTarget }) {
-        fire({ interaction, eventTarget, pointer, event, type }, scope);
-    };
-}
+
 export default pointerEvents;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["base.ts"],"names":[],"mappings":"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","sourcesContent":["import { PerActionDefaults } from '@interactjs/core/defaultOptions'\nimport Eventable from '@interactjs/core/Eventable'\nimport Interaction from '@interactjs/core/Interaction'\nimport { Scope } from '@interactjs/core/scope'\nimport * as utils from '@interactjs/utils'\nimport PointerEvent from './PointerEvent'\n\nexport type EventTargetList = Array<{\n  node: Node\n  eventable: Eventable\n  props: { [key: string]: any }\n}>\n\nexport interface PointerEventOptions extends PerActionDefaults {\n  enabled?: undefined // not used\n  holdDuration?: number\n  ignoreFrom?: any\n  allowFrom?: any\n  origin?: Interact.Point | string | Interact.Element\n}\n\ndeclare module '@interactjs/core/scope' {\n  interface Scope {\n    pointerEvents: typeof pointerEvents\n  }\n}\n\ndeclare module '@interactjs/core/Interaction' {\n  interface Interaction {\n    prevTap?: PointerEvent<string>\n    tapTime?: number\n  }\n}\n\ndeclare module '@interactjs/core/PointerInfo' {\n  interface PointerInfo {\n    hold?: {\n      duration: number\n      timeout: any\n    }\n  }\n}\n\ndeclare module '@interactjs/core/defaultOptions' {\n  interface ActionDefaults {\n    pointerEvents: Interact.Options\n  }\n}\n\nconst signals       = new utils.Signals()\nconst simpleSignals = ['down', 'up', 'cancel']\nconst simpleEvents  = ['down', 'up', 'cancel']\n\nconst defaults: PointerEventOptions = {\n  holdDuration: 600,\n  ignoreFrom  : null,\n  allowFrom   : null,\n  origin      : { x: 0, y: 0 },\n}\n\nconst pointerEvents = {\n  id: 'pointer-events/base',\n  install,\n  signals,\n  PointerEvent,\n  fire,\n  collectEventTargets,\n  createSignalListener,\n  defaults,\n  types: [\n    'down',\n    'move',\n    'up',\n    'cancel',\n    'tap',\n    'doubletap',\n    'hold',\n  ],\n}\n\nfunction fire<T extends string> (arg: {\n  interaction: Interaction\n  pointer: Interact.PointerType\n  event: Interact.PointerEventType\n  eventTarget: Interact.EventTarget\n  targets?: EventTargetList\n  pointerEvent?: PointerEvent<T>\n  type: T\n}, scope: Interact.Scope) {\n  const {\n    interaction, pointer, event, eventTarget,\n    type = (arg as any).pointerEvent.type,\n    targets = collectEventTargets(arg),\n  } = arg\n\n  const {\n    pointerEvent = new PointerEvent(type, pointer, event, eventTarget, interaction, scope.now()),\n  } = arg\n\n  const signalArg = {\n    interaction,\n    pointer,\n    event,\n    eventTarget,\n    targets,\n    type,\n    pointerEvent,\n  }\n\n  for (let i = 0; i < targets.length; i++) {\n    const target = targets[i]\n\n    for (const prop in target.props || {}) {\n      (pointerEvent as any)[prop] = target.props[prop]\n    }\n\n    const origin = utils.getOriginXY(target.eventable, target.node)\n\n    pointerEvent._subtractOrigin(origin)\n    pointerEvent.eventable = target.eventable\n    pointerEvent.currentTarget = target.node\n\n    target.eventable.fire(pointerEvent)\n\n    pointerEvent._addOrigin(origin)\n\n    if (pointerEvent.immediatePropagationStopped ||\n        (pointerEvent.propagationStopped &&\n            (i + 1) < targets.length && targets[i + 1].node !== pointerEvent.currentTarget)) {\n      break\n    }\n  }\n\n  signals.fire('fired', signalArg)\n\n  if (type === 'tap') {\n    // if pointerEvent should make a double tap, create and fire a doubletap\n    // PointerEvent and use that as the prevTap\n    const prevTap = pointerEvent.double\n      ? fire({\n        interaction,\n        pointer,\n        event,\n        eventTarget,\n        type: 'doubletap',\n      }, scope)\n      : pointerEvent\n\n    interaction.prevTap = prevTap\n    interaction.tapTime = prevTap.timeStamp\n  }\n\n  return pointerEvent\n}\n\nfunction collectEventTargets<T extends string> ({ interaction, pointer, event, eventTarget, type }: {\n  interaction: Interaction\n  pointer: Interact.PointerType\n  event: Interact.PointerEventType\n  eventTarget: Interact.EventTarget\n  type: T\n}) {\n  const pointerIndex = interaction.getPointerIndex(pointer)\n  const pointerInfo = interaction.pointers[pointerIndex]\n\n  // do not fire a tap event if the pointer was moved before being lifted\n  if (type === 'tap' && (interaction.pointerWasMoved ||\n      // or if the pointerup target is different to the pointerdown target\n      !(pointerInfo && pointerInfo.downTarget === eventTarget))) {\n    return []\n  }\n\n  const path = utils.dom.getPath(eventTarget)\n  const signalArg = {\n    interaction,\n    pointer,\n    event,\n    eventTarget,\n    type,\n    path,\n    targets: [] as EventTargetList,\n    node: null,\n  }\n\n  for (const node of path) {\n    signalArg.node = node\n\n    signals.fire('collect-targets', signalArg)\n  }\n\n  if (type === 'hold') {\n    signalArg.targets = signalArg.targets.filter(target =>\n      target.eventable.options.holdDuration === interaction.pointers[pointerIndex].hold.duration)\n  }\n\n  return signalArg.targets\n}\n\nfunction install (scope: Scope) {\n  const {\n    interactions,\n  } = scope\n\n  scope.pointerEvents = pointerEvents\n  scope.defaults.actions.pointerEvents = pointerEvents.defaults\n\n  interactions.signals.on('new', ({ interaction }) => {\n    interaction.prevTap    = null  // the most recent tap event on this interaction\n    interaction.tapTime    = 0     // time of the most recent tap event\n  })\n\n  interactions.signals.on('update-pointer', ({ down, pointerInfo }) => {\n    if (!down && pointerInfo.hold) {\n      return\n    }\n\n    pointerInfo.hold = { duration: Infinity, timeout: null }\n  })\n\n  interactions.signals.on('move', ({ interaction, pointer, event, eventTarget, duplicateMove }) => {\n    const pointerIndex = interaction.getPointerIndex(pointer)\n\n    if (!duplicateMove && (!interaction.pointerIsDown || interaction.pointerWasMoved)) {\n      if (interaction.pointerIsDown) {\n        clearTimeout(interaction.pointers[pointerIndex].hold.timeout)\n      }\n\n      fire({\n        interaction,\n        pointer,\n        event,\n        eventTarget,\n        type: 'move',\n      }, scope)\n    }\n  })\n\n  interactions.signals.on('down', ({ interaction, pointer, event, eventTarget, pointerIndex }) => {\n    const timer = interaction.pointers[pointerIndex].hold\n    const path = utils.dom.getPath(eventTarget)\n    const signalArg = {\n      interaction,\n      pointer,\n      event,\n      eventTarget,\n      type: 'hold',\n      targets: [] as EventTargetList,\n      path,\n      node: null,\n    }\n\n    for (const node of path) {\n      signalArg.node = node\n\n      signals.fire('collect-targets', signalArg)\n    }\n\n    if (!signalArg.targets.length) { return }\n\n    let minDuration = Infinity\n\n    for (const target of signalArg.targets) {\n      const holdDuration = target.eventable.options.holdDuration\n\n      if (holdDuration < minDuration) {\n        minDuration = holdDuration\n      }\n    }\n\n    timer.duration = minDuration\n    timer.timeout = setTimeout(() => {\n      fire({\n        interaction,\n        eventTarget,\n        pointer,\n        event,\n        type: 'hold',\n      }, scope)\n    }, minDuration)\n  })\n\n  for (const signalName of ['up', 'cancel']) {\n    interactions.signals.on(signalName, ({ interaction, pointerIndex }) => {\n      if (interaction.pointers[pointerIndex].hold) {\n        clearTimeout(interaction.pointers[pointerIndex].hold.timeout)\n      }\n    })\n  }\n\n  for (let i = 0; i < simpleSignals.length; i++) {\n    interactions.signals.on(simpleSignals[i], createSignalListener(simpleEvents[i], scope))\n  }\n\n  interactions.signals.on('up', ({ interaction, pointer, event, eventTarget }) => {\n    if (!interaction.pointerWasMoved) {\n      fire({ interaction, eventTarget, pointer, event, type: 'tap' }, scope)\n    }\n  })\n}\n\nfunction createSignalListener (type: string, scope) {\n  return function ({ interaction, pointer, event, eventTarget }: any) {\n    fire({ interaction, eventTarget, pointer, event, type }, scope)\n  }\n}\n\nexport default pointerEvents\n"]}
+//# sourceMappingURL=base.js.map

holdRepeat.js

@@ -1,53 +0,74 @@
-import basePlugin from './base';
+import basePlugin from "./base.js";
+
 function install(scope) {
-    const { pointerEvents, interactions, } = scope;
-    scope.usePlugin(basePlugin);
-    pointerEvents.signals.on('new', onNew);
-    pointerEvents.signals.on('fired', arg => onFired(arg, scope));
-    for (const signal of ['move', 'up', 'cancel', 'endall']) {
-        interactions.signals.on(signal, endHoldRepeat);
-    }
-    // don't repeat by default
-    pointerEvents.defaults.holdRepeatInterval = 0;
-    pointerEvents.types.push('holdrepeat');
+  scope.usePlugin(basePlugin);
+  const {
+    pointerEvents
+  } = scope; // don't repeat by default
+
+  pointerEvents.defaults.holdRepeatInterval = 0;
+  pointerEvents.types.push('holdrepeat');
 }
-function onNew({ pointerEvent }) {
-    if (pointerEvent.type !== 'hold') {
-        return;
-    }
-    pointerEvent.count = (pointerEvent.count || 0) + 1;
+
+function onNew({
+  pointerEvent
+}) {
+  if (pointerEvent.type !== 'hold') {
+    return;
+  }
+
+  pointerEvent.count = (pointerEvent.count || 0) + 1;
 }
-function onFired({ interaction, pointerEvent, eventTarget, targets }, scope) {
-    if (pointerEvent.type !== 'hold' || !targets.length) {
-        return;
-    }
-    // get the repeat interval from the first eventable
-    const interval = targets[0].eventable.options.holdRepeatInterval;
-    // don't repeat if the interval is 0 or less
-    if (interval <= 0) {
-        return;
-    }
-    // set a timeout to fire the holdrepeat event
-    interaction.holdIntervalHandle = setTimeout(() => {
-        scope.pointerEvents.fire({
-            interaction,
-            eventTarget,
-            type: 'hold',
-            pointer: pointerEvent,
-            event: pointerEvent,
-        }, scope);
-    }, interval);
+
+function onFired({
+  interaction,
+  pointerEvent,
+  eventTarget,
+  targets
+}, scope) {
+  if (pointerEvent.type !== 'hold' || !targets.length) {
+    return;
+  } // get the repeat interval from the first eventable
+
+
+  const interval = targets[0].eventable.options.holdRepeatInterval; // don't repeat if the interval is 0 or less
+
+  if (interval <= 0) {
+    return;
+  } // set a timeout to fire the holdrepeat event
+
+
+  interaction.holdIntervalHandle = setTimeout(() => {
+    scope.pointerEvents.fire({
+      interaction,
+      eventTarget,
+      type: 'hold',
+      pointer: pointerEvent,
+      event: pointerEvent
+    }, scope);
+  }, interval);
 }
-function endHoldRepeat({ interaction }) {
-    // set the interaction's holdStopTime property
-    // to stop further holdRepeat events
-    if (interaction.holdIntervalHandle) {
-        clearInterval(interaction.holdIntervalHandle);
-        interaction.holdIntervalHandle = null;
-    }
+
+function endHoldRepeat({
+  interaction
+}) {
+  // set the interaction's holdStopTime property
+  // to stop further holdRepeat events
+  if (interaction.holdIntervalHandle) {
+    clearInterval(interaction.holdIntervalHandle);
+    interaction.holdIntervalHandle = null;
+  }
 }
+
 export default {
-    id: 'pointer-events/holdRepeat',
-    install,
+  id: 'pointer-events/holdRepeat',
+  install,
+  listeners: ['move', 'up', 'cancel', 'endall'].reduce((acc, enderTypes) => {
+    acc[`pointerEvents:${enderTypes}`] = endHoldRepeat;
+    return acc;
+  }, {
+    'pointerEvents:new': onNew,
+    'pointerEvents:fired': onFired
+  })
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=holdRepeat.js.map

index.js

@@ -1,11 +0,13 @@
-import pointerEvents from './base';
-import holdRepeat from './holdRepeat';
-import interactableTargets from './interactableTargets';
+import pointerEvents from "./base.js";
+import holdRepeat from "./holdRepeat.js";
+import interactableTargets from "./interactableTargets.js";
+
 function install(scope) {
-    scope.usePlugin(pointerEvents);
-    scope.usePlugin(holdRepeat);
-    scope.usePlugin(interactableTargets);
+  scope.usePlugin(pointerEvents);
+  scope.usePlugin(holdRepeat);
+  scope.usePlugin(interactableTargets);
 }
+
 const id = 'pointer-events';
 export { id, pointerEvents, holdRepeat, interactableTargets, install };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLGFBQWEsTUFBTSxRQUFRLENBQUE7QUFDbEMsT0FBTyxVQUFVLE1BQU0sY0FBYyxDQUFBO0FBQ3JDLE9BQU8sbUJBQW1CLE1BQU0sdUJBQXVCLENBQUE7QUFFdkQsU0FBUyxPQUFPLENBQUUsS0FBSztJQUNyQixLQUFLLENBQUMsU0FBUyxDQUFDLGFBQWEsQ0FBQyxDQUFBO0lBQzlCLEtBQUssQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUE7SUFDM0IsS0FBSyxDQUFDLFNBQVMsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFBO0FBQ3RDLENBQUM7QUFFRCxNQUFNLEVBQUUsR0FBRyxnQkFBZ0IsQ0FBQTtBQUUzQixPQUFPLEVBQUUsRUFBRSxFQUFFLGFBQWEsRUFBRSxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsT0FBTyxFQUFFLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgcG9pbnRlckV2ZW50cyBmcm9tICcuL2Jhc2UnXG5pbXBvcnQgaG9sZFJlcGVhdCBmcm9tICcuL2hvbGRSZXBlYXQnXG5pbXBvcnQgaW50ZXJhY3RhYmxlVGFyZ2V0cyBmcm9tICcuL2ludGVyYWN0YWJsZVRhcmdldHMnXG5cbmZ1bmN0aW9uIGluc3RhbGwgKHNjb3BlKSB7XG4gIHNjb3BlLnVzZVBsdWdpbihwb2ludGVyRXZlbnRzKVxuICBzY29wZS51c2VQbHVnaW4oaG9sZFJlcGVhdClcbiAgc2NvcGUudXNlUGx1Z2luKGludGVyYWN0YWJsZVRhcmdldHMpXG59XG5cbmNvbnN0IGlkID0gJ3BvaW50ZXItZXZlbnRzJ1xuXG5leHBvcnQgeyBpZCwgcG9pbnRlckV2ZW50cywgaG9sZFJlcGVhdCwgaW50ZXJhY3RhYmxlVGFyZ2V0cywgaW5zdGFsbCB9XG4iXX0=
+//# sourceMappingURL=index.js.map

interactableTargets.d.ts

@@ -1,3 +0,1 @@
-import { Scope } from '@interactjs/core/scope';
-declare type Interactable = import('@interactjs/core/Interactable').default;
 declare module '@interactjs/core/Interactable' {
@@ -9,8 +7,4 @@ interface Interactable {
 }
-declare function install(scope: Scope): void;
-declare function pointerEventsMethod(this: Interactable, options: any): import("@interactjs/core/Interactable").Interactable;
-declare const _default: {
-    id: string;
-    install: typeof install;
-};
-export default _default;
+declare function pointerEventsMethod(this: Interact.Interactable, options: any): import("@interactjs/core/Interactable").Interactable;
+declare const plugin: Interact.Plugin;
+export default plugin;

interactableTargets.js

@@ -1,48 +0,72 @@
-import { merge } from '@interactjs/utils/arr';
-import extend from '@interactjs/utils/extend';
+import { merge } from "../utils/arr.js";
+import extend from "../utils/extend.js";
+
 function install(scope) {
-    const { pointerEvents, actions, Interactable, interactables, } = scope;
-    pointerEvents.signals.on('collect-targets', ({ targets, node, type, eventTarget, }) => {
-        scope.interactables.forEachMatch(node, (interactable) => {
-            const eventable = interactable.events;
-            const options = eventable.options;
-            if (eventable.types[type] &&
-                eventable.types[type].length &&
-                interactable.testIgnoreAllow(options, node, eventTarget)) {
-                targets.push({
-                    node,
-                    eventable,
-                    props: { interactable },
-                });
-            }
-        });
-    });
-    interactables.signals.on('new', ({ interactable }) => {
-        interactable.events.getRect = function (element) {
-            return interactable.getRect(element);
-        };
-    });
-    interactables.signals.on('set', ({ interactable, options }) => {
-        extend(interactable.events.options, pointerEvents.defaults);
-        extend(interactable.events.options, options.pointerEvents || {});
-    });
-    merge(actions.eventTypes, pointerEvents.types);
-    Interactable.prototype.pointerEvents = pointerEventsMethod;
-    const __backCompatOption = Interactable.prototype._backCompatOption;
-    Interactable.prototype._backCompatOption = function (optionName, newValue) {
-        const ret = __backCompatOption.call(this, optionName, newValue);
-        if (ret === this) {
-            this.events.options[optionName] = newValue;
-        }
-        return ret;
-    };
+  const {
+    pointerEvents,
+    actions,
+    Interactable
+  } = scope;
+  merge(actions.eventTypes, pointerEvents.types);
+  Interactable.prototype.pointerEvents = pointerEventsMethod;
+  const __backCompatOption = Interactable.prototype._backCompatOption;
+
+  Interactable.prototype._backCompatOption = function (optionName, newValue) {
+    const ret = __backCompatOption.call(this, optionName, newValue);
+
+    if (ret === this) {
+      this.events.options[optionName] = newValue;
+    }
+
+    return ret;
+  };
 }
+
 function pointerEventsMethod(options) {
-    extend(this.events.options, options);
-    return this;
+  extend(this.events.options, options);
+  return this;
 }
-export default {
-    id: 'pointer-events/interactableTargets',
-    install,
+
+const plugin = {
+  id: 'pointer-events/interactableTargets',
+  install,
+  listeners: {
+    'pointerEvents:collect-targets': ({
+      targets,
+      node,
+      type,
+      eventTarget
+    }, scope) => {
+      scope.interactables.forEachMatch(node, interactable => {
+        const eventable = interactable.events;
+        const options = eventable.options;
+
+        if (eventable.types[type] && eventable.types[type].length && interactable.testIgnoreAllow(options, node, eventTarget)) {
+          targets.push({
+            node,
+            eventable,
+            props: {
+              interactable
+            }
+          });
+        }
+      });
+    },
+    'interactable:new': ({
+      interactable
+    }) => {
+      interactable.events.getRect = function (element) {
+        return interactable.getRect(element);
+      };
+    },
+    'interactable:set': ({
+      interactable,
+      options
+    }, scope) => {
+      extend(interactable.events.options, scope.pointerEvents.defaults);
+      extend(interactable.events.options, options.pointerEvents || {});
+    }
+  }
 };
-//# sourceMappingURL=data:application/json;base64,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
+export default plugin;
+//# sourceMappingURL=interactableTargets.js.map

package.json

 {
   "name": "@interactjs/pointer-events",
-  "version": "1.6.3",
+  "version": "1.7.0",
   "license": "MIT",
   "peerDependencies": {
-    "@interactjs/core": "1.6.3",
-    "@interactjs/utils": "1.6.3"
+    "@interactjs/core": "1.7.0",
+    "@interactjs/utils": "1.7.0"
   },
@@ -9,0 +9,0 @@ "publishConfig": {

PointerEvent.d.ts

@@ -1,6 +0,6 @@
-import BaseEvent from '@interactjs/core/BaseEvent';
+import BaseEvent from '../core/BaseEvent';
 /** */
 export default class PointerEvent<T extends string> extends BaseEvent {
     type: T;
-    originalEvent: Interact.PointerEventType;
+    originalEvent: Interact.PointerEventType | PointerEvent<any>;
     pointerId: number;
@@ -16,3 +16,3 @@ pointerType: string;
     /** */
-    constructor(type: T, pointer: Interact.PointerType | PointerEvent<any>, event: Interact.PointerEventType, eventTarget: Interact.EventTarget, interaction: Interact.Interaction, timeStamp: number);
+    constructor(type: T, pointer: Interact.PointerType | PointerEvent<any>, event: Interact.PointerEventType | PointerEvent<any>, eventTarget: Interact.EventTarget, interaction: Interact.Interaction, timeStamp: number);
     _subtractOrigin({ x: originX, y: originY }: {
@@ -19,0 +19,0 @@ x: any;

PointerEvent.js

@@ -1,53 +0,89 @@
-import BaseEvent from '@interactjs/core/BaseEvent';
-import pointerUtils from '@interactjs/utils/pointerUtils';
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import BaseEvent from "../core/BaseEvent.js";
+import pointerUtils from "../utils/pointerUtils.js";
 /** */
+
 export default class PointerEvent extends BaseEvent {
-    /** */
-    constructor(type, pointer, event, eventTarget, interaction, timeStamp) {
-        super(interaction);
-        pointerUtils.pointerExtend(this, event);
-        if (event !== pointer) {
-            pointerUtils.pointerExtend(this, pointer);
-        }
-        this.timeStamp = timeStamp;
-        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 interval = this.timeStamp - interaction.tapTime;
-            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;
-        }
+  /** */
+  constructor(type, pointer, event, eventTarget, interaction, timeStamp) {
+    super(interaction);
+
+    _defineProperty(this, "type", void 0);
+
+    _defineProperty(this, "originalEvent", void 0);
+
+    _defineProperty(this, "pointerId", void 0);
+
+    _defineProperty(this, "pointerType", void 0);
+
+    _defineProperty(this, "double", void 0);
+
+    _defineProperty(this, "pageX", void 0);
+
+    _defineProperty(this, "pageY", void 0);
+
+    _defineProperty(this, "clientX", void 0);
+
+    _defineProperty(this, "clientY", void 0);
+
+    _defineProperty(this, "dt", void 0);
+
+    _defineProperty(this, "eventable", void 0);
+
+    pointerUtils.pointerExtend(this, event);
+
+    if (event !== pointer) {
+      pointerUtils.pointerExtend(this, pointer);
     }
-    _subtractOrigin({ x: originX, y: originY }) {
-        this.pageX -= originX;
-        this.pageY -= originY;
-        this.clientX -= originX;
-        this.clientY -= originY;
-        return this;
+
+    this.timeStamp = timeStamp;
+    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 interval = this.timeStamp - interaction.tapTime;
+      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;
     }
-    _addOrigin({ x: originX, y: originY }) {
-        this.pageX += originX;
-        this.pageY += originY;
-        this.clientX += originX;
-        this.clientY += originY;
-        return this;
-    }
-    /**
-     * Prevent the default behaviour of the original Event
-     */
-    preventDefault() {
-        this.originalEvent.preventDefault();
-    }
+  }
+
+  _subtractOrigin({
+    x: originX,
+    y: originY
+  }) {
+    this.pageX -= originX;
+    this.pageY -= originY;
+    this.clientX -= originX;
+    this.clientY -= originY;
+    return this;
+  }
+
+  _addOrigin({
+    x: originX,
+    y: originY
+  }) {
+    this.pageX += originX;
+    this.pageY += originY;
+    this.clientX += originX;
+    this.clientY += originY;
+    return this;
+  }
+  /**
+   * Prevent the default behaviour of the original Event
+   */
+
+
+  preventDefault() {
+    this.originalEvent.preventDefault();
+  }
+
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=PointerEvent.js.map

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

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

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

Improved metrics

Number of package files

21

increased by31.25%

Lines of code

606

increased by20.96%

Worsened metrics

Total package byte prevSize

51052

decreased by-7.87%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes