@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/eventListeners/touch/preventGhostClick.js

@@ -0,0 +1,47 @@
+const antiGhostDelay = 2000, pointerType = {
+    mouse: 0,
+    touch: 1,
+};
+let lastInteractionType, lastInteractionTime;
+function handleTap(type, e) {
+    const now = Date.now();
+    if (type !== lastInteractionType) {
+        if (now - lastInteractionTime <= antiGhostDelay) {
+            e.preventDefault();
+            e.stopPropagation();
+            e.stopImmediatePropagation();
+            return false;
+        }
+        lastInteractionType = type;
+    }
+    lastInteractionTime = now;
+}
+const handleTapMouse = handleTap.bind(null, pointerType.mouse);
+const handleTapTouch = handleTap.bind(null, pointerType.touch);
+function attachEvents(element, eventList, interactionType) {
+    const tapHandler = interactionType ? handleTapMouse : handleTapTouch;
+    eventList.forEach(function (eventName) {
+        element.addEventListener(eventName, tapHandler, { passive: false });
+    });
+}
+function removeEvents(element, eventList, interactionType) {
+    const tapHandler = interactionType ? handleTapMouse : handleTapTouch;
+    eventList.forEach(function (eventName) {
+        element.removeEventListener(eventName, tapHandler);
+    });
+}
+const mouseEvents = ['mousedown', 'mouseup', 'mousemove'];
+const touchEvents = ['touchstart', 'touchend'];
+function disable(element) {
+    removeEvents(element, mouseEvents, pointerType.mouse);
+    removeEvents(element, touchEvents, pointerType.touch);
+}
+function enable(element) {
+    disable(element);
+    attachEvents(element, mouseEvents, pointerType.mouse);
+    attachEvents(element, touchEvents, pointerType.touch);
+}
+export default {
+    enable,
+    disable,
+};

package/dist/esm/eventListeners/touch/touchStartListener.d.ts

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

package/dist/esm/eventListeners/touch/touchStartListener.js

