@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/eventDispatchers/shared/customCallbackHandler.js

@@ -0,0 +1,30 @@
+import { state } from '../../store/state';
+import ToolModes from '../../enums/ToolModes';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+const { Active } = ToolModes;
+export default function customCallbackHandler(handlerType, customFunction, evt) {
+    if (state.isInteractingWithTool) {
+        return false;
+    }
+    const { renderingEngineId, viewportId } = evt.detail;
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return false;
+    }
+    let activeTool;
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const tool = toolGroup.toolOptions[toolName];
+        const toolInstance = toolGroup.getToolInstance(toolName);
+        if (tool.mode === Active &&
+            typeof toolInstance[customFunction] === 'function') {
+            activeTool = toolGroup.getToolInstance(toolName);
+            break;
+        }
+    }
+    if (!activeTool) {
+        return;
+    }
+    activeTool[customFunction](evt);
+}

package/dist/esm/eventDispatchers/shared/getActiveToolForKeyboardEvent.d.ts

@@ -0,0 +1,2 @@
+import type { EventTypes } from '../../types';
+export default function getActiveToolForKeyboardEvent(evt: EventTypes.KeyDownEventType): any;

package/dist/esm/eventDispatchers/shared/getActiveToolForKeyboardEvent.js

@@ -0,0 +1,29 @@
+import { ToolModes } from '../../enums';
+import { keyEventListener } from '../../eventListeners';
+import { getMouseButton } from '../../eventListeners/mouse/mouseDownListener';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+const { Active } = ToolModes;
+export default function getActiveToolForKeyboardEvent(evt) {
+    const { renderingEngineId, viewportId } = evt.detail;
+    const mouseButton = getMouseButton();
+    const modifierKey = keyEventListener.getModifierKey();
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return null;
+    }
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    const defaultMousePrimary = toolGroup.getDefaultMousePrimary();
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const toolOptions = toolGroup.toolOptions[toolName];
+        if (toolOptions.mode !== Active) {
+            continue;
+        }
+        const correctBinding = toolOptions.bindings.length &&
+            toolOptions.bindings.some((binding) => binding.mouseButton === (mouseButton ?? defaultMousePrimary) &&
+                binding.modifierKey === modifierKey);
+        if (correctBinding) {
+            return toolGroup.getToolInstance(toolName);
+        }
+    }
+}

package/dist/esm/eventDispatchers/shared/getActiveToolForMouseEvent.d.ts

@@ -0,0 +1,2 @@
+import type { EventTypes } from '../../types';
+export default function getActiveToolForMouseEvent(evt: EventTypes.NormalizedMouseEventType): any;

package/dist/esm/eventDispatchers/shared/getActiveToolForMouseEvent.js

@@ -0,0 +1,28 @@
+import { ToolModes } from '../../enums';
+import { keyEventListener } from '../../eventListeners';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+import getMouseModifier from './getMouseModifier';
+const { Active } = ToolModes;
+export default function getActiveToolForMouseEvent(evt) {
+    const { renderingEngineId, viewportId, event: mouseEvent } = evt.detail;
+    const modifierKey = getMouseModifier(mouseEvent) || keyEventListener.getModifierKey();
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return null;
+    }
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    const defaultMousePrimary = toolGroup.getDefaultMousePrimary();
+    const mouseButton = evt.detail.buttons ?? mouseEvent?.buttons ?? defaultMousePrimary;
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const toolOptions = toolGroup.toolOptions[toolName];
+        const correctBinding = toolOptions.bindings.length &&
+            toolOptions.bindings.some((binding) => {
+                return (binding.mouseButton === mouseButton &&
+                    binding.modifierKey === modifierKey);
+            });
+        if (toolOptions.mode === Active && correctBinding) {
+            return toolGroup.getToolInstance(toolName);
+        }
+    }
+}

package/dist/esm/eventDispatchers/shared/getActiveToolForTouchEvent.d.ts

@@ -0,0 +1,2 @@
+import type { EventTypes } from '../../types';
+export default function getActiveToolForTouchEvent(evt: EventTypes.NormalizedTouchEventType): any;

package/dist/esm/eventDispatchers/shared/getActiveToolForTouchEvent.js

