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

package/dist/esm/stateManagement/segmentation/segmentationState.d.ts

@@ -1,38 +1,29 @@
-import type { Types } from '@cornerstonejs/core';
-import type { RepresentationConfig, Segmentation, SegmentationPublicInput, SegmentationRepresentationConfig, SegmentRepresentationConfig, SegmentationRepresentation } from '../../types/SegmentationStateTypes';
-declare function getDefaultSegmentationStateManager(): import("./SegmentationStateManager").default;
-declare function getSegmentation(segmentationId: string): Segmentation | undefined;
-declare function getSegmentations(): Segmentation[] | [];
-declare function addSegmentation(segmentationInput: SegmentationPublicInput, suppressEvents?: boolean): void;
-declare function getRepresentations(): SegmentationRepresentation[];
-declare function getRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
-declare function getRepresentationsBySegmentationId(segmentationId: string): SegmentationRepresentation[];
-declare function getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
-declare function setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;
-declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
-declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig, suppressEvents?: boolean): void;
-declare function getViewportIdsWithSegmentationId(segmentationId: string): string[];
-declare function getRepresentationsForViewport(viewportId: string): SegmentationRepresentation[] | [];
-declare function getRepresentationsRenderingStateForViewport(viewportId: string): {
-    [segRepUID: string]: {
-        visible: boolean;
-        segmentsHidden: Set<number>;
-        active: boolean;
-    };
-};
-declare function addRepresentationToViewport(viewportId: string, segmentationRepresentation: SegmentationRepresentation, suppressEvents?: boolean): void;
-declare function getGlobalConfig(): SegmentationRepresentationConfig;
-declare function setGlobalConfig(config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
-declare function removeSegmentation(segmentationId: string): void;
-declare function removeRepresentation(segmentationRepresentationUID: string, suppressEvents?: boolean): void;
-declare function removeColorLUT(colorLUTIndex: number): void;
-declare function getColorLUT(index: number): Types.ColorLUT | undefined;
-declare function getNextColorLUTIndex(): number;
-declare function addColorLUT(colorLUT: Types.ColorLUT, index: number): void;
-declare function getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
-declare function setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
-declare function getActiveRepresentation(viewportId: string): SegmentationRepresentation | undefined;
-declare function setActiveRepresentation(viewportId: string, segmentationRepresentationUID: string, suppressEvents?: boolean): void;
-declare function getLabelmapImageIdsForViewport(viewportId: string, segmentationId?: string): string;
-declare function updateSegmentationImageReferences(viewportId: string, segmentationId: string): void;
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, getLabelmapImageIdsForViewport, updateSegmentationImageReferences, };
+import { getSegmentation } from './getSegmentation';
+import { getSegmentations } from './getSegmentations';
+import { addSegmentation } from './addSegmentation';
+import { removeSegmentation } from './removeSegmentation';
+import { getAllSegmentationRepresentations } from './getAllSegmentationRepresentations';
+import { getSegmentationRepresentation } from './getSegmentationRepresentation';
+import { removeRepresentation } from './removeRepresentation';
+import { getGlobalConfig } from './getGlobalConfig';
+import { setGlobalConfig } from './setGlobalConfig';
+import { getSegmentationRepresentationConfig } from './getSegmentationRepresentationConfig';
+import { setSegmentationRepresentationConfig } from './setSegmentationRepresentationConfig';
+import { getPerSegmentConfig } from './getPerSegmentConfig';
+import { setPerSegmentConfig } from './setPerSegmentConfig';
+import { getSegmentationRepresentations } from './getSegmentationRepresentations';
+import { addSegmentationRepresentation } from './addSegmentationRepresentation';
+import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
+import { addColorLUT } from './addColorLUT';
+import { getColorLUT } from './getColorLUT';
+import { getNextColorLUTIndex } from './getNextColorLUTIndex';
+import { removeColorLUT } from './removeColorLUT';
+import { getSegmentationRepresentationsForSegmentation } from './getSegmentationRepresentationsForSegmentation';
+import { getSegmentationRepresentationVisibility } from './getSegmentationRepresentationVisibility';
+import { setSegmentationRepresentationVisibility } from './setSegmentationRepresentationVisibility';
+import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
+import { getActiveSegmentationRepresentation } from './getActiveSegmentationRepresentation';
+import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
+import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
+import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
+export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, addSegmentationRepresentation, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, };

