@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/esm/tools/MagnifyTool.js

@@ -3,7 +3,7 @@ import { Events } from '../enums';
 import { getEnabledElement, StackViewport } from '@cornerstonejs/core';
 import { getViewportIdsWithToolToRender } from '../utilities/viewportFilters';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
-import { state } from '../store';
+import { state } from '../store/state';
 import { Enums } from '@cornerstonejs/core';
 import { hideElementCursor, resetElementCursor, } from '../cursors/elementCursor';
 const MAGNIFY_VIEWPORT_ID = 'magnify-viewport';

package/dist/esm/tools/OrientationMarkerTool.d.ts

@@ -1,5 +1,43 @@
 import vtkAnnotatedCubeActor from '@kitware/vtk.js/Rendering/Core/AnnotatedCubeActor';
 import { BaseTool } from './base';
+declare enum OverlayMarkerType {
+    ANNOTATED_CUBE = 1,
+    AXES = 2,
+    CUSTOM = 3
+}
+type FaceProperty = {
+    text?: string;
+    faceColor?: string;
+    fontColor?: string;
+    faceRotation?: number;
+};
+type AnnotatedCubeConfig = {
+    faceProperties: {
+        xPlus: FaceProperty;
+        xMinus: FaceProperty;
+        yPlus: FaceProperty;
+        yMinus: FaceProperty;
+        zPlus: FaceProperty;
+        zMinus: FaceProperty;
+    };
+    defaultStyle: {
+        fontStyle?: string;
+        fontFamily?: string;
+        fontColor?: string;
+        fontSizeScale?: (res: number) => number;
+        faceColor?: string;
+        edgeThickness?: number;
+        edgeColor?: string;
+        resolution?: number;
+    };
+};
+type OverlayConfiguration = {
+    [OverlayMarkerType.ANNOTATED_CUBE]: AnnotatedCubeConfig;
+    [OverlayMarkerType.AXES]: Record<string, never>;
+    [OverlayMarkerType.CUSTOM]: {
+        polyDataURL: string;
+    };
+};
 declare class OrientationMarkerTool extends BaseTool {
     static toolName: any;
     static CUBE: number;
@@ -8,11 +46,7 @@ declare class OrientationMarkerTool extends BaseTool {
     orientationMarkers: any;
     polyDataURL: any;
     _resizeObservers: Map<any, any>;
-    static OVERLAY_MARKER_TYPES: {
-        ANNOTATED_CUBE: number;
-        AXES: number;
-        CUSTOM: number;
-    };
+    static OVERLAY_MARKER_TYPES: typeof OverlayMarkerType;
     constructor(toolProps?: {}, defaultToolProps?: {
         configuration: {
             orientationWidget: {
@@ -22,59 +56,8 @@ declare class OrientationMarkerTool extends BaseTool {
                 minPixelSize: number;
                 maxPixelSize: number;
             };
-            overlayMarkerType: number;
-            overlayConfiguration: {
-                [x: number]: {
-                    faceProperties: {
-                        xPlus: {
-                            text: string;
-                            faceColor: string;
-                            faceRotation: number;
-                        };
-                        xMinus: {
-                            text: string;
-                            faceColor: string;
-                            faceRotation: number;
-                        };
-                        yPlus: {
-                            text: string;
-                            faceColor: string;
-                            fontColor: string;
-                            faceRotation: number;
-                        };
-                        yMinus: {
-                            text: string;
-                            faceColor: string;
-                            fontColor: string;
-                        };
-                        zPlus: {
-                            text: string;
-                        };
-                        zMinus: {
-                            text: string;
-                        };
-                    };
-                    defaultStyle: {
-                        fontStyle: string;
-                        fontFamily: string;
-                        fontColor: string;
-                        fontSizeScale: (res: any) => number;
-                        faceColor: string;
-                        edgeThickness: number;
-                        edgeColor: string;
-                        resolution: number;
-                    };
-                    polyDataURL?: undefined;
-                } | {
-                    faceProperties?: undefined;
-                    defaultStyle?: undefined;
-                    polyDataURL?: undefined;
-                } | {
-                    polyDataURL: string;
-                    faceProperties?: undefined;
-                    defaultStyle?: undefined;
-                };
-            };
+            overlayMarkerType: OverlayMarkerType;
+            overlayConfiguration: OverlayConfiguration;
         };
     });
     onSetToolEnabled: () => void;

package/dist/esm/tools/OrientationMarkerTool.js

@@ -10,11 +10,12 @@ import { Enums, eventTarget, getEnabledElementByIds, getRenderingEngines, } from
 import { filterViewportsWithToolEnabled } from '../utilities/viewportFilters';
 import { getToolGroup } from '../store/ToolGroupManager';
 import { Events } from '../enums';
-const OverlayMarkerType = {
-    ANNOTATED_CUBE: 1,
-    AXES: 2,
-    CUSTOM: 3,
-};
+var OverlayMarkerType;
+(function (OverlayMarkerType) {
+    OverlayMarkerType[OverlayMarkerType["ANNOTATED_CUBE"] = 1] = "ANNOTATED_CUBE";
+    OverlayMarkerType[OverlayMarkerType["AXES"] = 2] = "AXES";
+    OverlayMarkerType[OverlayMarkerType["CUSTOM"] = 3] = "CUSTOM";
+})(OverlayMarkerType || (OverlayMarkerType = {}));
 class OrientationMarkerTool extends BaseTool {
     static { this.CUBE = 1; }
     static { this.AXIS = 2; }
@@ -33,8 +34,8 @@ class OrientationMarkerTool extends BaseTool {
             overlayConfiguration: {
                 [OrientationMarkerTool.OVERLAY_MARKER_TYPES.ANNOTATED_CUBE]: {
                     faceProperties: {
-                        xPlus: { text: 'R', faceColor: '#ffff00', faceRotation: 90 },
-                        xMinus: { text: 'L', faceColor: '#ffff00', faceRotation: 270 },
+                        xPlus: { text: 'L', faceColor: '#ffff00', faceRotation: 90 },
+                        xMinus: { text: 'R', faceColor: '#ffff00', faceRotation: 270 },
                         yPlus: {
                             text: 'P',
                             faceColor: '#00ffff',

package/dist/esm/tools/OverlayGridTool.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 export interface OverlayGridAnnotation extends Annotation {
     data: {
@@ -9,9 +9,7 @@ export interface OverlayGridAnnotation extends Annotation {
 }
 declare class OverlayGridTool extends AnnotationDisplayTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);

package/dist/esm/tools/OverlayGridTool.js

@@ -1,5 +1,5 @@
 import { vec3 } from 'gl-matrix';
-import { metaData, CONSTANTS, utilities as csUtils, } from '@cornerstonejs/core';
+import { metaData, CONSTANTS, getRenderingEngine, utilities as csUtils, } from '@cornerstonejs/core';
 import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
 import { getToolGroup } from '../store/ToolGroupManager';
 import { drawLine as drawLineSvg } from '../drawingSvg';

package/dist/esm/tools/PanTool.d.ts

@@ -1,5 +1,5 @@
 import { BaseTool } from './base';
-import { EventTypes, PublicToolProps, ToolProps } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
 declare class PanTool extends BaseTool {
     static toolName: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);

package/dist/esm/tools/PanTool.js

@@ -16,6 +16,11 @@ class PanTool extends BaseTool {
         const { element, deltaPoints } = evt.detail;
         const enabledElement = getEnabledElement(element);
         const deltaPointsWorld = deltaPoints.world;
+        if (deltaPointsWorld[0] === 0 &&
+            deltaPointsWorld[1] === 0 &&
+            deltaPointsWorld[2] === 0) {
+            return;
+        }
         const camera = enabledElement.viewport.getCamera();
         const { focalPoint, position } = camera;
         const updatedPosition = [

package/dist/esm/tools/PlanarRotateTool.d.ts

@@ -1,10 +1,12 @@
 import { BaseTool } from './base';
-import { PublicToolProps, ToolProps, EventTypes } from '../types';
+import type { PublicToolProps, ToolProps, EventTypes } from '../types';
 declare class PlanarRotateTool extends BaseTool {
     static toolName: any;
     touchDragCallback: (evt: EventTypes.MouseDragEventType) => void;
     mouseDragCallback: (evt: EventTypes.MouseDragEventType) => void;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseWheelCallback: (evt: EventTypes.MouseWheelEventType) => void;
     _dragCallback(evt: EventTypes.MouseDragEventType): void;
+    setAngle(viewport: any, angle: any): void;
 }
 export default PlanarRotateTool;

package/dist/esm/tools/PlanarRotateTool.js

@@ -1,4 +1,4 @@
-import { BaseVolumeViewport, getEnabledElement, } from '@cornerstonejs/core';
+import { BaseVolumeViewport, getEnabledElement } from '@cornerstonejs/core';
 import { mat4, vec3 } from 'gl-matrix';
 import { BaseTool } from './base';
 import angleBetweenLines from '../utilities/math/angle/angleBetweenLines';
@@ -7,6 +7,14 @@ class PlanarRotateTool extends BaseTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
     }) {
         super(toolProps, defaultToolProps);
+        this.mouseWheelCallback = (evt) => {
+            const { element, wheel } = evt.detail;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            const { invert } = this.configuration;
+            const angle = wheel.direction * 10 * (invert ? -1 : 1);
+            this.setAngle(viewport, angle);
+        };
         this.touchDragCallback = this._dragCallback.bind(this);
         this.mouseDragCallback = this._dragCallback.bind(this);
     }
@@ -22,7 +30,7 @@ class PlanarRotateTool extends BaseTool {
         const centerCanvas = [width * 0.5, height * 0.5];
         const centerWorld = viewport.canvasToWorld(centerCanvas);
         let angle = angleBetweenLines([startPointWorld, centerWorld], [centerWorld, currentPointWorld]);
-        const { viewPlaneNormal, viewUp } = camera;
+        const { viewPlaneNormal } = camera;
         const v1 = vec3.sub(vec3.create(), centerWorld, startPointWorld);
         const v2 = vec3.sub(vec3.create(), centerWorld, currentPointWorld);
         const cross = vec3.cross(vec3.create(), v1, v2);
@@ -32,8 +40,12 @@ class PlanarRotateTool extends BaseTool {
         if (Number.isNaN(angle)) {
             return;
         }
+        this.setAngle(viewport, angle);
+    }
+    setAngle(viewport, angle) {
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
         if (viewport instanceof BaseVolumeViewport) {
-            const rotAngle = (angle * Math.PI) / 180;
+            const rotAngle = (((angle + 360) % 360) * Math.PI) / 180;
             const rotMat = mat4.identity(new Float32Array(16));
             mat4.rotate(rotMat, rotMat, rotAngle, viewPlaneNormal);
             const rotatedViewUp = vec3.transformMat4(vec3.create(), viewUp, rotMat);
@@ -41,7 +53,9 @@ class PlanarRotateTool extends BaseTool {
         }
         else {
             const { rotation } = viewport.getViewPresentation();
-            viewport.setViewPresentation({ rotation: rotation + angle });
+            viewport.setViewPresentation({
+                rotation: (rotation + angle + 360) % 360,
+            });
         }
         viewport.render();
     }

package/dist/esm/tools/ReferenceCursors.d.ts

@@ -1,11 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, Annotations } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, Annotations } from '../types';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 declare class ReferenceCursors extends AnnotationDisplayTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     _elementWithCursor: null | HTMLDivElement;
@@ -19,7 +16,7 @@ declare class ReferenceCursors extends AnnotationDisplayTool {
     createInitialAnnotation: (worldPos: Types.Point3, element: HTMLDivElement) => void;
     getActiveAnnotation(element: HTMLDivElement): null | Annotation;
     updateAnnotationPosition(element: HTMLDivElement, annotation: Annotation): void;
-    onCameraModified: (evt: any) => void;
+    onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
     filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     updateViewportImage(viewport: Types.IStackViewport | Types.IVolumeViewport): void;

package/dist/esm/tools/ReferenceLinesTool.d.ts

@@ -1,14 +1,12 @@
 import { type Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
-import { ReferenceLineAnnotation } from '../types/ToolSpecificAnnotationTypes';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { ReferenceLineAnnotation } from '../types/ToolSpecificAnnotationTypes';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 declare class ReferenceLines extends AnnotationDisplayTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        renderingEngine: any;
+        renderingEngine: Types.IRenderingEngine;
         sourceViewportId: string;
         annotation: ReferenceLineAnnotation;
     } | null;

package/dist/esm/tools/ReferenceLinesTool.js

@@ -16,7 +16,7 @@ class ReferenceLines extends AnnotationDisplayTool {
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.editData = {};
+        this.editData = null;
         this._init = () => {
             const renderingEngines = getRenderingEngines();
             const renderingEngine = renderingEngines[0];

package/dist/esm/tools/ScaleOverlayTool.d.ts

@@ -1,15 +1,13 @@
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
-import { ScaleOverlayAnnotation } from '../types/ToolSpecificAnnotationTypes';
+import type { ScaleOverlayAnnotation } from '../types/ToolSpecificAnnotationTypes';
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 declare class ScaleOverlayTool extends AnnotationDisplayTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        renderingEngine: any;
-        viewport: any;
+        renderingEngine: Types.IRenderingEngine;
+        viewport: Types.IViewport;
         annotation: ScaleOverlayAnnotation;
     } | null;
     isDrawing: boolean;
@@ -20,12 +18,12 @@ declare class ScaleOverlayTool extends AnnotationDisplayTool {
     onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;
     _getTextLines(scaleSize: number): string[] | undefined;
-    computeScaleSize: (worldWidthViewport: number, worldHeightViewport: number, location: any) => any;
+    computeScaleSize: (worldWidthViewport: number, worldHeightViewport: number, location: string) => any;
     computeEndScaleTicks: (canvasCoordinates: any, location: any) => {
         endTick1: any[][];
         endTick2: any[][];
     };
-    computeInnerScaleTicks: (scaleSize: number, location: string, annotationUID: string, leftTick: any[][], rightTick: any[][]) => {
+    computeInnerScaleTicks: (scaleSize: number, location: string, annotationUID: string, leftTick: Types.Point2[], rightTick: Types.Point2[]) => {
         tickIds: any[];
         tickUIDs: any[];
         tickCoordinates: any[];

package/dist/esm/tools/ScaleOverlayTool.js

@@ -4,7 +4,6 @@ import { getEnabledElementByIds, getRenderingEngines, utilities as csUtils, } fr
 import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
 import { drawLine as drawLineSvg, drawTextBox as drawTextBoxSvg, } from '../drawingSvg';
 import { getToolGroup } from '../store/ToolGroupManager';
-const SCALEOVERLAYTOOL_ID = 'scaleoverlay-viewport';
 const viewportsWithAnnotations = [];
 class ScaleOverlayTool extends AnnotationDisplayTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -14,7 +13,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.editData = {};
+        this.editData = null;
         this._init = () => {
             const renderingEngines = getRenderingEngines();
             const renderingEngine = renderingEngines[0];

package/dist/esm/tools/SculptorTool/CircleSculptCursor.d.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
-import { ISculptToolShape } from '../../types/ISculptToolShape';
-import { SculptData } from '../SculptorTool';
-import { SVGDrawingHelper, EventTypes, ContourAnnotationData } from '../../types';
+import type { ISculptToolShape } from '../../types/ISculptToolShape';
+import type { SculptData } from '../SculptorTool';
+import type { SVGDrawingHelper, EventTypes, ContourAnnotationData } from '../../types';
 export type PushedHandles = {
     first?: number;
     last?: number;
@@ -9,7 +9,7 @@ export type PushedHandles = {
 declare class CircleSculptCursor implements ISculptToolShape {
     static shapeName: string;
     private toolInfo;
-    renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: any): void;
+    renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: unknown): void;
     pushHandles(viewport: Types.IViewport, sculptData: SculptData): PushedHandles;
     configureToolSize(evt: EventTypes.InteractionEventType): void;
     updateToolSize(canvasCoords: Types.Point2, viewport: Types.IViewport, activeAnnotation: ContourAnnotationData): void;

package/dist/esm/tools/SculptorTool.d.ts

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from './base';
-import { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 import type { ISculptToolShape } from '../types/ISculptToolShape';
 export type SculptData = {
     mousePoint: Types.Point3;

package/dist/esm/tools/SculptorTool.js

@@ -3,13 +3,13 @@ import { BaseTool } from './base';
 import { getAnnotations } from '../stateManagement';
 import { point } from '../utilities/math';
 import { Events, ToolModes, AnnotationStyleStates } from '../enums';
-import { ToolGroupManager } from '../store';
 import { triggerAnnotationRenderForViewportIds } from '../utilities/triggerAnnotationRenderForViewportIds';
 import { hideElementCursor, resetElementCursor, } from '../cursors/elementCursor';
 import { getStyleProperty } from '../stateManagement/annotation/config/helpers';
 import { triggerAnnotationModified } from '../stateManagement/annotation/helpers/state';
 import CircleSculptCursor from './SculptorTool/CircleSculptCursor';
 import { distancePointToContour } from './distancePointToContour';
+import { getToolGroupForViewport } from '../store/ToolGroupManager';
 class SculptorTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -63,7 +63,7 @@ class SculptorTool extends BaseTool {
             this.deactivateModify(element);
             resetElementCursor(element);
             const { renderingEngineId, viewportId } = enabledElement;
-            const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+            const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
             const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
             const annotations = this.filterSculptableAnnotationsForElement(element);
             const activeAnnotation = annotations.find((annotation) => annotation.annotationUID === this.commonData.activeAnnotationUID);
@@ -148,7 +148,7 @@ class SculptorTool extends BaseTool {
         const enabledElement = getEnabledElement(element);
         const { renderingEngineId, viewportId } = enabledElement;
         const sculptableAnnotations = [];
-        const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+        const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
         const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
         config.referencedToolNames.forEach((referencedToolName) => {
             const annotations = getAnnotations(referencedToolName, element);

package/dist/esm/tools/SegmentationIntersectionTool.d.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
-import { Annotation } from '../types';
+import type { Annotation } from '../types';
 export interface SegmentationIntersectionAnnotation extends Annotation {
     data: {
         actorsWorldPointsMap: Map<string, Map<string, object>>;

package/dist/esm/tools/StackScrollTool.d.ts

@@ -1,9 +1,10 @@
 import { BaseTool } from './base';
-import { PublicToolProps, ToolProps, EventTypes } from '../types';
+import type { PublicToolProps, ToolProps, EventTypes } from '../types';
 declare class StackScrollTool extends BaseTool {
     static toolName: any;
     deltaY: number;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseWheelCallback(evt: EventTypes.MouseWheelEventType): void;
     mouseDragCallback(evt: EventTypes.InteractionEventType): void;
     touchDragCallback(evt: EventTypes.InteractionEventType): void;
     _dragCallback(evt: EventTypes.InteractionEventType): void;

package/dist/esm/tools/StackScrollTool.js

@@ -1,4 +1,4 @@
-import { getEnabledElementByIds, VolumeViewport } from '@cornerstonejs/core';
+import { getEnabledElementByIds, getEnabledElement, VolumeViewport, } from '@cornerstonejs/core';
 import { BaseTool } from './base';
 import { scroll } from '../utilities';
 class StackScrollTool extends BaseTool {
@@ -13,6 +13,21 @@ class StackScrollTool extends BaseTool {
         super(toolProps, defaultToolProps);
         this.deltaY = 1;
     }
+    mouseWheelCallback(evt) {
+        const { wheel, element } = evt.detail;
+        const { direction } = wheel;
+        const { invert } = this.configuration;
+        const { viewport } = getEnabledElement(element);
+        const delta = direction * (invert ? -1 : 1);
+        const volumeId = this.getTargetVolumeId(viewport);
+        scroll(viewport, {
+            delta,
+            debounceLoading: this.configuration.debounceIfNotLoaded,
+            loop: this.configuration.loop,
+            volumeId,
+            scrollSlabs: this.configuration.scrollSlabs,
+        });
+    }
     mouseDragCallback(evt) {
         this._dragCallback(evt);
     }
@@ -22,12 +37,11 @@ class StackScrollTool extends BaseTool {
     _dragCallback(evt) {
         const { deltaPoints, viewportId, renderingEngineId } = evt.detail;
         const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-        const targetId = this.getTargetId(viewport);
         const { debounceIfNotLoaded, invert, loop } = this.configuration;
         const deltaPointY = deltaPoints.canvas[1];
         let volumeId;
         if (viewport instanceof VolumeViewport) {
-            volumeId = targetId.split(/volumeId:|\?/)[1];
+            volumeId = this.getTargetVolumeId(viewport);
         }
         const pixelsPerImage = this._getPixelPerImage(viewport);
         const deltaY = deltaPointY + this.deltaY;

package/dist/esm/tools/StackScrollToolMouseWheelTool.d.ts

@@ -1,8 +1,7 @@
 import { BaseTool } from './base';
-import { MouseWheelEventType } from '../types/EventTypes';
+import type { MouseWheelEventType } from '../types/EventTypes';
 declare class StackScrollMouseWheelTool extends BaseTool {
     static toolName: any;
-    _configuration: any;
     constructor(toolProps?: {}, defaultToolProps?: {
         supportedInteractionTypes: string[];
         configuration: {

package/dist/esm/tools/StackScrollToolMouseWheelTool.js

@@ -19,8 +19,7 @@ class StackScrollMouseWheelTool extends BaseTool {
         const { invert } = this.configuration;
         const { viewport } = getEnabledElement(element);
         const delta = direction * (invert ? -1 : 1);
-        const targetId = this.getTargetId(viewport);
-        const volumeId = utilities.getVolumeId(targetId);
+        const volumeId = this.getTargetVolumeId(viewport);
         scroll(viewport, {
             delta,
             debounceLoading: this.configuration.debounceIfNotLoaded,

package/dist/esm/tools/TrackballRotateTool.d.ts

@@ -1,4 +1,4 @@
-import { EventTypes, PublicToolProps, ToolProps } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
 import { BaseTool } from './base';
 declare class TrackballRotateTool extends BaseTool {
     static toolName: any;

package/dist/esm/tools/TrackballRotateTool.js

@@ -22,6 +22,10 @@ class TrackballRotateTool extends BaseTool {
             const actorEntry = viewport.getDefaultActor();
             const actor = actorEntry.actor;
             const mapper = actor.getMapper();
+            const hasSampleDistance = 'getSampleDistance' in mapper || 'getCurrentSampleDistance' in mapper;
+            if (!hasSampleDistance) {
+                return true;
+            }
             const originalSampleDistance = mapper.getSampleDistance();
             if (!this._hasResolutionChanged) {
                 mapper.setSampleDistance(originalSampleDistance * 2);

package/dist/esm/tools/VolumeRotateMouseWheelTool.d.ts

@@ -1,9 +1,8 @@
 import { BaseTool } from './base';
-import { PublicToolProps, ToolProps } from '../types';
-import { MouseWheelEventType } from '../types/EventTypes';
+import type { PublicToolProps, ToolProps } from '../types';
+import type { MouseWheelEventType } from '../types/EventTypes';
 declare class VolumeRotateMouseWheelTool extends BaseTool {
     static toolName: any;
-    _configuration: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     mouseWheelCallback(evt: MouseWheelEventType): void;
 }

package/dist/esm/tools/WindowLevelRegionTool.d.ts

@@ -1,15 +1,15 @@
 import { AnnotationTool } from './base';
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, ToolProps, PublicToolProps, SVGDrawingHelper } from '../types';
+import type { EventTypes, ToolProps, PublicToolProps, SVGDrawingHelper, Annotation } from '../types';
 declare class WindowLevelRegionTool extends AnnotationTool {
     static toolName: any;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
     } | null;
     isDrawing: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    addNewAnnotation: (evt: EventTypes.InteractionEventType) => any;
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => Annotation;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
     _activateDraw: (element: any) => void;

package/dist/esm/tools/WindowLevelRegionTool.js

@@ -3,7 +3,7 @@ import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../stateManagement';
 import { triggerAnnotationCompleted } from '../stateManagement/annotation/helpers/state';
 import { drawRect as drawRectSvg } from '../drawingSvg';
-import { state } from '../store';
+import { state } from '../store/state';
 import { Events } from '../enums';
 import { getViewportIdsWithToolToRender } from '../utilities/viewportFilters';
 import { resetElementCursor, hideElementCursor, } from '../cursors/elementCursor';
@@ -23,7 +23,7 @@ class WindowLevelRegionTool extends AnnotationTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
@@ -69,7 +69,6 @@ class WindowLevelRegionTool extends AnnotationTool {
             const { annotation, viewportIdsToRender } = this.editData;
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const { renderingEngine } = getEnabledElement(element);
             this.editData = null;
             this.isDrawing = false;
             removeAnnotation(annotation.annotationUID);
@@ -105,7 +104,6 @@ class WindowLevelRegionTool extends AnnotationTool {
             points[1] = bottomRightWorld;
             points[2] = topLeftWorld;
             annotation.invalidated = true;
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._activateDraw = (element) => {

package/dist/esm/tools/WindowLevelTool.d.ts

@@ -1,5 +1,5 @@
 import { BaseTool } from './base';
-import { EventTypes } from '../types';
+import type { EventTypes } from '../types';
 declare class WindowLevelTool extends BaseTool {
     static toolName: any;
     constructor(toolProps?: {}, defaultToolProps?: {