@@ -0,0 +1,282 @@
+import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
+import Events from '../../enums/Events';
+import { Swipe } from '../../enums/Touch';
+import getTouchEventPoints from './getTouchEventPoints';
+import { copyPoints, copyPointsList, getDeltaDistanceBetweenIPoints, getDeltaDistance, getDeltaPoints, getMeanTouchPoints, } from '../../utilities/touch';
+import { Settings } from '@cornerstonejs/core';
+const runtimeSettings = Settings.getRuntimeSettings();
+const { TOUCH_START, TOUCH_START_ACTIVATE, TOUCH_PRESS, TOUCH_DRAG, TOUCH_END, TOUCH_TAP, TOUCH_SWIPE, } = Events;
+const zeroIPoint = {
+    page: [0, 0],
+    client: [0, 0],
+    canvas: [0, 0],
+    world: [0, 0, 0],
+};
+const zeroIDistance = {
+    page: 0,
+    client: 0,
+    canvas: 0,
+    world: 0,
+};
+const defaultState = {
+    renderingEngineId: undefined,
+    viewportId: undefined,
+    element: null,
+    startPointsList: [
+        {
+            ...zeroIPoint,
+            touch: null,
+        },
+    ],
+    lastPointsList: [
+        {
+            ...zeroIPoint,
+            touch: null,
+        },
+    ],
+    isTouchStart: false,
+    startTime: null,
+    pressTimeout: null,
+    pressDelay: 700,
+    pressMaxDistance: 5,
+    accumulatedDistance: zeroIDistance,
+    swipeDistanceThreshold: 48,
+    swiped: false,
+    swipeToleranceMs: 300,
+};
+const defaultTapState = {
+    renderingEngineId: undefined,
+    viewportId: undefined,
+    element: null,
+    startPointsList: [
+        {
+            ...zeroIPoint,
+            touch: null,
+        },
+    ],
+    taps: 0,
+    tapTimeout: null,
+    tapMaxDistance: 24,
+    tapToleranceMs: 300,
+};
+let state = JSON.parse(JSON.stringify(defaultState));
+let tapState = JSON.parse(JSON.stringify(defaultTapState));
+function triggerEventCallback(ele, name, eventDetail) {
+    return triggerEvent(ele, name, eventDetail);
+}
+function touchStartListener(evt) {
+    state.element = evt.currentTarget;
+    const enabledElement = getEnabledElement(state.element);
+    const { renderingEngineId, viewportId } = enabledElement;
+    state.renderingEngineId = renderingEngineId;
+    state.viewportId = viewportId;
+    if (state.isTouchStart) {
+        return;
+    }
+    clearTimeout(state.pressTimeout);
+    state.pressTimeout = setTimeout(() => _onTouchPress(evt), state.pressDelay);
+    _onTouchStart(evt);
+    document.addEventListener('touchmove', _onTouchDrag);
+    document.addEventListener('touchend', _onTouchEnd);
+}
+function _onTouchPress(evt) {
+    const totalDistance = state.accumulatedDistance.canvas;
+    if (totalDistance > state.pressMaxDistance) {
+        return;
+    }
+    const eventDetail = {
+        event: evt,
+        eventName: TOUCH_PRESS,
+        renderingEngineId: state.renderingEngineId,
+        viewportId: state.viewportId,
+        camera: {},
+        element: state.element,
+        startPointsList: copyPointsList(state.startPointsList),
+        lastPointsList: copyPointsList(state.lastPointsList),
+        startPoints: copyPoints(getMeanTouchPoints(state.startPointsList)),
+        lastPoints: copyPoints(getMeanTouchPoints(state.lastPointsList)),
+    };
+    triggerEventCallback(eventDetail.element, TOUCH_PRESS, eventDetail);
+}
+function _onTouchStart(evt) {
+    state.isTouchStart = true;
+    state.startTime = new Date();
+    const startPointsList = getTouchEventPoints(evt, state.element);
+    const startPoints = getMeanTouchPoints(startPointsList);
+    const deltaPoints = zeroIPoint;
+    const deltaDistance = zeroIDistance;
+    const eventDetail = {
+        event: evt,
+        eventName: TOUCH_START,
+        element: state.element,
+        renderingEngineId: state.renderingEngineId,
+        viewportId: state.viewportId,
+        camera: {},
+        startPointsList: startPointsList,
+        lastPointsList: startPointsList,
+        currentPointsList: startPointsList,
+        startPoints: startPoints,
+        lastPoints: startPoints,
+        currentPoints: startPoints,
+        deltaPoints,
+        deltaDistance,
+    };
+    state.startPointsList = copyPointsList(eventDetail.startPointsList);
+    state.lastPointsList = copyPointsList(eventDetail.lastPointsList);
+    const eventDidPropagate = triggerEventCallback(eventDetail.element, TOUCH_START, eventDetail);
+    if (eventDidPropagate) {
+        triggerEventCallback(eventDetail.element, TOUCH_START_ACTIVATE, eventDetail);
+    }
+}
+function _onTouchDrag(evt) {
+    const currentPointsList = getTouchEventPoints(evt, state.element);
+    const lastPointsList = _updateTouchEventsLastPoints(state.element, state.lastPointsList);
+    const deltaPoints = currentPointsList.length === lastPointsList.length
+        ? getDeltaPoints(currentPointsList, lastPointsList)
+        : zeroIPoint;
+    const deltaDistance = currentPointsList.length === lastPointsList.length
+        ? getDeltaDistanceBetweenIPoints(currentPointsList, lastPointsList)
+        : zeroIDistance;
+    const totalDistance = currentPointsList.length === lastPointsList.length
+        ? getDeltaDistance(currentPointsList, state.lastPointsList)
+        : zeroIDistance;
+    state.accumulatedDistance = {
+        page: state.accumulatedDistance.page + totalDistance.page,
+        client: state.accumulatedDistance.client + totalDistance.client,
+        canvas: state.accumulatedDistance.canvas + totalDistance.canvas,
+        world: state.accumulatedDistance.world + totalDistance.world,
+    };
+    const eventDetail = {
+        event: evt,
+        eventName: TOUCH_DRAG,
+        renderingEngineId: state.renderingEngineId,
+        viewportId: state.viewportId,
+        camera: {},
+        element: state.element,
+        startPoints: getMeanTouchPoints(state.startPointsList),
+        lastPoints: getMeanTouchPoints(lastPointsList),
+        currentPoints: getMeanTouchPoints(currentPointsList),
+        startPointsList: copyPointsList(state.startPointsList),
+        lastPointsList: copyPointsList(lastPointsList),
+        currentPointsList,
+        deltaPoints: deltaPoints,
+        deltaDistance: deltaDistance,
+    };
+    triggerEventCallback(state.element, TOUCH_DRAG, eventDetail);
+    _checkTouchSwipe(evt, deltaPoints);
+    state.lastPointsList = copyPointsList(currentPointsList);
+}
+function _onTouchEnd(evt) {
+    clearTimeout(state.pressTimeout);
+    const currentPointsList = getTouchEventPoints(evt, state.element);
+    const lastPointsList = _updateTouchEventsLastPoints(state.element, state.lastPointsList);
+    const deltaPoints = currentPointsList.length === lastPointsList.length
+        ? getDeltaPoints(currentPointsList, lastPointsList)
+        : getDeltaPoints(currentPointsList, currentPointsList);
+    const deltaDistance = currentPointsList.length === lastPointsList.length
+        ? getDeltaDistanceBetweenIPoints(currentPointsList, lastPointsList)
+        : getDeltaDistanceBetweenIPoints(currentPointsList, currentPointsList);
+    const eventDetail = {
+        event: evt,
+        eventName: TOUCH_END,
+        element: state.element,
+        renderingEngineId: state.renderingEngineId,
+        viewportId: state.viewportId,
+        camera: {},
+        startPointsList: copyPointsList(state.startPointsList),
+        lastPointsList: copyPointsList(lastPointsList),
+        currentPointsList,
+        startPoints: getMeanTouchPoints(state.startPointsList),
+        lastPoints: getMeanTouchPoints(lastPointsList),
+        currentPoints: getMeanTouchPoints(currentPointsList),
+        deltaPoints,
+        deltaDistance,
+    };
+    triggerEventCallback(eventDetail.element, TOUCH_END, eventDetail);
+    _checkTouchTap(evt);
+    state = JSON.parse(JSON.stringify(defaultState));
+    document.removeEventListener('touchmove', _onTouchDrag);
+    document.removeEventListener('touchend', _onTouchEnd);
+}
+function _checkTouchTap(evt) {
+    const currentTime = new Date().getTime();
+    const startTime = state.startTime.getTime();
+    if (currentTime - startTime > tapState.tapToleranceMs) {
+        return;
+    }
+    if (tapState.taps === 0) {
+        tapState.element = state.element;
+        tapState.renderingEngineId = state.renderingEngineId;
+        tapState.viewportId = state.viewportId;
+        tapState.startPointsList = state.startPointsList;
+    }
+    if (tapState.taps > 0 &&
+        !(tapState.element == state.element &&
+            tapState.renderingEngineId == state.renderingEngineId &&
+            tapState.viewportId == state.viewportId)) {
+        return;
+    }
+    const currentPointsList = getTouchEventPoints(evt, tapState.element);
+    const distanceFromStart = getDeltaDistance(currentPointsList, tapState.startPointsList).canvas;
+    if (distanceFromStart > tapState.tapMaxDistance) {
+        return;
+    }
+    clearTimeout(tapState.tapTimeout);
+    tapState.taps += 1;
+    tapState.tapTimeout = setTimeout(() => {
+        const eventDetail = {
+            event: evt,
+            eventName: TOUCH_TAP,
+            element: tapState.element,
+            renderingEngineId: tapState.renderingEngineId,
+            viewportId: tapState.viewportId,
+            camera: {},
+            currentPointsList,
+            currentPoints: getMeanTouchPoints(currentPointsList),
+            taps: tapState.taps,
+        };
+        triggerEventCallback(eventDetail.element, TOUCH_TAP, eventDetail);
+        tapState = JSON.parse(JSON.stringify(defaultTapState));
+    }, tapState.tapToleranceMs);
+}
+function _checkTouchSwipe(evt, deltaPoints) {
+    const currentTime = new Date().getTime();
+    const startTime = state.startTime.getTime();
+    if (state.swiped || currentTime - startTime > state.swipeToleranceMs) {
+        return;
+    }
+    const [x, y] = deltaPoints.canvas;
+    const eventDetail = {
+        event: evt,
+        eventName: TOUCH_SWIPE,
+        renderingEngineId: state.renderingEngineId,
+        viewportId: state.viewportId,
+        camera: {},
+        element: state.element,
+        swipe: null,
+    };
+    if (Math.abs(x) > state.swipeDistanceThreshold) {
+        eventDetail.swipe = x > 0 ? Swipe.RIGHT : Swipe.LEFT;
+        triggerEventCallback(eventDetail.element, TOUCH_SWIPE, eventDetail);
+        state.swiped = true;
+    }
+    if (Math.abs(y) > state.swipeDistanceThreshold) {
+        eventDetail.swipe = y > 0 ? Swipe.DOWN : Swipe.UP;
+        triggerEventCallback(eventDetail.element, TOUCH_SWIPE, eventDetail);
+        state.swiped = true;
+    }
+}
+function _updateTouchEventsLastPoints(element, lastPoints) {
+    const { viewport } = getEnabledElement(element);
+    return lastPoints.map((lp) => {
+        const world = viewport.canvasToWorld(lp.canvas);
+        return {
+            page: lp.page,
+            client: lp.client,
+            canvas: lp.canvas,
+            world,
+            touch: lp.touch,
+        };
+    });
+}
+export default touchStartListener;