package/dist/esm/stateManagement/segmentation/segmentationState.js

@@ -1,157 +1,29 @@
-import { defaultSegmentationStateManager } from './SegmentationStateManager';
-import { triggerSegmentationModified, triggerSegmentationRemoved, triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, } from './triggerSegmentationEvents';
-import normalizeSegmentationInput from './helpers/normalizeSegmentationInput';
-function getDefaultSegmentationStateManager() {
-    return defaultSegmentationStateManager;
-}
-function getSegmentation(segmentationId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentation(segmentationId);
-}
-function getSegmentations() {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    const state = segmentationStateManager.getState();
-    return state.segmentations;
-}
-function addSegmentation(segmentationInput, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    const segmentation = normalizeSegmentationInput(segmentationInput);
-    segmentationStateManager.addSegmentation(segmentation);
-    if (!suppressEvents) {
-        triggerSegmentationModified(segmentation.segmentationId);
-    }
-}
-function getRepresentations() {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    const state = segmentationStateManager.getState();
-    return Object.values(state.representations);
-}
-function getRepresentation(segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getRepresentation(segmentationRepresentationUID);
-}
-function getRepresentationsBySegmentationId(segmentationId) {
-    const allRepresentations = getRepresentations();
-    return allRepresentations.filter((representation) => representation.segmentationId === segmentationId);
-}
-function getAllSegmentsConfig(segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getAllSegmentsConfig(segmentationRepresentationUID);
-}
-function setAllSegmentsConfig(segmentationRepresentationUID, config, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setAllSegmentsConfig(segmentationRepresentationUID, config);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
-    }
-}
-function getPerSegmentConfig(segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getPerSegmentConfig(segmentationRepresentationUID);
-}
-function setPerSegmentConfig(segmentationRepresentationUID, config, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setPerSegmentConfig(segmentationRepresentationUID, config);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
-    }
-}
-function getViewportIdsWithSegmentationId(segmentationId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    const state = segmentationStateManager.getState();
-    const viewports = state.viewports;
-    return Object.keys(viewports).filter((viewportId) => {
-        const viewport = viewports[viewportId];
-        return Object.keys(viewport).some((segRepUID) => state.representations[segRepUID].segmentationId === segmentationId);
-    });
-}
-function getRepresentationsForViewport(viewportId) {
-    const viewportRenderingState = getRepresentationsRenderingStateForViewport(viewportId);
-    if (!viewportRenderingState) {
-        return [];
-    }
-    const segRepUIDs = Object.keys(viewportRenderingState);
-    return segRepUIDs
-        .map((segRepUID) => getRepresentation(segRepUID))
-        .filter(Boolean);
-}
-function getRepresentationsRenderingStateForViewport(viewportId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    const state = segmentationStateManager.getState();
-    return state.viewports?.[viewportId] || {};
-}
-function addRepresentationToViewport(viewportId, segmentationRepresentation, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.addRepresentation(segmentationRepresentation);
-    segmentationStateManager.addRepresentationToViewport(viewportId, segmentationRepresentation.segmentationRepresentationUID);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(segmentationRepresentation.segmentationRepresentationUID);
-    }
-}
-function getGlobalConfig() {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getGlobalConfig();
-}
-function setGlobalConfig(config, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setGlobalConfig(config);
-    if (!suppressEvents) {
-        triggerSegmentationModified();
-    }
-}
-function removeSegmentation(segmentationId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.removeSegmentation(segmentationId);
-    triggerSegmentationRemoved(segmentationId);
-}
-function removeRepresentation(segmentationRepresentationUID, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.removeRepresentation(segmentationRepresentationUID);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationRemoved(segmentationRepresentationUID);
-    }
-}
-function removeColorLUT(colorLUTIndex) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.removeColorLUT(colorLUTIndex);
-}
-function getColorLUT(index) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getColorLUT(index);
-}
-function getNextColorLUTIndex() {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getNextColorLUTIndex();
-}
-function addColorLUT(colorLUT, index) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.addColorLUT(colorLUT, index);
-}
-function getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
-}
-function setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible);
-}
-function getActiveRepresentation(viewportId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getActiveRepresentation(viewportId);
-}
-function setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setActiveRepresentation(viewportId, segmentationRepresentationUID);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
-    }
-}
-function getLabelmapImageIdsForViewport(viewportId, segmentationId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getLabelmapImageIdsForViewport(viewportId, segmentationId);
-}
-function updateSegmentationImageReferences(viewportId, segmentationId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.updateSegmentationImageReferences(viewportId, segmentationId);
-}
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, getLabelmapImageIdsForViewport, updateSegmentationImageReferences, };
+import { getSegmentation } from './getSegmentation';
+import { getSegmentations } from './getSegmentations';
+import { addSegmentation } from './addSegmentation';
+import { removeSegmentation } from './removeSegmentation';
+import { getAllSegmentationRepresentations } from './getAllSegmentationRepresentations';
+import { getSegmentationRepresentation } from './getSegmentationRepresentation';
+import { removeRepresentation } from './removeRepresentation';
+import { getGlobalConfig } from './getGlobalConfig';
+import { setGlobalConfig } from './setGlobalConfig';
+import { getSegmentationRepresentationConfig } from './getSegmentationRepresentationConfig';
+import { setSegmentationRepresentationConfig } from './setSegmentationRepresentationConfig';
+import { getPerSegmentConfig } from './getPerSegmentConfig';
+import { setPerSegmentConfig } from './setPerSegmentConfig';
+import { getSegmentationRepresentations } from './getSegmentationRepresentations';
+import { addSegmentationRepresentation } from './addSegmentationRepresentation';
+import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
+import { addColorLUT } from './addColorLUT';
+import { getColorLUT } from './getColorLUT';
+import { getNextColorLUTIndex } from './getNextColorLUTIndex';
+import { removeColorLUT } from './removeColorLUT';
+import { getSegmentationRepresentationsForSegmentation } from './getSegmentationRepresentationsForSegmentation';
+import { getSegmentationRepresentationVisibility } from './getSegmentationRepresentationVisibility';
+import { setSegmentationRepresentationVisibility } from './setSegmentationRepresentationVisibility';
+import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
+import { getActiveSegmentationRepresentation } from './getActiveSegmentationRepresentation';
+import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
+import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
+import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
+export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, addSegmentationRepresentation, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, };