@@ -0,0 +1,29 @@
+import { ToolModes } from '../../enums';
+import getMouseModifier from './getMouseModifier';
+import { keyEventListener } from '../../eventListeners';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+const { Active } = ToolModes;
+export default function getActiveToolForTouchEvent(evt) {
+    const { renderingEngineId, viewportId } = evt.detail;
+    const touchEvent = evt.detail.event;
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return null;
+    }
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    const numTouchPoints = Object.keys(touchEvent.touches).length;
+    const modifierKey = getMouseModifier(touchEvent) || keyEventListener.getModifierKey();
+    const defaultMousePrimary = toolGroup.getDefaultMousePrimary();
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const toolOptions = toolGroup.toolOptions[toolName];
+        const correctBinding = toolOptions.bindings.length &&
+            toolOptions.bindings.some((binding) => (binding.numTouchPoints === numTouchPoints ||
+                (numTouchPoints === 1 &&
+                    binding.mouseButton === defaultMousePrimary)) &&
+                binding.modifierKey === modifierKey);
+        if (toolOptions.mode === Active && correctBinding) {
+            return toolGroup.getToolInstance(toolName);
+        }
+    }
+}

package/dist/esm/eventDispatchers/shared/getMouseModifier.d.ts

@@ -0,0 +1,3 @@
+import { KeyboardBindings as kb } from '../../enums';
+declare const getMouseModifierKey: (evt: any) => kb;
+export default getMouseModifierKey;

package/dist/esm/eventDispatchers/shared/getMouseModifier.js

@@ -0,0 +1,32 @@
+import { KeyboardBindings as kb } from '../../enums';
+const getMouseModifierKey = (evt) => {
+    if (evt.shiftKey) {
+        if (evt.ctrlKey) {
+            return kb.ShiftCtrl;
+        }
+        if (evt.altKey) {
+            return kb.ShiftAlt;
+        }
+        if (evt.metaKey) {
+            return kb.ShiftMeta;
+        }
+        return kb.Shift;
+    }
+    if (evt.ctrlKey) {
+        if (evt.altKey) {
+            return kb.CtrlAlt;
+        }
+        if (evt.metaKey) {
+            return kb.CtrlMeta;
+        }
+        return kb.Ctrl;
+    }
+    if (evt.altKey) {
+        return (evt.metaKey && kb.AltMeta) || kb.Alt;
+    }
+    if (evt.metaKey) {
+        return kb.Meta;
+    }
+    return undefined;
+};
+export default getMouseModifierKey;

package/dist/esm/eventDispatchers/shared/getToolsWithActionsForKeyboardEvents.d.ts

@@ -0,0 +1,3 @@
+import type { ToolModes } from '../../enums';
+import type { EventTypes } from '../../types';
+export default function getToolsWithModesForKeyboardEvent(evt: EventTypes.KeyDownEventType, toolModes: ToolModes[]): Map<any, any>;

package/dist/esm/eventDispatchers/shared/getToolsWithActionsForKeyboardEvents.js

@@ -0,0 +1,28 @@
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+export default function getToolsWithModesForKeyboardEvent(evt, toolModes) {
+    const toolsWithActions = new Map();
+    const { renderingEngineId, viewportId } = evt.detail;
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return toolsWithActions;
+    }
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    const key = evt.detail.key;
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const tool = toolGroup.getToolInstance(toolName);
+        const actionsConfig = tool.configuration?.actions;
+        if (!actionsConfig) {
+            continue;
+        }
+        const actions = Object.values(actionsConfig);
+        if (!actions?.length || !toolModes.includes(tool.mode)) {
+            continue;
+        }
+        const action = actions.find((action) => action.bindings?.some((binding) => binding.key === key));
+        if (action) {
+            toolsWithActions.set(tool, action);
+        }
+    }
+    return toolsWithActions;
+}

package/dist/esm/eventDispatchers/shared/getToolsWithActionsForMouseEvent.d.ts

@@ -0,0 +1,4 @@
+import type { ToolModes } from '../../enums';
+import type { ToolAction, EventTypes } from '../../types';
+import type { BaseTool } from '../../tools';
+export default function getToolsWithActionsForMouseEvent(evt: EventTypes.MouseMoveEventType, toolModes: ToolModes[]): Map<BaseTool, ToolAction>;

package/dist/esm/eventDispatchers/shared/getToolsWithActionsForMouseEvent.js

