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

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -83,7 +83,9 @@ export default class BrushStrategy {
         }
         const { imageVoxelManager, segmentationVoxelManager, segmentationImageData, } = data;
         const previewVoxelManager = operationData.preview?.previewVoxelManager ||
-            VoxelManager.createHistoryVoxelManager(segmentationVoxelManager);
+            VoxelManager.createHistoryVoxelManager({
+                sourceVoxelManager: segmentationVoxelManager,
+            });
         const previewEnabled = !!operationData.previewColors;
         const previewSegmentIndex = previewEnabled ? 255 : undefined;
         const initializedData = {

package/dist/esm/tools/segmentation/strategies/compositions/determineSegmentIndex.js

@@ -1,4 +1,3 @@
-import pointInShapeCallback from '../../../../utilities/pointInShapeCallback';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.Initialize]: (operationData) => {
@@ -12,7 +11,7 @@ export default {
         }
     },
     [StrategyCallbacks.OnInteractionStart]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager: segmentationVoxelManager, centerIJK, strategySpecificConfiguration, imageVoxelManager: imageVoxelManager, segmentationImageData, preview, } = operationData;
+        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, strategySpecificConfiguration, imageVoxelManager, segmentationImageData, preview, } = operationData;
         if (!strategySpecificConfiguration?.useCenterSegmentIndex) {
             return;
         }
@@ -23,7 +22,11 @@ export default {
             hasSegmentIndex ||= value === segmentIndex;
             hasPreviewIndex ||= value === previewSegmentIndex;
         };
-        pointInShapeCallback(segmentationImageData, imageVoxelManager.isInObject, callback, segmentationVoxelManager.boundsIJK);
+        imageVoxelManager.forEach(callback, {
+            imageData: segmentationImageData,
+            isInObject: imageVoxelManager.isInObject,
+            boundsIJK: segmentationVoxelManager.boundsIJK,
+        });
         if (!hasSegmentIndex && !hasPreviewIndex) {
             return;
         }

package/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.js

@@ -2,7 +2,7 @@ import { vec3 } from 'gl-matrix';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { operationName, centerIJK, strategySpecificConfiguration, segmentationVoxelManager: segmentationVoxelManager, imageVoxelManager: imageVoxelManager, segmentIndex, } = operationData;
+        const { operationName, centerIJK, strategySpecificConfiguration, segmentationVoxelManager, imageVoxelManager, segmentIndex, } = operationData;
         const { THRESHOLD } = strategySpecificConfiguration;
         if (!THRESHOLD?.isDynamic || !centerIJK || !segmentIndex) {
             return;

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js

@@ -3,7 +3,7 @@ import { triggerSegmentationDataModified } from '../../../../stateManagement/seg
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
-        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager: segmentationVoxelManager, strategySpecificConfiguration, previewSegmentIndex, segmentIndex, } = operationData;
+        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, strategySpecificConfiguration, previewSegmentIndex, segmentIndex, } = operationData;
         if (!strategySpecificConfiguration.THRESHOLD || segmentIndex === null) {
             return;
         }

package/dist/esm/tools/segmentation/strategies/compositions/preview.js

@@ -1,6 +1,6 @@
-import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { config as segmentationConfig } from '../../../../stateManagement/segmentation';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/events/triggerSegmentationDataModified';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { getSegmentIndexColor, setSegmentIndexColor, } from '../../../../stateManagement/segmentation/config/segmentationColor';
 function lightenColor(r, g, b, a, factor = 0.4) {
     return [
         Math.round(r + (255 - r) * factor),
@@ -42,15 +42,15 @@ export default {
             return;
         }
         const configColor = previewColors?.[segmentIndex];
-        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         if (!configColor && !segmentColor) {
             return;
         }
         const previewColor = configColor || lightenColor(...segmentColor);
-        segmentationConfig.color.setSegmentIndexColor(segmentationRepresentationUID, previewSegmentIndex, previewColor);
+        setSegmentIndexColor(segmentationRepresentationUID, previewSegmentIndex, previewColor);
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
-        const { segmentationVoxelManager: segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, preview, } = operationData || {};
+        const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, preview, } = operationData || {};
         if (previewSegmentIndex === undefined) {
             return;
         }
@@ -70,7 +70,7 @@ export default {
         tracking.clear();
     },
     [StrategyCallbacks.RejectPreview]: (operationData) => {
-        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager: segmentationVoxelManager, } = operationData;
+        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, } = operationData;
         if (previewVoxelManager.modifiedSlices.size === 0) {
             return;
         }