package/dist/esm/eventListeners/wheel/index.d.ts

@@ -0,0 +1,7 @@
+declare function enable(element: HTMLDivElement): void;
+declare function disable(element: HTMLDivElement): void;
+declare const _default: {
+    enable: typeof enable;
+    disable: typeof disable;
+};
+export default _default;

package/dist/esm/eventListeners/wheel/index.js

@@ -0,0 +1,12 @@
+import wheelListener from './wheelListener';
+function enable(element) {
+    disable(element);
+    element.addEventListener('wheel', wheelListener, { passive: false });
+}
+function disable(element) {
+    element.removeEventListener('wheel', wheelListener);
+}
+export default {
+    enable,
+    disable,
+};

package/dist/esm/eventListeners/wheel/normalizeWheel.d.ts

@@ -0,0 +1,6 @@
+export default function normalizeWheel(event: any): {
+    spinX: number;
+    spinY: number;
+    pixelX: number;
+    pixelY: number;
+};

package/dist/esm/eventListeners/wheel/normalizeWheel.js

@@ -0,0 +1,48 @@
+const PIXEL_STEP = 10;
+const LINE_HEIGHT = 40;
+const PAGE_HEIGHT = 800;
+export default function normalizeWheel(event) {
+    let spinX = 0, spinY = 0, pixelX = 0, pixelY = 0;
+    if ('detail' in event) {
+        spinY = event.detail;
+    }
+    if ('wheelDelta' in event) {
+        spinY = -event.wheelDelta / 120;
+    }
+    if ('wheelDeltaY' in event) {
+        spinY = -event.wheelDeltaY / 120;
+    }
+    if ('wheelDeltaX' in event) {
+        spinX = -event.wheelDeltaX / 120;
+    }
+    pixelX = spinX * PIXEL_STEP;
+    pixelY = spinY * PIXEL_STEP;
+    if ('deltaY' in event) {
+        pixelY = event.deltaY;
+    }
+    if ('deltaX' in event) {
+        pixelX = event.deltaX;
+    }
+    if ((pixelX || pixelY) && event.deltaMode) {
+        if (event.deltaMode === 1) {
+            pixelX *= LINE_HEIGHT;
+            pixelY *= LINE_HEIGHT;
+        }
+        else {
+            pixelX *= PAGE_HEIGHT;
+            pixelY *= PAGE_HEIGHT;
+        }
+    }
+    if (pixelX && !spinX) {
+        spinX = pixelX < 1 ? -1 : 1;
+    }
+    if (pixelY && !spinY) {
+        spinY = pixelY < 1 ? -1 : 1;
+    }
+    return {
+        spinX,
+        spinY,
+        pixelX,
+        pixelY,
+    };
+}