package/dist/esm/stateManagement/segmentation/setActiveSegmentationRepresentation.d.ts

@@ -0,0 +1 @@
+export declare function setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string, suppressEvents?: boolean): void;

package/dist/esm/stateManagement/segmentation/setActiveSegmentationRepresentation.js

@@ -0,0 +1,9 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationRepresentationModified } from './triggerSegmentationEvents';
+export function setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    }
+}

package/dist/esm/stateManagement/segmentation/setGlobalConfig.d.ts

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentationConfig } from '../../types';
+export declare function setGlobalConfig(config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;

package/dist/esm/stateManagement/segmentation/setGlobalConfig.js

@@ -0,0 +1,9 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+export function setGlobalConfig(config, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.setGlobalConfig(config);
+    if (!suppressEvents) {
+        triggerSegmentationModified();
+    }
+}

package/dist/esm/stateManagement/segmentation/setPerSegmentConfig.d.ts

@@ -0,0 +1,2 @@
+import type { SegmentRepresentationConfig } from '../../types/SegmentationStateTypes';
+export declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig, suppressEvents?: boolean): void;

package/dist/esm/stateManagement/segmentation/setPerSegmentConfig.js

@@ -0,0 +1,9 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationRepresentationModified } from './triggerSegmentationEvents';
+export function setPerSegmentConfig(segmentationRepresentationUID, config, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.setPerSegmentConfig(segmentationRepresentationUID, config);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    }
+}