@@ -0,0 +1,32 @@
+import { keyEventListener } from '../../eventListeners';
+import getMouseModifier from './getMouseModifier';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+export default function getToolsWithActionsForMouseEvent(evt, toolModes) {
+    const toolsWithActions = new Map();
+    const { renderingEngineId, viewportId } = evt.detail;
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return toolsWithActions;
+    }
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    const defaultMousePrimary = toolGroup.getDefaultMousePrimary();
+    const mouseEvent = evt.detail.event;
+    const mouseButton = mouseEvent?.buttons ?? defaultMousePrimary;
+    const modifierKey = getMouseModifier(mouseEvent) || keyEventListener.getModifierKey();
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const tool = toolGroup.getToolInstance(toolName);
+        const actionsConfig = tool.configuration?.actions ?? {};
+        const actions = Object.values(actionsConfig);
+        if (!actions?.length || !toolModes.includes(tool.mode)) {
+            continue;
+        }
+        const action = actions.find((action) => action.bindings?.length &&
+            action.bindings.some((binding) => binding.mouseButton === mouseButton &&
+                binding.modifierKey === modifierKey));
+        if (action) {
+            toolsWithActions.set(tool, action);
+        }
+    }
+    return toolsWithActions;
+}

package/dist/esm/eventDispatchers/shared/getToolsWithModesForMouseEvent.d.ts

@@ -0,0 +1,5 @@
+import type { ToolModes } from '../../enums';
+import type { EventTypes } from '../../types';
+type ModesFilter = Array<ToolModes>;
+export default function getToolsWithModesForMouseEvent(evt: EventTypes.MouseMoveEventType, modesFilter: ModesFilter, evtButton?: number): any[];
+export {};

package/dist/esm/eventDispatchers/shared/getToolsWithModesForMouseEvent.js

@@ -0,0 +1,23 @@
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+export default function getToolsWithModesForMouseEvent(evt, modesFilter, evtButton) {
+    const { renderingEngineId, viewportId } = evt.detail;
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return [];
+    }
+    const enabledTools = [];
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const tool = toolGroup.toolOptions[toolName];
+        const correctBinding = evtButton != null &&
+            tool.bindings.length &&
+            tool.bindings.some((binding) => binding.mouseButton === evtButton);
+        if (modesFilter.includes(tool.mode) &&
+            (!evtButton || correctBinding)) {
+            const toolInstance = toolGroup.getToolInstance(toolName);
+            enabledTools.push(toolInstance);
+        }
+    }
+    return enabledTools;
+}

package/dist/esm/eventDispatchers/shared/getToolsWithModesForTouchEvent.d.ts

@@ -0,0 +1,5 @@
+import type { ToolModes } from '../../enums';
+import type { EventTypes } from '../../types';
+type ModesFilter = Array<ToolModes>;
+export default function getToolsWithModesForTouchEvent(evt: EventTypes.NormalizedTouchEventType, modesFilter: ModesFilter, numTouchPoints?: number): any[];
+export {};

package/dist/esm/eventDispatchers/shared/getToolsWithModesForTouchEvent.js

@@ -0,0 +1,23 @@
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+export default function getToolsWithModesForTouchEvent(evt, modesFilter, numTouchPoints) {
+    const { renderingEngineId, viewportId } = evt.detail;
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return [];
+    }
+    const enabledTools = [];
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const tool = toolGroup.toolOptions[toolName];
+        const correctBinding = numTouchPoints != null &&
+            tool.bindings.length &&
+            tool.bindings.some((binding) => binding.numTouchPoints === numTouchPoints);
+        if (modesFilter.includes(tool.mode) &&
+            (!numTouchPoints || correctBinding)) {
+            const toolInstance = toolGroup.getToolInstance(toolName);
+            enabledTools.push(toolInstance);
+        }
+    }
+    return enabledTools;
+}

package/dist/esm/eventDispatchers/touchEventHandlers/index.d.ts

@@ -0,0 +1,7 @@
+import touchStart from './touchStart';
+import touchStartActivate from './touchStartActivate';
+import touchDrag from './touchDrag';
+import touchEnd from './touchEnd';
+import touchTap from './touchTap';
+import touchPress from './touchPress';
+export { touchStart, touchStartActivate, touchDrag, touchEnd, touchTap, touchPress };

package/dist/esm/eventDispatchers/touchEventHandlers/index.js

@@ -0,0 +1,7 @@
+import touchStart from './touchStart';
+import touchStartActivate from './touchStartActivate';
+import touchDrag from './touchDrag';
+import touchEnd from './touchEnd';
+import touchTap from './touchTap';
+import touchPress from './touchPress';
+export { touchStart, touchStartActivate, touchDrag, touchEnd, touchTap, touchPress, };