package/dist/esm/eventListeners/wheel/wheelListener.d.ts

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

package/dist/esm/eventListeners/wheel/wheelListener.js

@@ -0,0 +1,34 @@
+import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
+import normalizeWheel from './normalizeWheel';
+import Events from '../../enums/Events';
+import getMouseEventPoints from '../mouse/getMouseEventPoints';
+function wheelListener(evt) {
+    const element = evt.currentTarget;
+    const enabledElement = getEnabledElement(element);
+    const { renderingEngineId, viewportId } = enabledElement;
+    if (evt.deltaY > -1 && evt.deltaY < 1) {
+        return;
+    }
+    evt.preventDefault();
+    const { spinX, spinY, pixelX, pixelY } = normalizeWheel(evt);
+    const direction = spinY < 0 ? -1 : 1;
+    const eventDetail = {
+        event: evt,
+        eventName: Events.MOUSE_WHEEL,
+        renderingEngineId,
+        viewportId,
+        element,
+        camera: {},
+        detail: evt,
+        wheel: {
+            spinX,
+            spinY,
+            pixelX,
+            pixelY,
+            direction,
+        },
+        points: getMouseEventPoints(evt),
+    };
+    triggerEvent(element, Events.MOUSE_WHEEL, eventDetail);
+}
+export default wheelListener;