package/dist/esm/stateManagement/segmentation/setSegmentationRepresentationConfig.d.ts

@@ -0,0 +1,2 @@
+import type { RepresentationConfig } from '../../types';
+export declare function setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;

package/dist/esm/stateManagement/segmentation/setSegmentationRepresentationConfig.js

@@ -0,0 +1,9 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationRepresentationModified } from './triggerSegmentationEvents';
+export function setSegmentationRepresentationConfig(segmentationRepresentationUID, config, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.setSegmentationRepresentationConfig(segmentationRepresentationUID, config);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    }
+}

package/dist/esm/stateManagement/segmentation/setSegmentationRepresentationVisibility.d.ts

@@ -0,0 +1 @@
+export declare function setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;

package/dist/esm/stateManagement/segmentation/setSegmentationRepresentationVisibility.js

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible);
+}

package/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.d.ts

@@ -1,6 +1,6 @@
-declare function triggerSegmentationRemoved(segmentationId: string): void;
-declare function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID: string): void;
-declare function triggerSegmentationRepresentationModified(segmentationRepresentationUID: string): void;
-declare function triggerSegmentationModified(segmentationId?: string): void;
-declare function triggerSegmentationDataModified(segmentationId: string, modifiedSlicesToUse?: number[]): void;
+import { triggerSegmentationRepresentationModified } from './events/triggerSegmentationRepresentationModified';
+import { triggerSegmentationRepresentationRemoved } from './events/triggerSegmentationRepresentationRemoved';
+import { triggerSegmentationDataModified } from './events/triggerSegmentationDataModified';
+import { triggerSegmentationModified } from './events/triggerSegmentationModified';
+import { triggerSegmentationRemoved } from './events/triggerSegmentationRemoved';
 export { triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, };

package/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js

@@ -1,46 +1,6 @@
-import { triggerEvent, eventTarget } from '@cornerstonejs/core';
-import { Events } from '../../enums';
-import { getSegmentations } from '../../stateManagement/segmentation/segmentationState';
-import { setSegmentationDirty } from '../../utilities/segmentation/getUniqueSegmentIndices';
-function triggerSegmentationRemoved(segmentationId) {
-    const eventDetail = {
-        segmentationId,
-    };
-    triggerEvent(eventTarget, Events.SEGMENTATION_REMOVED, eventDetail);
-}
-function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID) {
-    const eventDetail = {
-        segmentationRepresentationUID,
-    };
-    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_REMOVED, eventDetail);
-}
-function triggerSegmentationRepresentationModified(segmentationRepresentationUID) {
-    const eventDetail = {
-        segmentationRepresentationUID,
-    };
-    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
-}
-function triggerSegmentationModified(segmentationId) {
-    let segmentationIds;
-    if (segmentationId) {
-        segmentationIds = [segmentationId];
-    }
-    else {
-        segmentationIds = getSegmentations().map(({ segmentationId }) => segmentationId);
-    }
-    segmentationIds.forEach((segmentationId) => {
-        const eventDetail = {
-            segmentationId,
-        };
-        triggerEvent(eventTarget, Events.SEGMENTATION_MODIFIED, eventDetail);
-    });
-}
-function triggerSegmentationDataModified(segmentationId, modifiedSlicesToUse) {
-    const eventDetail = {
-        segmentationId,
-        modifiedSlicesToUse,
-    };
-    setSegmentationDirty(segmentationId);
-    triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);
-}
+import { triggerSegmentationRepresentationModified } from './events/triggerSegmentationRepresentationModified';
+import { triggerSegmentationRepresentationRemoved } from './events/triggerSegmentationRepresentationRemoved';
+import { triggerSegmentationDataModified } from './events/triggerSegmentationDataModified';
+import { triggerSegmentationModified } from './events/triggerSegmentationModified';
+import { triggerSegmentationRemoved } from './events/triggerSegmentationRemoved';
 export { triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, };