package/dist/esm/tools/segmentation/strategies/compositions/regionFill.js

@@ -1,8 +1,7 @@
-import pointInShapeCallback from '../../../../utilities/pointInShapeCallback';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.Fill]: (operationData) => {
-        const { segmentsLocked, segmentationImageData, segmentationVoxelManager: segmentationVoxelManager, previewVoxelManager: previewVoxelManager, imageVoxelManager: imageVoxelManager, brushStrategy, centerIJK, } = operationData;
+        const { segmentsLocked, segmentationImageData, segmentationVoxelManager, previewVoxelManager: previewVoxelManager, imageVoxelManager, brushStrategy, centerIJK, } = operationData;
         const isWithinThreshold = brushStrategy.createIsInThreshold?.(operationData);
         const { setValue } = brushStrategy;
         const callback = isWithinThreshold
@@ -14,7 +13,11 @@ export default {
                 setValue(operationData, data);
             }
             : (data) => setValue(operationData, data);
-        pointInShapeCallback(segmentationImageData, imageVoxelManager?.isInObject || segmentationVoxelManager.isInObject, callback, segmentationVoxelManager.boundsIJK);
+        imageVoxelManager.forEach(callback, {
+            imageData: segmentationImageData,
+            isInObject: imageVoxelManager?.isInObject || segmentationVoxelManager.isInObject,
+            boundsIJK: segmentationVoxelManager.boundsIJK,
+        });
         previewVoxelManager.addPoint(centerIJK);
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/setValue.js

@@ -1,7 +1,7 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, segmentIndex, previewVoxelManager: previewVoxelManager, previewSegmentIndex, segmentationVoxelManager: segmentationVoxelManager, } = operationData;
+        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, } = operationData;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
         if (segmentIndex === null) {
             const oldValue = previewVoxelManager.getAtIndex(index);

package/dist/esm/tools/segmentation/strategies/eraseRectangle.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { LabelmapToolOperationData } from '../../../types';
+import type { LabelmapToolOperationData } from '../../../types';
 type OperationData = LabelmapToolOperationData & {
     points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
 };

package/dist/esm/tools/segmentation/strategies/fillCircle.js

@@ -9,7 +9,7 @@ import { pointInSphere } from '../../../utilities/math/sphere';
 const { transformWorldToIndex, isEqual } = csUtils;
 const initializeCircle = {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { points, imageVoxelManager: imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager: segmentationVoxelManager, } = operationData;
+        const { points, imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager, } = operationData;
         if (!points) {
             return;
         }

package/dist/esm/tools/segmentation/strategies/fillRectangle.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { LabelmapToolOperationData } from '../../../types';
+import type { LabelmapToolOperationData } from '../../../types';
 type OperationData = LabelmapToolOperationData & {
     points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
 };

package/dist/esm/tools/segmentation/strategies/fillRectangle.js

@@ -1,11 +1,10 @@
 import { utilities as csUtils, StackViewport } from '@cornerstonejs/core';
 import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, } from '../../../utilities/boundingBox';
-import { pointInShapeCallback } from '../../../utilities';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { getStrategyData } from './utils/getStrategyData';
 import { isAxisAlignedRectangle } from '../../../utilities/rectangleROITool/isAxisAlignedRectangle';
 const { transformWorldToIndex } = csUtils;
-function fillRectangle(enabledElement, operationData, inside = true) {
+function fillRectangle(enabledElement, operationData) {
     const { points, segmentsLocked, segmentIndex, segmentationId } = operationData;
     const { viewport } = enabledElement;
     const strategyData = getStrategyData({
@@ -16,7 +15,7 @@ function fillRectangle(enabledElement, operationData, inside = true) {
         console.warn('No data found for fillRectangle');
         return;
     }
-    const { segmentationImageData, segmentationScalarData } = strategyData;
+    const { segmentationImageData, segmentationVoxelManager } = strategyData;
     let rectangleCornersIJK = points.map((world) => {
         return transformWorldToIndex(segmentationImageData, world);
     });
@@ -56,14 +55,18 @@ function fillRectangle(enabledElement, operationData, inside = true) {
         if (segmentsLocked.includes(value)) {
             return;
         }
-        segmentationScalarData[index] = segmentIndex;
+        segmentationVoxelManager.setAtIndex(index, segmentIndex);
     };
-    pointInShapeCallback(segmentationImageData, pointInShapeFn, callback, boundsIJK);
+    segmentationVoxelManager.forEach(callback, {
+        isInObject: pointInShapeFn,
+        boundsIJK,
+        imageData: segmentationImageData,
+    });
     triggerSegmentationDataModified(segmentationId);
 }
 export function fillInsideRectangle(enabledElement, operationData) {
-    fillRectangle(enabledElement, operationData, true);
+    fillRectangle(enabledElement, operationData);
 }
 export function fillOutsideRectangle(enabledElement, operationData) {
-    fillRectangle(enabledElement, operationData, false);
+    fillRectangle(enabledElement, operationData);
 }

package/dist/esm/tools/segmentation/strategies/fillSphere.js

@@ -8,7 +8,7 @@ const { transformWorldToIndex } = csUtils;
 import { getSphereBoundsInfo } from '../../../utilities/getSphereBoundsInfo';
 const sphereComposition = {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { points, imageVoxelManager: imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager: segmentationVoxelManager, } = operationData;
+        const { points, imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager, } = operationData;
         if (!points) {
             return;
         }

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.d.ts

@@ -4,8 +4,8 @@ declare function getStrategyData({ operationData, viewport }: {
 }): {
     segmentationImageData: any;
     segmentationScalarData: any;
-    segmentationVoxelManager: any;
     imageScalarData: any;
+    segmentationVoxelManager: any;
     imageVoxelManager: any;
 };
 export { getStrategyData };

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js

@@ -1,11 +1,8 @@
-import { cache, utilities } from '@cornerstonejs/core';
+import { cache } from '@cornerstonejs/core';
 import { isVolumeSegmentation } from './stackVolumeCheck';
-import { getLabelmapImageIdsForViewport } from '../../../../stateManagement/segmentation/segmentationState';
-const { VoxelManager } = utilities;
+import { getCurrentLabelmapImageIdForViewport } from '../../../../stateManagement/segmentation/segmentationState';
 function getStrategyData({ operationData, viewport }) {
     let segmentationImageData, segmentationScalarData, imageScalarData;
-    let imageDimensions;
-    let segmentationDimensions;
     let imageVoxelManager;
     let segmentationVoxelManager;
     if (isVolumeSegmentation(operationData, viewport)) {
@@ -17,16 +14,13 @@ function getStrategyData({ operationData, viewport }) {
         segmentationVoxelManager = segmentationVolume.voxelManager;
         if (referencedVolumeId) {
             const imageVolume = cache.getVolume(referencedVolumeId);
-            imageScalarData = imageVolume.getScalarData();
-            imageDimensions = imageVolume.dimensions;
+            imageVoxelManager = imageVolume.voxelManager;
         }
         ({ imageData: segmentationImageData } = segmentationVolume);
-        segmentationScalarData = segmentationVolume.getScalarData();
-        segmentationDimensions = segmentationVolume.dimensions;
     }
     else {
         const { segmentationRepresentationUID, segmentationId } = operationData;
-        const labelmapImageId = getLabelmapImageIdsForViewport(viewport.id, segmentationId);
+        const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
         if (!labelmapImageId) {
             return;
         }
@@ -38,8 +32,9 @@ function getStrategyData({ operationData, viewport }) {
         if (!actor) {
             return;
         }
+        const currentSegImage = cache.getImage(labelmapImageId);
         segmentationImageData = actor.actor.getMapper().getInputData();
-        segmentationVoxelManager = segmentationImageData.voxelManager;
+        segmentationVoxelManager = currentSegImage.voxelManager;
         const currentSegmentationImageId = operationData.imageId;
         const segmentationImage = cache.getImage(currentSegmentationImageId);
         if (!segmentationImage) {
@@ -49,25 +44,13 @@ function getStrategyData({ operationData, viewport }) {
         const image = cache.getImage(currentImageId);
         const imageData = image ? null : viewport.getImageData();
         imageScalarData = image?.getPixelData() || imageData.getScalarData();
-        imageDimensions = image
-            ? [image.columns, image.rows, 1]
-            : imageData.dimensions;
-        segmentationDimensions = [
-            segmentationImage.columns,
-            segmentationImage.rows,
-            1,
-        ];
         imageVoxelManager = image?.voxelManager;
     }
-    segmentationVoxelManager ||= VoxelManager.createVolumeVoxelManager(segmentationDimensions, segmentationScalarData);
-    imageVoxelManager ||=
-        imageDimensions &&
-            VoxelManager.createVolumeVoxelManager(imageDimensions, imageScalarData);
     return {
         segmentationImageData,
         segmentationScalarData,
-        segmentationVoxelManager,
         imageScalarData,
+        segmentationVoxelManager,
         imageVoxelManager,
     };
 }

package/dist/esm/tools/segmentation/strategies/utils/isWithinThreshold.d.ts

@@ -1,3 +1,10 @@
-import { Types } from '@cornerstonejs/core';
-declare function isWithinThreshold(index: number, imageScalarData: Types.PixelDataTypedArray, strategySpecificConfiguration: any): boolean;
+import type { Types } from '@cornerstonejs/core';
+declare function isWithinThreshold(index: number, imageScalarData: Types.PixelDataTypedArray, strategySpecificConfiguration: {
+    THRESHOLD?: {
+        threshold: number[];
+    };
+    THRESHOLD_INSIDE_CIRCLE?: {
+        threshold: number[];
+    };
+}): boolean;
 export default isWithinThreshold;

package/dist/esm/tools/segmentation/strategies/utils/stackVolumeCheck.d.ts

@@ -1,5 +1,5 @@
-import { LabelmapSegmentationData, LabelmapSegmentationDataVolume } from '../../../../types/LabelmapTypes';
-import { LabelmapToolOperationData, LabelmapToolOperationDataVolume } from '../../../../types';
-import { Types } from '@cornerstonejs/core';
+import type { LabelmapSegmentationData, LabelmapSegmentationDataVolume } from '../../../../types/LabelmapTypes';
+import type { LabelmapToolOperationData, LabelmapToolOperationDataVolume } from '../../../../types';
+import type { Types } from '@cornerstonejs/core';
 declare function isVolumeSegmentation(operationData: LabelmapToolOperationData | LabelmapSegmentationData, viewport?: Types.IViewport): operationData is LabelmapToolOperationDataVolume | LabelmapSegmentationDataVolume;
 export { isVolumeSegmentation };

package/dist/esm/tools/segmentation/strategies/utils/stackVolumeCheck.js

@@ -8,9 +8,6 @@ function isVolumeSegmentation(operationData, viewport) {
     if (imageIds && !volumeId) {
         return false;
     }
-    if (volumeId && imageIds && !viewport) {
-        throw new Error('isVolumeSegmentation: viewport is required when both volumeId and imageIds are provided');
-    }
     return viewport instanceof VolumeViewport;
 }
 export { isVolumeSegmentation };

package/dist/esm/types/AnnotationGroupSelector.d.ts

@@ -1,2 +1,2 @@
 type AnnotationGroupSelector = HTMLDivElement | string;
-export default AnnotationGroupSelector;
+export type { AnnotationGroupSelector as default };

package/dist/esm/types/AnnotationRenderContext.d.ts

@@ -1,11 +1,12 @@
 import type { Types } from '@cornerstonejs/core';
 import type { Annotation } from './AnnotationTypes';
 import type SVGDrawingHelper from './SVGDrawingHelper';
+import type { AnnotationStyle } from './AnnotationStyle';
 type AnnotationRenderContext = {
     enabledElement: Types.IEnabledElement;
     targetId: string;
     annotation: Annotation;
-    annotationStyle: Record<string, any>;
+    annotationStyle: AnnotationStyle;
     svgDrawingHelper: SVGDrawingHelper;
 };
-export default AnnotationRenderContext;
+export type { AnnotationRenderContext as default };

package/dist/esm/types/AnnotationStyle.d.ts

@@ -1,8 +1,8 @@
 type Modes = '' | 'Active' | 'Passive' | 'Enabled';
 type States = '' | 'Highlighted' | 'Selected' | 'Locked' | 'AutoGenerated';
-type Properties = 'color' | 'colorAutoGenerated' | 'lineWidth' | 'lineWidthAutoGenerated' | 'lineDash' | 'textBoxFontFamily' | 'textBoxFontSize' | 'textBoxColor' | 'textBoxBackground' | 'textBoxLinkLineWidth' | 'textBoxLinkLineDash';
+type Properties = 'color' | 'colorAutoGenerated' | 'lineWidth' | 'lineWidthAutoGenerated' | 'lineDash' | 'textBoxFontFamily' | 'textBoxFontSize' | 'textBoxColor' | 'textBoxBackground' | 'textBoxLinkLineWidth' | 'textBoxLinkLineDash' | 'locked' | 'fillColor' | 'fillOpacity' | 'textbox' | 'shadow' | 'visibility';
 export type AnnotationStyle = {
-    [key in `${Properties}${States}${Modes}`]?: string;
+    [key in `${Properties}${States}${Modes}`]?: string | number | boolean | Record<string, unknown>;
 };
 export type ToolStyleConfig = {
     [toolName: string]: AnnotationStyle;

package/dist/esm/types/AnnotationTypes.d.ts

@@ -27,9 +27,9 @@ type Annotation = {
                     bottomRight: Types.Point3;
                 };
             };
-            [key: string]: any;
+            [key: string]: unknown;
         };
-        [key: string]: any;
+        [key: string]: unknown;
         cachedStats?: unknown;
     };
 };
@@ -40,4 +40,4 @@ type GroupSpecificAnnotations = {
 type AnnotationState = {
     [key: string]: GroupSpecificAnnotations;
 };
-export { Annotation, Annotations, GroupSpecificAnnotations, AnnotationState };
+export type { Annotation, Annotations, GroupSpecificAnnotations, AnnotationState, };

package/dist/esm/types/BoundsIJK.d.ts

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
 type BoundsIJK = Types.BoundsIJK;
-export default BoundsIJK;
+export type { BoundsIJK as default };

package/dist/esm/types/CINETypes.d.ts

@@ -25,5 +25,6 @@ type CinePlayContext = {
     get frameTimeVectorEnabled(): boolean;
     waitForRenderedCount?: number;
     scroll(delta: number): void;
+    play?(fps?: number): number;
 };
 export type { PlayClipOptions, ToolData, CinePlayContext };

package/dist/esm/types/CalculatorTypes.d.ts

@@ -30,7 +30,7 @@ type NamedStatistics = {
     circumference?: Statistics & {
         name: 'circumference';
     };
-    pointsInShape?: Types.PointsManager<Types.Point3>;
+    pointsInShape?: Types.IPointsManager<Types.Point3>;
     array: Statistics[];
 };
 export type { Statistics, NamedStatistics };

package/dist/esm/types/CardinalSplineProps.d.ts

@@ -1,4 +1,4 @@
-import { SplineProps } from './SplineProps';
+import type { SplineProps } from './SplineProps';
 export type CardinalSplineProps = SplineProps & {
     scale?: number;
     fixedScale?: boolean;

package/dist/esm/types/ClosestPoint.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export type ClosestPoint = {
     point: Types.Point2;
     distance: number;

package/dist/esm/types/ContourAnnotation.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { Annotation } from './AnnotationTypes';
+import type { Annotation } from './AnnotationTypes';
 export declare enum ContourWindingDirection {
     CounterClockwise = -1,
     Unknown = 0,

package/dist/esm/types/ContourSegmentationAnnotation.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { ContourAnnotation } from './ContourAnnotation';
+import type { ContourAnnotation } from './ContourAnnotation';
 export type ContourSegmentationAnnotationData = {
     autoGenerated?: boolean;
     interpolationUID?: string;
@@ -17,7 +17,7 @@ export type ContourSegmentationAnnotationData = {
         originalToolName?: string;
     };
     handles?: {
-        interpolationSources?: Types.PointsManager<Types.Point3>[];
+        interpolationSources?: Types.IPointsManager<Types.Point3>[];
     };
     onInterpolationComplete?: (annotation: ContourSegmentationAnnotation) => unknown;
 };

package/dist/esm/types/ControlPointInfo.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export type ControlPointInfo = {
     index: number;
     point: Types.Point2;

package/dist/esm/types/EventTypes.d.ts

@@ -1,13 +1,13 @@
-import { Types } from '@cornerstonejs/core';
-import { Annotation } from './AnnotationTypes';
-import IPoints from './IPoints';
-import ITouchPoints from './ITouchPoints';
-import IDistance from './IDistance';
-import { SetToolBindingsType } from './ISetToolModeOptions';
-import { Swipe } from '../enums/Touch';
-import { ToolModes } from '../enums';
-import { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
-import { ChangeTypes } from '../enums';
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from './AnnotationTypes';
+import type IPoints from './IPoints';
+import type ITouchPoints from './ITouchPoints';
+import type IDistance from './IDistance';
+import type { SetToolBindingsType } from './ISetToolModeOptions';
+import type { Swipe } from '../enums/Touch';
+import type { ToolModes } from '../enums';
+import type { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
+import type { ChangeTypes } from '../enums';
 type NormalizedInteractionEventDetail = {
     eventName: string;
     renderingEngineId: string;
@@ -17,6 +17,7 @@ type NormalizedInteractionEventDetail = {
 };
 type MouseCustomEventDetail = NormalizedInteractionEventDetail & {
     event: Record<string, unknown> | MouseEvent;
+    buttons?: number;
 };
 type TouchCustomEventDetail = NormalizedInteractionEventDetail & {
     event: Record<string, unknown> | TouchEvent;
@@ -170,7 +171,7 @@ type TouchPressEventDetail = NormalizedInteractionEventDetail & TouchCustomEvent
     lastPoints: ITouchPoints;
 };
 type MouseWheelEventDetail = NormalizedInteractionEventDetail & MouseCustomEventDetail & {
-    detail: Record<string, any>;
+    detail: Record<string, unknown>;
     wheel: {
         spinX: number;
         spinY: number;
@@ -230,4 +231,4 @@ type MouseMoveEventType = Types.CustomEventType<MouseMoveEventDetail>;
 type MouseDoubleClickEventType = Types.CustomEventType<MouseDoubleClickEventDetail>;
 type MouseWheelEventType = Types.CustomEventType<MouseWheelEventDetail>;
 type VolumeScrollOutOfBoundsEventType = Types.CustomEventType<VolumeScrollOutOfBoundsEventDetail>;
-export { InteractionStartType, InteractionEndType, InteractionEventType, NormalizedInteractionEventDetail, NormalizedMouseEventType, NormalizedTouchEventType, ToolModeChangedEventDetail, ToolModeChangedEventType, ToolActivatedEventDetail, ToolActivatedEventType, AnnotationAddedEventDetail, AnnotationAddedEventType, AnnotationCompletedEventDetail, AnnotationCompletedEventType, AnnotationModifiedEventDetail, AnnotationModifiedEventType, AnnotationRemovedEventDetail, AnnotationRemovedEventType, AnnotationSelectionChangeEventDetail, AnnotationSelectionChangeEventType, AnnotationRenderedEventDetail, AnnotationRenderedEventType, AnnotationLockChangeEventDetail, AnnotationVisibilityChangeEventDetail, AnnotationLockChangeEventType, AnnotationVisibilityChangeEventType, AnnotationInterpolationCompletedEventDetail, AnnotationInterpolationCompletedEventType, AnnotationInterpolationRemovedEventDetail, AnnotationInterpolationRemovedEventType, ContourAnnotationCompletedEventDetail, SegmentationDataModifiedEventType, SegmentationRepresentationModifiedEventDetail, SegmentationRepresentationModifiedEventType, SegmentationRepresentationRemovedEventDetail, SegmentationRepresentationRemovedEventType, SegmentationRemovedEventType, SegmentationRemovedEventDetail, SegmentationDataModifiedEventDetail, SegmentationRenderedEventType, SegmentationRenderedEventDetail, SegmentationModifiedEventType, SegmentationModifiedEventDetail, KeyDownEventDetail, KeyDownEventType, KeyUpEventDetail, KeyUpEventType, MouseDownEventDetail, TouchStartEventDetail, MouseDownEventType, TouchStartEventType, MouseDownActivateEventDetail, TouchStartActivateEventDetail, MouseDownActivateEventType, TouchStartActivateEventType, MouseDragEventDetail, TouchDragEventDetail, MouseDragEventType, TouchDragEventType, MouseUpEventDetail, TouchEndEventDetail, MouseUpEventType, TouchEndEventType, MouseClickEventDetail, MouseClickEventType, TouchTapEventDetail, TouchTapEventType, TouchSwipeEventDetail, TouchSwipeEventType, TouchPressEventDetail, TouchPressEventType, MouseMoveEventDetail, MouseMoveEventType, MouseDoubleClickEventDetail, MouseDoubleClickEventType, MouseWheelEventDetail, MouseWheelEventType, VolumeScrollOutOfBoundsEventDetail, VolumeScrollOutOfBoundsEventType, };
+export type { InteractionStartType, InteractionEndType, InteractionEventType, NormalizedInteractionEventDetail, NormalizedMouseEventType, NormalizedTouchEventType, ToolModeChangedEventDetail, ToolModeChangedEventType, ToolActivatedEventDetail, ToolActivatedEventType, AnnotationAddedEventDetail, AnnotationAddedEventType, AnnotationCompletedEventDetail, AnnotationCompletedEventType, AnnotationModifiedEventDetail, AnnotationModifiedEventType, AnnotationRemovedEventDetail, AnnotationRemovedEventType, AnnotationSelectionChangeEventDetail, AnnotationSelectionChangeEventType, AnnotationRenderedEventDetail, AnnotationRenderedEventType, AnnotationLockChangeEventDetail, AnnotationVisibilityChangeEventDetail, AnnotationLockChangeEventType, AnnotationVisibilityChangeEventType, AnnotationInterpolationCompletedEventDetail, AnnotationInterpolationCompletedEventType, AnnotationInterpolationRemovedEventDetail, AnnotationInterpolationRemovedEventType, ContourAnnotationCompletedEventDetail, SegmentationDataModifiedEventType, SegmentationRepresentationModifiedEventDetail, SegmentationRepresentationModifiedEventType, SegmentationRepresentationRemovedEventDetail, SegmentationRepresentationRemovedEventType, SegmentationRemovedEventType, SegmentationRemovedEventDetail, SegmentationDataModifiedEventDetail, SegmentationRenderedEventType, SegmentationRenderedEventDetail, SegmentationModifiedEventType, SegmentationModifiedEventDetail, KeyDownEventDetail, KeyDownEventType, KeyUpEventDetail, KeyUpEventType, MouseDownEventDetail, TouchStartEventDetail, MouseDownEventType, TouchStartEventType, MouseDownActivateEventDetail, TouchStartActivateEventDetail, MouseDownActivateEventType, TouchStartActivateEventType, MouseDragEventDetail, TouchDragEventDetail, MouseDragEventType, TouchDragEventType, MouseUpEventDetail, TouchEndEventDetail, MouseUpEventType, TouchEndEventType, MouseClickEventDetail, MouseClickEventType, TouchTapEventDetail, TouchTapEventType, TouchSwipeEventDetail, TouchSwipeEventType, TouchPressEventDetail, TouchPressEventType, MouseMoveEventDetail, MouseMoveEventType, MouseDoubleClickEventDetail, MouseDoubleClickEventType, MouseWheelEventDetail, MouseWheelEventType, VolumeScrollOutOfBoundsEventDetail, VolumeScrollOutOfBoundsEventType, };

package/dist/esm/types/FloodFillTypes.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 type FloodFillResult = {
     flooded: Types.Point2[] | Types.Point3[];
     boundaries: Types.Point2[] | Types.Point3[];
@@ -12,4 +12,4 @@ type FloodFillOptions = {
     equals?: (a: any, b: any) => boolean;
     diagonals?: boolean;
 };
-export { FloodFillResult, FloodFillGetter, FloodFillOptions };
+export type { FloodFillResult, FloodFillGetter, FloodFillOptions };

package/dist/esm/types/IAnnotationManager.d.ts

@@ -1,5 +1,5 @@
-import AnnotationGroupSelector from './AnnotationGroupSelector';
-import { Annotation, Annotations, GroupSpecificAnnotations } from './AnnotationTypes';
+import type AnnotationGroupSelector from './AnnotationGroupSelector';
+import type { Annotation, Annotations, GroupSpecificAnnotations } from './AnnotationTypes';
 interface IAnnotationManager {
     getGroupKey: (annotationGroupSelector: AnnotationGroupSelector) => string;
     addAnnotation: (annotation: Annotation, groupKey: string) => void;
@@ -11,4 +11,4 @@ interface IAnnotationManager {
     getNumberOfAnnotations: (groupKey: string, toolName?: string) => number;
     getNumberOfAllAnnotations: () => number;
 }
-export default IAnnotationManager;
+export type { IAnnotationManager as default };

package/dist/esm/types/IDistance.d.ts

@@ -4,4 +4,4 @@ type IDistance = {
     canvas: number;
     world: number;
 };
-export default IDistance;
+export type { IDistance as default };

package/dist/esm/types/IPoints.d.ts

@@ -1,8 +1,8 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 type IPoints = {
     page: Types.Point2;
     client: Types.Point2;
     canvas: Types.Point2;
     world: Types.Point3;
 };
-export default IPoints;
+export type { IPoints as default };

package/dist/esm/types/ISetToolModeOptions.d.ts

@@ -1,4 +1,4 @@
-import { ToolModes, MouseBindings, KeyboardBindings } from '../enums';
+import type { ToolModes, MouseBindings, KeyboardBindings } from '../enums';
 type ToolBindingMouseType = (typeof MouseBindings)[keyof typeof MouseBindings];
 type ToolBindingKeyboardType = (typeof KeyboardBindings)[keyof typeof KeyboardBindings];
 type IToolBinding = {
@@ -13,4 +13,4 @@ type ToolOptionsType = {
     bindings: IToolBinding[];
     mode: ToolModes;
 };
-export { IToolBinding, SetToolBindingsType, ToolOptionsType };
+export type { IToolBinding, SetToolBindingsType, ToolOptionsType };

package/dist/esm/types/ISpline.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import type { ClosestPoint, ClosestControlPoint, ClosestSplinePoint, ControlPointInfo } from './';
 export interface ISpline {
     get numControlPoints(): number;

package/dist/esm/types/ISynchronizerEventHandler.d.ts

@@ -1,5 +1,5 @@
-import { Types } from '@cornerstonejs/core';
-import { Synchronizer } from '../store';
+import type { Types } from '@cornerstonejs/core';
+import type { Synchronizer } from '../store';
 export default interface ISynchronizerEventHandler {
-    (synchronizer: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, sourceEvent: any, options?: any): Promise<void> | void;
+    (synchronizer: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, sourceEvent: any, options?: unknown): Promise<void> | void;
 }

package/dist/esm/types/IToolClassReference.d.ts

@@ -1,3 +1,3 @@
-import { BaseTool } from '../tools';
-type IToolClassReference = new <T extends BaseTool>(config: any) => T;
-export default IToolClassReference;
+import type { BaseTool } from '../tools';
+type IToolClassReference = new <T extends BaseTool>(config: unknown) => T;
+export type { IToolClassReference as default };