package/dist/esm/index.d.ts

@@ -0,0 +1,17 @@
+import { init, destroy } from './init';
+import { addTool, removeTool, ToolGroupManager, SynchronizerManager, Synchronizer, cancelActiveManipulations } from './store';
+import { state } from './store/state';
+import * as store from './store';
+import * as CONSTANTS from './constants';
+import * as synchronizers from './synchronizers';
+import * as drawing from './drawingSvg';
+import * as utilities from './utilities';
+import * as cursors from './cursors';
+import * as Types from './types';
+import * as annotation from './stateManagement/annotation';
+import * as segmentation from './stateManagement/segmentation';
+import * as splines from './tools/annotation/splines';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool } from './tools';
+import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
+import * as Enums from './enums';
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, splines, };

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+import { init, destroy } from './init';
+import { addTool, removeTool, ToolGroupManager, SynchronizerManager, Synchronizer, cancelActiveManipulations, } from './store';
+import { state } from './store/state';
+import * as store from './store';
+import * as CONSTANTS from './constants';
+import * as synchronizers from './synchronizers';
+import * as drawing from './drawingSvg';
+import * as utilities from './utilities';
+import * as cursors from './cursors';
+import * as Types from './types';
+import * as annotation from './stateManagement/annotation';
+import * as segmentation from './stateManagement/segmentation';
+import * as splines from './tools/annotation/splines';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, } from './tools';
+import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
+import * as Enums from './enums';
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, splines, };

package/dist/esm/init.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from './config';
+export declare function init(defaultConfiguration?: Config): void;
+export declare function destroy(): void;
+export default init;

package/dist/esm/init.js

@@ -0,0 +1,70 @@
+import { eventTarget, Enums } from '@cornerstonejs/core';
+import { getAnnotationManager } from './stateManagement/annotation/annotationState';
+import { Events as TOOLS_EVENTS } from './enums';
+import { addEnabledElement, removeEnabledElement } from './store';
+import { resetCornerstoneToolsState } from './store/state';
+import { annotationCompletedListener, annotationRemovedListener, annotationSelectionListener, annotationModifiedListener, segmentationDataModifiedEventListener, segmentationModifiedListener, } from './eventListeners';
+import { annotationInterpolationEventDispatcher } from './eventDispatchers';
+import * as ToolGroupManager from './store/ToolGroupManager';
+import { defaultSegmentationStateManager } from './stateManagement/segmentation/SegmentationStateManager';
+import segmentationRepresentationModifiedListener from './eventListeners/segmentation/segmentationRepresentationModifiedListener';
+import { setConfig } from './config';
+let csToolsInitialized = false;
+export function init(defaultConfiguration = {}) {
+    if (csToolsInitialized) {
+        return;
+    }
+    setConfig(defaultConfiguration);
+    _addCornerstoneEventListeners();
+    _addCornerstoneToolsEventListeners();
+    csToolsInitialized = true;
+}
+export function destroy() {
+    _removeCornerstoneEventListeners();
+    _removeCornerstoneToolsEventListeners();
+    ToolGroupManager.destroy();
+    resetCornerstoneToolsState();
+    const annotationManager = getAnnotationManager();
+    const segmentationStateManager = defaultSegmentationStateManager;
+    annotationManager.restoreAnnotations({});
+    segmentationStateManager.resetState();
+    csToolsInitialized = false;
+}
+function _addCornerstoneEventListeners() {
+    _removeCornerstoneEventListeners();
+    const elementEnabledEvent = Enums.Events.ELEMENT_ENABLED;
+    const elementDisabledEvent = Enums.Events.ELEMENT_DISABLED;
+    eventTarget.addEventListener(elementEnabledEvent, addEnabledElement);
+    eventTarget.addEventListener(elementDisabledEvent, removeEnabledElement);
+    annotationInterpolationEventDispatcher.enable();
+}
+function _removeCornerstoneEventListeners() {
+    const elementEnabledEvent = Enums.Events.ELEMENT_ENABLED;
+    const elementDisabledEvent = Enums.Events.ELEMENT_DISABLED;
+    eventTarget.removeEventListener(elementEnabledEvent, addEnabledElement);
+    eventTarget.removeEventListener(elementDisabledEvent, removeEnabledElement);
+    annotationInterpolationEventDispatcher.disable();
+}
+function _addCornerstoneToolsEventListeners() {
+    _removeCornerstoneToolsEventListeners();
+    eventTarget.addEventListener(TOOLS_EVENTS.ANNOTATION_COMPLETED, annotationCompletedListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.ANNOTATION_MODIFIED, annotationModifiedListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE, annotationSelectionListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE, annotationSelectionListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.ANNOTATION_REMOVED, annotationRemovedListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_MODIFIED, segmentationModifiedListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_DATA_MODIFIED, segmentationDataModifiedEventListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED, segmentationRepresentationModifiedListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_ADDED, segmentationRepresentationModifiedListener);
+}
+function _removeCornerstoneToolsEventListeners() {
+    eventTarget.removeEventListener(TOOLS_EVENTS.ANNOTATION_COMPLETED, annotationCompletedListener);
+    eventTarget.removeEventListener(TOOLS_EVENTS.ANNOTATION_MODIFIED, annotationModifiedListener);
+    eventTarget.removeEventListener(TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE, annotationSelectionListener);
+    eventTarget.removeEventListener(TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE, annotationSelectionListener);
+    eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_MODIFIED, segmentationModifiedListener);
+    eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_DATA_MODIFIED, segmentationDataModifiedEventListener);
+    eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED, segmentationRepresentationModifiedListener);
+    eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_ADDED, segmentationRepresentationModifiedListener);
+}
+export default init;