package/dist/esm/eventDispatchers/touchEventHandlers/touchDrag.d.ts

@@ -0,0 +1,2 @@
+import type { TouchDragEventType } from '../../types/EventTypes';
+export default function touchDrag(evt: TouchDragEventType): void;

package/dist/esm/eventDispatchers/touchEventHandlers/touchDrag.js

@@ -0,0 +1,13 @@
+import getActiveToolForTouchEvent from '../shared/getActiveToolForTouchEvent';
+import { state } from '../../store/state';
+export default function touchDrag(evt) {
+    if (state.isInteractingWithTool) {
+        return;
+    }
+    const activeTool = getActiveToolForTouchEvent(evt);
+    const noFoundToolOrDoesNotHaveTouchDragCallback = !activeTool || typeof activeTool.touchDragCallback !== 'function';
+    if (noFoundToolOrDoesNotHaveTouchDragCallback) {
+        return;
+    }
+    activeTool.touchDragCallback(evt);
+}

package/dist/esm/eventDispatchers/touchEventHandlers/touchEnd.d.ts

@@ -0,0 +1,2 @@
+declare const touchEnd: (evt: any) => boolean;
+export default touchEnd;

package/dist/esm/eventDispatchers/touchEventHandlers/touchEnd.js

@@ -0,0 +1,3 @@
+import customCallbackHandler from '../shared/customCallbackHandler';
+const touchEnd = customCallbackHandler.bind(null, 'Touch', 'touchEndCallback');
+export default touchEnd;

package/dist/esm/eventDispatchers/touchEventHandlers/touchPress.d.ts

@@ -0,0 +1,2 @@
+declare const touchPress: (evt: any) => boolean;
+export default touchPress;

package/dist/esm/eventDispatchers/touchEventHandlers/touchPress.js

@@ -0,0 +1,3 @@
+import customCallbackHandler from '../shared/customCallbackHandler';
+const touchPress = customCallbackHandler.bind(null, 'Touch', 'touchPressCallback');
+export default touchPress;

package/dist/esm/eventDispatchers/touchEventHandlers/touchStart.d.ts

@@ -0,0 +1,2 @@
+import type { EventTypes } from '../../types';
+export default function touchStart(evt: EventTypes.TouchStartEventType): void;

package/dist/esm/eventDispatchers/touchEventHandlers/touchStart.js