package/dist/esm/stateManagement/segmentation/updateLabelmapSegmentationImageReferences.d.ts

@@ -0,0 +1 @@
+export declare function updateLabelmapSegmentationImageReferences(viewportId: string, segmentationId: string): void;

package/dist/esm/stateManagement/segmentation/updateLabelmapSegmentationImageReferences.js

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
+}

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 { state } from '../state';
+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/destroy.js

@@ -1,4 +1,4 @@
-import { state } from '../index';
+import { state } from '../state';
 function destroy() {
     while (state.synchronizers.length > 0) {
         const synchronizer = state.synchronizers.pop();

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

@@ -1,4 +1,4 @@
-import { state } from '../index';
+import { state } from '../state';
 function destroySynchronizer(synchronizerId) {
     const synchronizerIndex = state.synchronizers.findIndex((sync) => sync.id === synchronizerId);
     if (synchronizerIndex > -1) {

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/getAllSynchronizers.js

@@ -1,4 +1,4 @@
-import { state } from '../index';
+import { state } from '../state';
 function getAllSynchronizers() {
     return state.synchronizers;
 }

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/getSynchronizer.js

@@ -1,4 +1,4 @@
-import { state } from '../index';
+import { state } from '../state';
 function getSynchronizer(synchronizerId) {
     return state.synchronizers.find((s) => s.id === synchronizerId);
 }

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/SynchronizerManager/getSynchronizersForViewport.js

@@ -1,4 +1,4 @@
-import { state } from '../index';
+import { state } from '../state';
 function getSynchronizersForViewport(viewportId, renderingEngineId) {
     const synchronizersFilteredByIds = [];
     if (!renderingEngineId && !viewportId) {

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

@@ -1,10 +1,10 @@
-import { MouseBindings, ToolModes } from '../../enums';
+import { MouseBindings, ToolModes, Events } from '../../enums';
 import get from 'lodash.get';
 import { triggerEvent, eventTarget, getRenderingEngine, getRenderingEngines, getEnabledElementByIds, Settings, } from '@cornerstonejs/core';
-import { Events } from '../../enums';
-import { ToolGroupManager, state } from '../index';
+import { state } from '../state';
 import { MouseCursor, SVGMouseCursor } from '../../cursors';
 import { initElementCursor } from '../../cursors/elementCursor';
+import getToolGroup from './getToolGroup';
 const { Active, Passive, Enabled, Disabled } = ToolModes;
 const PRIMARY_BINDINGS = [{ mouseButton: MouseBindings.Primary }];
 export default class ToolGroup {
@@ -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)) {
@@ -392,12 +395,13 @@ export default class ToolGroup {
         return this.currentActivePrimaryToolName;
     }
     clone(newToolGroupId, fnToolFilter = null) {
-        let toolGroup = ToolGroupManager.getToolGroup(newToolGroupId);
+        let toolGroup = getToolGroup(newToolGroupId);
         if (toolGroup) {
-            console.warn(`ToolGroup ${newToolGroupId} already exists`);
+            console.debug(`ToolGroup ${newToolGroupId} already exists`);
             return toolGroup;
         }
-        toolGroup = ToolGroupManager.createToolGroup(newToolGroupId);
+        toolGroup = new ToolGroup(newToolGroupId);
+        state.toolGroups.push(toolGroup);
         fnToolFilter = fnToolFilter ?? (() => true);
         Object.keys(this._toolInstances)
             .filter(fnToolFilter)

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/createToolGroup.js

@@ -1,4 +1,4 @@
-import { state } from '../index';
+import { state } from '../state';
 import ToolGroup from './ToolGroup';
 function createToolGroup(toolGroupId) {
     const toolGroupWithIdExists = state.toolGroups.some((tg) => tg.id === toolGroupId);