package/dist/esm/stateManagement/annotation/AnnotationGroup.d.ts

@@ -0,0 +1,18 @@
+export type BaseEventDetail = {
+    viewportId: string;
+    renderingEngineId: string;
+};
+export default class AnnotationGroup {
+    private annotationUIDs;
+    private _isVisible;
+    visibleFilter: (uid: string) => boolean;
+    constructor();
+    protected unboundVisibleFilter(uid: string): boolean;
+    has(uid: string): boolean;
+    setVisible(isVisible: boolean, baseEvent: BaseEventDetail, filter?: (annotationUID: string) => boolean): void;
+    get isVisible(): boolean;
+    findNearby(uid: string, direction: 1): string;
+    add(...annotationUIDs: string[]): void;
+    remove(...annotationUIDs: string[]): void;
+    clear(): void;
+}

package/dist/esm/stateManagement/annotation/AnnotationGroup.js

@@ -0,0 +1,69 @@
+import { eventTarget, triggerEvent } from '@cornerstonejs/core';
+import Events from '../../enums/Events';
+import { getAnnotation } from './annotationState';
+export default class AnnotationGroup {
+    constructor() {
+        this.annotationUIDs = new Set();
+        this._isVisible = true;
+        this.visibleFilter = this.unboundVisibleFilter.bind(this);
+    }
+    unboundVisibleFilter(uid) {
+        return !this._isVisible || !this.annotationUIDs.has(uid);
+    }
+    has(uid) {
+        return this.annotationUIDs.has(uid);
+    }
+    setVisible(isVisible = true, baseEvent, filter) {
+        if (this._isVisible === isVisible) {
+            return;
+        }
+        this._isVisible = isVisible;
+        this.annotationUIDs.forEach((uid) => {
+            const annotation = getAnnotation(uid);
+            if (!annotation) {
+                this.annotationUIDs.delete(uid);
+                return;
+            }
+            if (annotation.isVisible === isVisible) {
+                return;
+            }
+            if (!isVisible && filter?.(uid) === false) {
+                return;
+            }
+            annotation.isVisible = isVisible;
+            const eventDetail = {
+                ...baseEvent,
+                annotation,
+            };
+            triggerEvent(eventTarget, Events.ANNOTATION_MODIFIED, eventDetail);
+        });
+    }
+    get isVisible() {
+        return this._isVisible;
+    }
+    findNearby(uid, direction) {
+        const uids = [...this.annotationUIDs];
+        if (uids.length === 0) {
+            return null;
+        }
+        if (!uid) {
+            return uids[direction === 1 ? 0 : uids.length - 1];
+        }
+        const index = uids.indexOf(uid);
+        if (index === -1 ||
+            index + direction < 0 ||
+            index + direction >= uids.length) {
+            return null;
+        }
+        return uids[index + direction];
+    }
+    add(...annotationUIDs) {
+        annotationUIDs.forEach((annotationUID) => this.annotationUIDs.add(annotationUID));
+    }
+    remove(...annotationUIDs) {
+        annotationUIDs.forEach((annotationUID) => this.annotationUIDs.delete(annotationUID));
+    }
+    clear() {
+        this.annotationUIDs.clear();
+    }
+}