@@ -0,0 +1,79 @@
+import { state } from '../../store/state';
+import { ToolModes } from '../../enums';
+import { setAnnotationSelected, isAnnotationSelected, } from '../../stateManagement/annotation/annotationSelection';
+import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
+import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
+import filterToolsWithMoveableHandles from '../../store/filterToolsWithMoveableHandles';
+import filterToolsWithAnnotationsForElement from '../../store/filterToolsWithAnnotationsForElement';
+import filterMoveableAnnotationTools from '../../store/filterMoveableAnnotationTools';
+import getActiveToolForTouchEvent from '../shared/getActiveToolForTouchEvent';
+import getToolsWithModesForTouchEvent from '../shared/getToolsWithModesForTouchEvent';
+const { Active, Passive } = ToolModes;
+export default function touchStart(evt) {
+    if (state.isInteractingWithTool) {
+        return;
+    }
+    const activeTool = getActiveToolForTouchEvent(evt);
+    if (activeTool && typeof activeTool.preTouchStartCallback === 'function') {
+        const consumedEvent = activeTool.preTouchStartCallback(evt);
+        if (consumedEvent) {
+            return;
+        }
+    }
+    const isPrimaryClick = Object.keys(evt.detail.event.touches).length === 1;
+    const activeToolsWithEventBinding = getToolsWithModesForTouchEvent(evt, [Active], Object.keys(evt.detail.event.touches).length);
+    const passiveToolsIfEventWasPrimaryTouchButton = isPrimaryClick
+        ? getToolsWithModesForTouchEvent(evt, [Passive])
+        : undefined;
+    const applicableTools = [
+        ...(activeToolsWithEventBinding || []),
+        ...(passiveToolsIfEventWasPrimaryTouchButton || []),
+        activeTool,
+    ];
+    const eventDetail = evt.detail;
+    const { element } = eventDetail;
+    const annotationToolsWithAnnotations = filterToolsWithAnnotationsForElement(element, applicableTools);
+    const canvasCoords = eventDetail.currentPoints.canvas;
+    const annotationToolsWithMoveableHandles = filterToolsWithMoveableHandles(element, annotationToolsWithAnnotations, canvasCoords, 'touch');
+    const isMultiSelect = false;
+    if (annotationToolsWithMoveableHandles.length > 0) {
+        const { tool, annotation, handle } = getAnnotationForSelection(annotationToolsWithMoveableHandles);
+        toggleAnnotationSelection(annotation.annotationUID, isMultiSelect);
+        tool.handleSelectedCallback(evt, annotation, handle, 'Touch');
+        return;
+    }
+    const moveableAnnotationTools = filterMoveableAnnotationTools(element, annotationToolsWithAnnotations, canvasCoords, 'touch');
+    if (moveableAnnotationTools.length > 0) {
+        const { tool, annotation } = getAnnotationForSelection(moveableAnnotationTools);
+        toggleAnnotationSelection(annotation.annotationUID, isMultiSelect);
+        tool.toolSelectedCallback(evt, annotation, 'Touch');
+        return;
+    }
+    if (activeTool && typeof activeTool.postTouchStartCallback === 'function') {
+        const consumedEvent = activeTool.postTouchStartCallback(evt);
+        if (consumedEvent) {
+            return;
+        }
+    }
+}
+function getAnnotationForSelection(toolsWithMovableHandles) {
+    return ((toolsWithMovableHandles.length > 1 &&
+        toolsWithMovableHandles.find((item) => !isAnnotationLocked(item.annotation.annotationUID) &&
+            isAnnotationVisible(item.annotation.annotationUID))) ||
+        toolsWithMovableHandles[0]);
+}
+function toggleAnnotationSelection(annotationUID, isMultiSelect = false) {
+    if (isMultiSelect) {
+        if (isAnnotationSelected(annotationUID)) {
+            setAnnotationSelected(annotationUID, false);
+        }
+        else {
+            const preserveSelected = true;
+            setAnnotationSelected(annotationUID, true, preserveSelected);
+        }
+    }
+    else {
+        const preserveSelected = false;
+        setAnnotationSelected(annotationUID, true, preserveSelected);
+    }
+}

package/dist/esm/eventDispatchers/touchEventHandlers/touchStartActivate.d.ts

@@ -0,0 +1,2 @@
+import type { EventTypes } from '../../types';
+export default function touchStartActivate(evt: EventTypes.TouchStartActivateEventType): void;

package/dist/esm/eventDispatchers/touchEventHandlers/touchStartActivate.js

@@ -0,0 +1,19 @@
+import { state } from '../../store/state';
+import { setAnnotationSelected } from '../../stateManagement/annotation/annotationSelection';
+import getActiveToolForTouchEvent from '../shared/getActiveToolForTouchEvent';
+export default function touchStartActivate(evt) {
+    if (state.isInteractingWithTool) {
+        return;
+    }
+    const activeTool = getActiveToolForTouchEvent(evt);
+    if (!activeTool) {
+        return;
+    }
+    if (state.isMultiPartToolActive) {
+        return;
+    }
+    if (activeTool.addNewAnnotation) {
+        const annotation = activeTool.addNewAnnotation(evt, 'touch');
+        setAnnotationSelected(annotation.annotationUID);
+    }
+}

package/dist/esm/eventDispatchers/touchEventHandlers/touchTap.d.ts

@@ -0,0 +1,2 @@
+declare const touchTap: (evt: any) => boolean;
+export default touchTap;

package/dist/esm/eventDispatchers/touchEventHandlers/touchTap.js

@@ -0,0 +1,3 @@
+import customCallbackHandler from '../shared/customCallbackHandler';
+const touchTap = customCallbackHandler.bind(null, 'Touch', 'touchTapCallback');
+export default touchTap;

package/dist/esm/eventDispatchers/touchToolEventDispatcher.d.ts

@@ -0,0 +1,5 @@
+declare const touchToolEventDispatcher: {
+    enable: (element: HTMLDivElement) => void;
+    disable: (element: HTMLDivElement) => void;
+};
+export default touchToolEventDispatcher;

package/dist/esm/eventDispatchers/touchToolEventDispatcher.js

