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

package/dist/esm/store/SynchronizerManager/Synchronizer.d.ts

@@ -1,5 +1,9 @@
-import { Types } from '@cornerstonejs/core';
-import { ISynchronizerEventHandler } from '../../types';
+import type { Types } from '@cornerstonejs/core';
+import type { ISynchronizerEventHandler } from '../../types';
+export type SynchronizerOptions = {
+    auxiliaryEventNames?: string[];
+    viewPresentation?: Types.ViewPresentation;
+};
 declare class Synchronizer {
     private _enabled;
     private _eventName;
@@ -11,7 +15,7 @@ declare class Synchronizer {
     private _viewportOptions;
     private _options;
     id: string;
-    constructor(synchronizerId: string, eventName: string, eventHandler: ISynchronizerEventHandler, options?: any);
+    constructor(synchronizerId: string, eventName: string, eventHandler: ISynchronizerEventHandler, options?: SynchronizerOptions);
     isDisabled(): boolean;
     setOptions(viewportId: string, options?: Record<string, unknown>): void;
     setEnabled(enabled: boolean): void;

package/dist/esm/store/SynchronizerManager/Synchronizer.js

@@ -9,7 +9,8 @@ class Synchronizer {
             if (!this._targetViewports.length) {
                 return;
             }
-            const enabledElement = getEnabledElement(evt.currentTarget);
+            const currentTarget = evt.currentTarget;
+            const enabledElement = getEnabledElement(currentTarget);
             if (!enabledElement) {
                 return;
             }

package/dist/esm/store/SynchronizerManager/createSynchronizer.d.ts

@@ -1,4 +1,4 @@
-import Synchronizer from './Synchronizer';
-import { ISynchronizerEventHandler } from '../../types';
-declare function createSynchronizer(synchronizerId: string, eventName: string, eventHandler: ISynchronizerEventHandler, options?: any): Synchronizer;
+import Synchronizer, { type SynchronizerOptions } from './Synchronizer';
+import type { ISynchronizerEventHandler } from '../../types';
+declare function createSynchronizer(synchronizerId: string, eventName: string, eventHandler: ISynchronizerEventHandler, options?: SynchronizerOptions): Synchronizer;
 export default createSynchronizer;

package/dist/esm/store/SynchronizerManager/createSynchronizer.js

@@ -1,5 +1,5 @@
 import { state } from '../index';
-import Synchronizer from './Synchronizer';
+import Synchronizer, {} from './Synchronizer';
 function createSynchronizer(synchronizerId, eventName, eventHandler, options) {
     const synchronizerWithSameIdExists = state.synchronizers.some((sync) => sync.id === synchronizerId);
     if (synchronizerWithSameIdExists) {

package/dist/esm/store/SynchronizerManager/getAllSynchronizers.d.ts

@@ -1,3 +1,3 @@
-import Synchronizer from './Synchronizer';
+import type Synchronizer from './Synchronizer';
 declare function getAllSynchronizers(): Array<Synchronizer>;
 export default getAllSynchronizers;

package/dist/esm/store/SynchronizerManager/getSynchronizer.d.ts

@@ -1,3 +1,3 @@
-import Synchronizer from './Synchronizer';
+import type Synchronizer from './Synchronizer';
 declare function getSynchronizer(synchronizerId: string): Synchronizer | void;
 export default getSynchronizer;

package/dist/esm/store/SynchronizerManager/getSynchronizersForViewport.d.ts

@@ -1,3 +1,3 @@
-import Synchronizer from './Synchronizer';
+import type Synchronizer from './Synchronizer';
 declare function getSynchronizersForViewport(viewportId: string, renderingEngineId: string): Array<Synchronizer>;
 export default getSynchronizersForViewport;

package/dist/esm/store/ToolGroupManager/ToolGroup.d.ts

@@ -1,6 +1,6 @@
 import { MouseBindings, ToolModes } from '../../enums';
 import type { Types } from '@cornerstonejs/core';
-import { IToolBinding, IToolGroup, SetToolBindingsType, ToolOptionsType, ToolConfiguration } from '../../types';
+import type { IToolBinding, IToolGroup, SetToolBindingsType, ToolOptionsType, ToolConfiguration } from '../../types';
 import { MouseCursor } from '../../cursors';
 export default class ToolGroup implements IToolGroup {
     id: string;
@@ -14,7 +14,7 @@ export default class ToolGroup implements IToolGroup {
     getViewportIds(): string[];
     getViewportsInfo(): Array<Types.IViewportId>;
     getToolInstance(toolInstanceName: string): any;
-    getToolInstances(): Record<string, any>;
+    getToolInstances(): Record<string, unknown>;
     hasTool(toolName: string): boolean;
     addTool(toolName: string, configuration?: ToolConfiguration): void;
     addToolInstance(toolName: string, parentClassName: string, configuration?: {}): void;
@@ -36,7 +36,7 @@ export default class ToolGroup implements IToolGroup {
     setToolConfiguration(toolName: string, configuration: ToolConfiguration, overwrite?: boolean): boolean;
     getDefaultMousePrimary(): MouseBindings;
     getDefaultPrimaryBindings(): IToolBinding[];
-    getToolConfiguration(toolName: string, configurationPath?: string): any;
+    getToolConfiguration(toolName: string, configurationPath?: string): unknown;
     getPrevActivePrimaryToolName(): string;
     setActivePrimaryTool(toolName: string): void;
     getCurrentActivePrimaryToolName(): string;

package/dist/esm/store/ToolGroupManager/ToolGroup.js

@@ -83,8 +83,11 @@ export default class ToolGroup {
             throw new Error('viewportId must be defined and be a string');
         }
         const renderingEngines = getRenderingEngines();
-        if (!renderingEngineId && renderingEngines.length > 1) {
-            throw new Error('You must specify a renderingEngineId when there are multiple rendering engines.');
+        if (renderingEngines?.length === 0) {
+            throw new Error('No rendering engines found.');
+        }
+        if (renderingEngines.length > 1) {
+            throw new Error('Multiple rendering engines found. You must specify a renderingEngineId.');
         }
         const renderingEngineUIDToUse = renderingEngineId || renderingEngines[0].id;
         if (!this.viewportsInfo.some(({ viewportId: vpId }) => vpId === viewportId)) {

package/dist/esm/store/ToolGroupManager/createToolGroup.d.ts

@@ -1,3 +1,3 @@
-import { IToolGroup } from '../../types';
+import type { IToolGroup } from '../../types';
 declare function createToolGroup(toolGroupId: string): IToolGroup | undefined;
 export default createToolGroup;

package/dist/esm/store/ToolGroupManager/destroyToolGroup.js

@@ -1,4 +1,5 @@
 import { state } from '../index';
+import { removeSegmentationRepresentations } from '../../stateManagement/segmentation';
 function destroyToolGroup(toolGroupId) {
     const toolGroupIndex = state.toolGroups.findIndex((tg) => tg.id === toolGroupId);
     if (toolGroupIndex > -1) {

package/dist/esm/store/ToolGroupManager/getAllToolGroups.d.ts

@@ -1,3 +1,3 @@
-import { IToolGroup } from '../../types';
+import type { IToolGroup } from '../../types';
 declare function getAllToolGroups(): Array<IToolGroup>;
 export default getAllToolGroups;

package/dist/esm/store/ToolGroupManager/getToolGroup.d.ts

@@ -1,3 +1,3 @@
-import { IToolGroup } from '../../types';
+import type { IToolGroup } from '../../types';
 declare function getToolGroup(toolGroupId: string): IToolGroup | undefined;
 export default getToolGroup;

package/dist/esm/store/ToolGroupManager/getToolGroupForViewport.d.ts

@@ -1,3 +1,3 @@
-import { IToolGroup } from '../../types';
+import type { IToolGroup } from '../../types';
 declare function getToolGroupForViewport(viewportId: string, renderingEngineId?: string): IToolGroup | undefined;
 export default getToolGroupForViewport;

package/dist/esm/store/ToolGroupManager/getToolGroupsWithToolName.d.ts

@@ -1,3 +1,3 @@
-import { IToolGroup } from '../../types';
+import type { IToolGroup } from '../../types';
 declare function getToolGroupsWithToolName(toolName: string): IToolGroup[] | [];
 export default getToolGroupsWithToolName;

package/dist/esm/store/addEnabledElement.d.ts

@@ -1,2 +1,2 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export default function addEnabledElement(evt: Types.EventTypes.ElementEnabledEvent): void;

package/dist/esm/store/addEnabledElement.js

@@ -1,7 +1,7 @@
 import { mouseEventListeners, wheelEventListener, touchEventListeners, keyEventListener, imageChangeEventListener, } from '../eventListeners';
 import { imageRenderedEventDispatcher, cameraModifiedEventDispatcher, mouseToolEventDispatcher, touchToolEventDispatcher, keyboardToolEventDispatcher, imageSpacingCalibratedEventDispatcher, cameraResetEventDispatcher, } from '../eventDispatchers';
 import { state } from './state';
-import { annotationRenderingEngine } from '../utilities/triggerAnnotationRender';
+import { annotationRenderingEngine } from '../stateManagement/annotation/AnnotationRenderingEngine';
 export default function addEnabledElement(evt) {
     const { element, viewportId } = evt.detail;
     const svgLayer = _createSvgAnnotationLayer(viewportId);

package/dist/esm/store/addTool.js

@@ -5,9 +5,6 @@ export function addTool(ToolClass) {
     if (!toolName) {
         throw new Error(`No Tool Found for the ToolClass ${ToolClass.name}`);
     }
-    if (toolAlreadyAdded) {
-        throw new Error(`${toolName} has already been added globally`);
-    }
     state.tools[toolName] = {
         toolClass: ToolClass,
     };

package/dist/esm/store/filterMoveableAnnotationTools.d.ts

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-import { ToolAnnotationPair, ToolAnnotationsPair } from '../types/InternalToolTypes';
+import type { ToolAnnotationPair, ToolAnnotationsPair } from '../types/InternalToolTypes';
 export default function filterMoveableAnnotationTools(element: HTMLDivElement, ToolAndAnnotations: ToolAnnotationsPair[], canvasCoords: Types.Point2, interactionType?: string): ToolAnnotationPair[];

package/dist/esm/store/filterToolsWithAnnotationsForElement.d.ts

@@ -1,3 +1,3 @@
-import { ToolAnnotationsPair } from '../types/InternalToolTypes';
+import type { ToolAnnotationsPair } from '../types/InternalToolTypes';
 import type AnnotationTool from '../tools/base/AnnotationTool';
 export default function filterToolsWithAnnotationsForElement(element: HTMLDivElement, tools: AnnotationTool[]): ToolAnnotationsPair[];

package/dist/esm/store/filterToolsWithMoveableHandles.d.ts

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-import { ToolAnnotationsPair, ToolsWithMoveableHandles } from '../types/InternalToolTypes';
+import type { ToolAnnotationsPair, ToolsWithMoveableHandles } from '../types/InternalToolTypes';
 export default function filterToolsWithMoveableHandles(element: HTMLDivElement, ToolAndAnnotations: ToolAnnotationsPair[], canvasCoords: Types.Point2, interactionType?: string): ToolsWithMoveableHandles[];

package/dist/esm/store/removeEnabledElement.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare function removeEnabledElement(elementDisabledEvt: Types.EventTypes.ElementDisabledEvent): void;
 export default removeEnabledElement;

package/dist/esm/store/removeEnabledElement.js

@@ -8,7 +8,7 @@ import { ToolModes } from '../enums';
 import { removeAnnotation } from '../stateManagement';
 import getSynchronizersForViewport from './SynchronizerManager/getSynchronizersForViewport';
 import getToolGroupForViewport from './ToolGroupManager/getToolGroupForViewport';
-import { annotationRenderingEngine } from '../utilities/triggerAnnotationRender';
+import { annotationRenderingEngine } from '../stateManagement/annotation/AnnotationRenderingEngine';
 const VIEWPORT_ELEMENT = 'viewport-element';
 function removeEnabledElement(elementDisabledEvt) {
     const { element, viewportId } = elementDisabledEvt.detail;

package/dist/esm/store/state.d.ts

@@ -1,5 +1,5 @@
-import { IToolGroup, IToolClassReference } from '../types';
-import Synchronizer from './SynchronizerManager/Synchronizer';
+import type { IToolGroup, IToolClassReference } from '../types';
+import type Synchronizer from './SynchronizerManager/Synchronizer';
 interface ICornerstoneTools3dState {
     isInteractingWithTool: boolean;
     isMultiPartToolActive: boolean;
@@ -14,4 +14,5 @@ interface ICornerstoneTools3dState {
 }
 declare let state: ICornerstoneTools3dState;
 declare function resetCornerstoneToolsState(): void;
-export { ICornerstoneTools3dState, resetCornerstoneToolsState, state, state as default, };
+export type { ICornerstoneTools3dState };
+export { resetCornerstoneToolsState, state, state as default };

package/dist/esm/store/state.js

@@ -31,4 +31,4 @@ function resetCornerstoneToolsState() {
         },
     };
 }
-export { resetCornerstoneToolsState, state, state as default, };
+export { resetCornerstoneToolsState, state, state as default };

package/dist/esm/synchronizers/callbacks/areViewportsCoplanar .d.ts

@@ -1,2 +1,2 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export default function areViewportsCoplanar(viewport1: Types.IStackViewport | Types.IVolumeViewport, viewport2: Types.IStackViewport | Types.IVolumeViewport): boolean;

package/dist/esm/synchronizers/callbacks/cameraSyncCallback.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
-import { Synchronizer } from '../../store';
+import type { Types } from '@cornerstonejs/core';
+import type { Synchronizer } from '../../store';
 export default function cameraSyncCallback(synchronizerInstance: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, cameraModifiedEvent: CustomEvent): void;

package/dist/esm/synchronizers/callbacks/imageSliceSyncCallback.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
-import { Synchronizer } from '../../store';
+import type { Types } from '@cornerstonejs/core';
+import type { Synchronizer } from '../../store';
 export default function imageSliceSyncCallback(synchronizerInstance: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId): Promise<void>;

package/dist/esm/synchronizers/callbacks/presentationViewSyncCallback.d.ts

@@ -1,2 +1,2 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export default function presentationViewSyncCallback(_synchronizerInstance: any, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, _sourceEvent: any, options?: Types.ViewPresentationSelector): void;

package/dist/esm/synchronizers/callbacks/slabThicknessSyncCallback.d.ts

@@ -1,2 +1,2 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export default function slabThicknessSyncCallback(_synchronizerInstance: any, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId): void;

package/dist/esm/synchronizers/callbacks/voiSyncCallback.d.ts

@@ -1,2 +1,5 @@
-import { Types } from '@cornerstonejs/core';
-export default function voiSyncCallback(synchronizerInstance: any, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, modifiedEvent: any, options?: any): void;
+import type { Types } from '@cornerstonejs/core';
+export default function voiSyncCallback(synchronizerInstance: any, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, modifiedEvent: Types.EventTypes.VoiModifiedEvent, options?: {
+    syncInvertState?: boolean;
+    syncColormap?: boolean;
+}): void;

package/dist/esm/synchronizers/callbacks/zoomPanSyncCallback.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
-import { Synchronizer } from '../../store';
+import type { Types } from '@cornerstonejs/core';
+import type { Synchronizer } from '../../store';
 export default function zoomPanSyncCallback(synchronizerInstance: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId): void;

package/dist/esm/synchronizers/synchronizers/createCameraPositionSynchronizer.d.ts

@@ -1,2 +1,2 @@
-import Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
 export default function createCameraPositionSynchronizer(synchronizerName: string): Synchronizer;

package/dist/esm/synchronizers/synchronizers/createImageSliceSynchronizer.d.ts

@@ -1,2 +1,2 @@
-import Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
 export default function createImageSliceSynchronizer(synchronizerName: string): Synchronizer;

package/dist/esm/synchronizers/synchronizers/createPresentationViewSynchronizer.d.ts

@@ -1,3 +1,3 @@
-import type { Types } from '@cornerstonejs/core';
-import Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+import { type Types } from '@cornerstonejs/core';
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
 export default function createPresentationViewSynchronizer(synchronizerName: string, options?: Types.ViewPresentation): Synchronizer;

package/dist/esm/synchronizers/synchronizers/createPresentationViewSynchronizer.js

@@ -3,6 +3,6 @@ import { createSynchronizer } from '../../store/SynchronizerManager';
 import presentationViewSyncCallback from '../callbacks/presentationViewSyncCallback';
 const { CAMERA_MODIFIED } = Enums.Events;
 export default function createPresentationViewSynchronizer(synchronizerName, options) {
-    const presentationView = createSynchronizer(synchronizerName, CAMERA_MODIFIED, presentationViewSyncCallback, options);
+    const presentationView = createSynchronizer(synchronizerName, CAMERA_MODIFIED, presentationViewSyncCallback, { viewPresentation: options });
     return presentationView;
 }

package/dist/esm/synchronizers/synchronizers/createSlabThicknessSynchronizer.d.ts

@@ -1,2 +1,2 @@
-import Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
 export default function createPresentationViewSynchronizer(synchronizerName: string): Synchronizer;

package/dist/esm/synchronizers/synchronizers/createVOISynchronizer.d.ts

@@ -1,4 +1,4 @@
-import Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
 type VOISynchronizerOptions = {
     syncInvertState: boolean;
     syncColormap: boolean;

package/dist/esm/synchronizers/synchronizers/createZoomPanSynchronizer.d.ts

@@ -1,2 +1,2 @@
-import Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
 export default function createZoomPanSynchronizer(synchronizerName: string): Synchronizer;

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

@@ -1,7 +1,7 @@
 import { AnnotationTool } from './base';
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
-import { AdvancedMagnifyAnnotation } from '../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
+import type { AdvancedMagnifyAnnotation } from '../types/ToolSpecificAnnotationTypes';
 import AdvancedMagnifyViewportManager from './AdvancedMagnifyViewportManager';
 declare enum AdvancedMagnifyToolActions {
     ShowZoomFactorsList = "showZoomFactorsList"
@@ -10,10 +10,8 @@ declare class AdvancedMagnifyTool extends AnnotationTool {
     static toolName: any;
     static Actions: typeof AdvancedMagnifyToolActions;
     magnifyViewportManager: AdvancedMagnifyViewportManager;
-    touchDragCallback: any;
-    mouseDragCallback: any;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: Array<string>;
         handleIndex?: number;
         newAnnotation?: boolean;
@@ -30,7 +28,7 @@ declare class AdvancedMagnifyTool extends AnnotationTool {
     _dragDrawCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragModifyCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragHandle: (evt: EventTypes.InteractionEventType) => void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: any) => void;
     _deactivateModify: (element: any) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;

package/dist/esm/tools/AdvancedMagnifyViewport.js

@@ -151,7 +151,7 @@ class AdvancedMagnifyViewport {
         });
         magnifyToolGroup.addViewport(magnifyViewport.id, magnifyViewport.renderingEngineId);
         sourceActors.filter(isSegmentation).forEach((actor) => {
-            segmentation.addRepresentations(this.viewportId, [
+            segmentation.addSegmentationRepresentations(this.viewportId, [
                 {
                     segmentationId: actor.referencedId,
                     type: SegmentationRepresentations.Labelmap,

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

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
-import { AdvancedMagnifyViewport, AutoPanCallback } from './AdvancedMagnifyViewport';
-import { AdvancedMagnifyAnnotation } from '../types/ToolSpecificAnnotationTypes';
+import type { AutoPanCallback } from './AdvancedMagnifyViewport';
+import { AdvancedMagnifyViewport } from './AdvancedMagnifyViewport';
+import type { AdvancedMagnifyAnnotation } from '../types/ToolSpecificAnnotationTypes';
 export type MagnifyViewportInfo = {
     magnifyViewportId?: string;
     sourceEnabledElement: Types.IEnabledElement;

package/dist/esm/tools/AdvancedMagnifyViewportManager.js

@@ -1,7 +1,7 @@
 import { vec3 } from 'gl-matrix';
 import { eventTarget, Enums, getRenderingEngine, CONSTANTS, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { Events as cstEvents } from '../enums';
-import { AdvancedMagnifyViewport, } from './AdvancedMagnifyViewport';
+import { AdvancedMagnifyViewport } from './AdvancedMagnifyViewport';
 const ADVANCED_MAGNIFY_TOOL_NAME = 'AdvancedMagnify';
 const PARALLEL_THRESHOLD = 1 - CONSTANTS.EPSILON;
 const { Events } = Enums;

package/dist/esm/tools/AnnotationEraserTool.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 AnnotationEraserTool extends BaseTool {
     static toolName: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);

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

@@ -1,11 +1,11 @@
 import { AnnotationTool } from './base';
 import type { Types } from '@cornerstonejs/core';
-import { Annotation, Annotations, EventTypes, ToolHandle, PublicToolProps, ToolProps, InteractionTypes, SVGDrawingHelper } from '../types';
+import type { Annotation, Annotations, EventTypes, ToolHandle, PublicToolProps, ToolProps, InteractionTypes, SVGDrawingHelper } from '../types';
 interface CrosshairsAnnotation extends Annotation {
     data: {
         handles: {
-            rotationPoints: any[];
-            slabThicknessPoints: any[];
+            rotationPoints: Types.Point3[];
+            slabThicknessPoints: Types.Point3[];
             activeOperation: number | null;
             toolCenter: Types.Point3;
         };
@@ -21,7 +21,7 @@ declare class CrosshairsTool extends AnnotationTool {
     _getReferenceLineDraggableRotatable?: (viewportId: string) => boolean;
     _getReferenceLineSlabThicknessControlsOn?: (viewportId: string) => boolean;
     editData: {
-        annotation: any;
+        annotation: Annotation;
     } | null;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     initializeViewport: ({ renderingEngineId, viewportId, }: Types.IViewportId) => {
@@ -47,7 +47,7 @@ declare class CrosshairsTool extends AnnotationTool {
     filterInteractableAnnotationsForElement: (element: any, annotations: any) => any;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     _getAnnotations: (enabledElement: Types.IEnabledElement) => Annotation[];
-    _onNewVolume: (e: any) => void;
+    _onNewVolume: () => void;
     _unsubscribeToViewportNewVolumeSet(viewportsInfo: any): void;
     _subscribeToViewportNewVolumeSet(viewports: any): void;
     _autoPanViewportIfNecessary(viewportId: string, renderingEngine: Types.IRenderingEngine): void;

package/dist/esm/tools/CrosshairsTool.js

@@ -105,7 +105,8 @@ class CrosshairsTool extends AnnotationTool {
         };
         this.resetCrosshairs = () => {
             const viewportsInfo = this._getViewportsInfo();
-            viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+            for (const viewportInfo of viewportsInfo) {
+                const { viewportId, renderingEngineId } = viewportInfo;
                 const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
                 const viewport = enabledElement.viewport;
                 const resetPan = true;
@@ -128,7 +129,7 @@ class CrosshairsTool extends AnnotationTool {
                     removeAnnotation(annotations[0].annotationUID);
                 }
                 viewport.render();
-            });
+            }
             this.computeToolCenter(viewportsInfo);
         };
         this.computeToolCenter = (viewportsInfo) => {
@@ -672,7 +673,7 @@ class CrosshairsTool extends AnnotationTool {
             });
             return toolGroupAnnotations;
         };
-        this._onNewVolume = (e) => {
+        this._onNewVolume = () => {
             const viewportsInfo = this._getViewportsInfo();
             this.computeToolCenter(viewportsInfo);
         };

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

@@ -1,8 +1,7 @@
 import { BaseTool } from './base';
-import { PublicToolProps, ToolProps } from '../types';
+import type { PublicToolProps, ToolProps } from '../types';
 declare class MIPJumpToClickTool extends BaseTool {
     static toolName: any;
-    _bounds: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     mouseClickCallback(evt: any): void;
 }

package/dist/esm/tools/MIPJumpToClickTool.js

@@ -17,11 +17,10 @@ class MIPJumpToClickTool extends BaseTool {
         const { element, currentPoints } = evt.detail;
         const enabledElement = getEnabledElement(element);
         const { viewport, renderingEngine } = enabledElement;
-        const targetId = this.getTargetId(viewport);
-        if (!targetId.startsWith('volumeId')) {
+        const volumeId = this.getTargetVolumeId(viewport);
+        if (!volumeId) {
             throw new Error(`MIPJumpToClickTool: targetId is not a volumeId, you should only use MIPJumpToClickTool with a volumeId as the targetId`);
         }
-        const volumeId = utilities.getVolumeId(targetId);
         let maxIntensity = -Infinity;
         const maxFn = (intensity, point) => {
             if (intensity > maxIntensity) {

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

@@ -1,10 +1,9 @@
 import { BaseTool } from './base';
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, PublicToolProps, ToolProps } from '../types';
-import { IPoints } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
+import type { IPoints } from '../types';
 declare class MagnifyTool extends BaseTool {
     static toolName: any;
-    _bounds: any;
     editData: {
         referencedImageId: string;
         viewportIdsToRender: string[];

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;