@@ -0,0 +1,22 @@
+import Events from '../enums/Events';
+import { touchStart, touchStartActivate, touchDrag, touchEnd, touchTap, touchPress, } from './touchEventHandlers';
+const enable = function (element) {
+    element.addEventListener(Events.TOUCH_START, touchStart);
+    element.addEventListener(Events.TOUCH_START_ACTIVATE, touchStartActivate);
+    element.addEventListener(Events.TOUCH_DRAG, touchDrag);
+    element.addEventListener(Events.TOUCH_END, touchEnd);
+    element.addEventListener(Events.TOUCH_TAP, touchTap);
+    element.addEventListener(Events.TOUCH_PRESS, touchPress);
+};
+const disable = function (element) {
+    element.removeEventListener(Events.TOUCH_START, touchStart);
+    element.removeEventListener(Events.TOUCH_START_ACTIVATE, touchStartActivate);
+    element.removeEventListener(Events.TOUCH_DRAG, touchDrag);
+    element.removeEventListener(Events.TOUCH_END, touchEnd);
+    element.removeEventListener(Events.TOUCH_PRESS, touchPress);
+};
+const touchToolEventDispatcher = {
+    enable,
+    disable,
+};
+export default touchToolEventDispatcher;

package/dist/esm/eventListeners/annotations/annotationCompletedListener.d.ts

@@ -0,0 +1,2 @@
+import type { AnnotationCompletedEventType } from '../../types/EventTypes';
+export default function annotationCompletedListener(evt: AnnotationCompletedEventType): void;

package/dist/esm/eventListeners/annotations/annotationCompletedListener.js

@@ -0,0 +1,8 @@
+import * as contourSegUtils from '../../utilities/contourSegmentation';
+import { contourSegmentationCompleted } from './contourSegmentation';
+export default function annotationCompletedListener(evt) {
+    const annotation = evt.detail.annotation;
+    if (contourSegUtils.isContourSegmentationAnnotation(annotation)) {
+        contourSegmentationCompleted(evt);
+    }
+}

package/dist/esm/eventListeners/annotations/annotationModifiedListener.d.ts

@@ -0,0 +1,2 @@
+declare function annotationModifiedListener(evt: any): void;
+export default annotationModifiedListener;

package/dist/esm/eventListeners/annotations/annotationModifiedListener.js

@@ -0,0 +1,6 @@
+import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+function annotationModifiedListener(evt) {
+    const { viewportId } = evt.detail;
+    triggerAnnotationRenderForViewportIds([viewportId]);
+}
+export default annotationModifiedListener;

package/dist/esm/eventListeners/annotations/annotationRemovedListener.d.ts

@@ -0,0 +1,2 @@
+import type { AnnotationRemovedEventType } from '../../types/EventTypes';
+export default function annotationRemovedListener(evt: AnnotationRemovedEventType): void;

package/dist/esm/eventListeners/annotations/annotationRemovedListener.js

@@ -0,0 +1,8 @@
+import * as contourSegUtils from '../../utilities/contourSegmentation';
+import { contourSegmentationRemoved } from './contourSegmentation';
+export default function annotationRemovedListener(evt) {
+    const annotation = evt.detail.annotation;
+    if (contourSegUtils.isContourSegmentationAnnotation(annotation)) {
+        contourSegmentationRemoved(evt);
+    }
+}

package/dist/esm/eventListeners/annotations/annotationSelectionListener.d.ts

@@ -0,0 +1,2 @@
+declare function annotationSelectionListener(evt: any): void;
+export default annotationSelectionListener;

package/dist/esm/eventListeners/annotations/annotationSelectionListener.js

@@ -0,0 +1,15 @@
+import { getRenderingEngines } from '@cornerstonejs/core';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
+function annotationSelectionListener(evt) {
+    const deselectedAnnotation = evt.detail.removed;
+    if (!deselectedAnnotation.length) {
+        return;
+    }
+    const renderingEngines = getRenderingEngines();
+    renderingEngines.forEach((renderingEngine) => {
+        const viewports = renderingEngine.getViewports();
+        const viewportIds = viewports.map((vp) => vp.id);
+        triggerAnnotationRenderForViewportIds(viewportIds);
+    });
+}
+export default annotationSelectionListener;

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../../types/ContourSegmentationAnnotation';
+import type { AnnotationCompletedEventType } from '../../../types/EventTypes';
+export default function contourSegmentationCompletedListener(evt: AnnotationCompletedEventType): Promise<void>;
+export declare function createPolylineHole(viewport: Types.IViewport, targetAnnotation: ContourSegmentationAnnotation, holeAnnotation: ContourSegmentationAnnotation): void;