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

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 getAllSegmentationRepresentations() {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    const state = segmentationStateManager.getState();
-    return Object.values(state.representations);
-}
-function getSegmentationRepresentation(segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentation(segmentationRepresentationUID);
-}
-function getSegmentationRepresentationsForSegmentation(segmentationId) {
-    const allRepresentations = getAllSegmentationRepresentations();
-    return allRepresentations.filter((representation) => representation.segmentationId === segmentationId);
-}
-function getSegmentationRepresentationConfig(segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentationConfig(segmentationRepresentationUID);
-}
-function setSegmentationRepresentationConfig(segmentationRepresentationUID, config, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setSegmentationRepresentationConfig(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 getViewportIdsWithSegmentation(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 getSegmentationRepresentations(viewportId) {
-    const viewportRenderingState = getSegmentationRepresentationViewportStates(viewportId);
-    if (!viewportRenderingState) {
-        return [];
-    }
-    const segRepUIDs = Object.keys(viewportRenderingState);
-    return segRepUIDs
-        .map((segRepUID) => getSegmentationRepresentation(segRepUID))
-        .filter(Boolean);
-}
-function getSegmentationRepresentationViewportStates(viewportId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    const state = segmentationStateManager.getState();
-    return state.viewports?.[viewportId] || {};
-}
-function addSegmentationRepresentation(viewportId, segmentationRepresentation, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.addSegmentationRepresentationState(segmentationRepresentation);
-    segmentationStateManager.addSegmentationRepresentationToViewport(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 getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
-}
-function setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible);
-}
-function getActiveSegmentationRepresentation(viewportId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getActiveSegmentationRepresentation(viewportId);
-}
-function setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvents) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
-    }
-}
-function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
-}
-function updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
-}
-export { getDefaultSegmentationStateManager, 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, };
+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/createSynchronizer.js

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

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

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

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.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.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 {
@@ -395,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.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);

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

@@ -1,10 +1,10 @@
-import { state as csToolsState } from '../index';
+import { state } from '../state';
 import destroyToolGroup from './destroyToolGroup';
 function destroy() {
-    const toolGroups = [...csToolsState.toolGroups];
+    const toolGroups = [...state.toolGroups];
     for (const toolGroup of toolGroups) {
         destroyToolGroup(toolGroup.id);
     }
-    csToolsState.toolGroups = [];
+    state.toolGroups = [];
 }
 export default destroy;

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { getRenderingEngines } from '@cornerstonejs/core';
-import { state } from '../index';
+import { state } from '../state';
 function getToolGroupForViewport(viewportId, renderingEngineId) {
     if (!renderingEngineId) {
         renderingEngineId = getRenderingEngines().find((re) => re.getViewports().find((vp) => vp.id === viewportId))?.id;

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

@@ -1,4 +1,4 @@
-import { state } from '../index';
+import { state } from '../state';
 import { ToolModes } from '../../enums';
 const MODES = [ToolModes.Active, ToolModes.Passive, ToolModes.Enabled];
 function getToolGroupsWithToolName(toolName) {

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

@@ -1,4 +1,5 @@
 export declare function addTool(ToolClass: any): void;
 export declare function hasTool(ToolClass: any): boolean;
+export declare function hasToolByName(toolName: string): boolean;
 export declare function removeTool(ToolClass: any): void;
 export default addTool;

package/dist/esm/store/addTool.js

@@ -13,6 +13,9 @@ export function hasTool(ToolClass) {
     const toolName = ToolClass.toolName;
     return !!(toolName && state.tools[toolName]);
 }
+export function hasToolByName(toolName) {
+    return !!(toolName && state.tools[toolName]);
+}
 export function removeTool(ToolClass) {
     const toolName = ToolClass.toolName;
     if (!toolName) {

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

@@ -4,7 +4,6 @@ import removeEnabledElement from './removeEnabledElement';
 import cancelActiveManipulations from './cancelActiveManipulations';
 import Synchronizer from './SynchronizerManager/Synchronizer';
 import svgNodeCache from './svgNodeCache';
-import state from './state';
 import * as ToolGroupManager from './ToolGroupManager';
 import * as SynchronizerManager from './SynchronizerManager';
-export { state, addTool, hasTool, removeTool, addEnabledElement, removeEnabledElement, cancelActiveManipulations, svgNodeCache, ToolGroupManager, SynchronizerManager, Synchronizer, };
+export { addTool, hasTool, removeTool, addEnabledElement, removeEnabledElement, cancelActiveManipulations, svgNodeCache, ToolGroupManager, SynchronizerManager, Synchronizer, };

package/dist/esm/store/index.js

@@ -4,7 +4,6 @@ import removeEnabledElement from './removeEnabledElement';
 import cancelActiveManipulations from './cancelActiveManipulations';
 import Synchronizer from './SynchronizerManager/Synchronizer';
 import svgNodeCache from './svgNodeCache';
-import state from './state';
 import * as ToolGroupManager from './ToolGroupManager';
 import * as SynchronizerManager from './SynchronizerManager';
-export { state, addTool, hasTool, removeTool, addEnabledElement, removeEnabledElement, cancelActiveManipulations, svgNodeCache, ToolGroupManager, SynchronizerManager, Synchronizer, };
+export { addTool, hasTool, removeTool, addEnabledElement, removeEnabledElement, cancelActiveManipulations, svgNodeCache, ToolGroupManager, SynchronizerManager, Synchronizer, };

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

@@ -2,14 +2,48 @@ import { AnnotationTool } from './base';
 import type { Types } from '@cornerstonejs/core';
 import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
 import type { AdvancedMagnifyAnnotation } from '../types/ToolSpecificAnnotationTypes';
-import AdvancedMagnifyViewportManager from './AdvancedMagnifyViewportManager';
+export type AutoPanCallbackData = {
+    points: {
+        currentPosition: {
+            canvas: Types.Point2;
+            world: Types.Point3;
+        };
+        newPosition: {
+            canvas: Types.Point2;
+            world: Types.Point3;
+        };
+    };
+    delta: {
+        canvas: Types.Point2;
+        world: Types.Point3;
+    };
+};
+export type AutoPanCallback = (data: AutoPanCallbackData) => void;
 declare enum AdvancedMagnifyToolActions {
     ShowZoomFactorsList = "showZoomFactorsList"
 }
+export type MagnifyViewportInfo = {
+    magnifyViewportId?: string;
+    sourceEnabledElement: Types.IEnabledElement;
+    position: Types.Point2;
+    radius: number;
+    zoomFactor: number;
+    autoPan: {
+        enabled: boolean;
+        padding: number;
+        callback: AutoPanCallback;
+    };
+};
+interface MagnifyViewportManager {
+    createViewport(annotation: AdvancedMagnifyAnnotation, viewportInfo: MagnifyViewportInfo): AdvancedMagnifyViewport;
+    getViewport(magnifyViewportId: string): AdvancedMagnifyViewport;
+    destroyViewport(magnifyViewportId: string): void;
+    dispose(): void;
+}
 declare class AdvancedMagnifyTool extends AnnotationTool {
     static toolName: any;
     static Actions: typeof AdvancedMagnifyToolActions;
-    magnifyViewportManager: AdvancedMagnifyViewportManager;
+    magnifyViewportManager: MagnifyViewportManager;
     editData: {
         annotation: Annotation;
         viewportIdsToRender: Array<string>;
@@ -36,4 +70,61 @@ declare class AdvancedMagnifyTool extends AnnotationTool {
     private _getZoomFactorsListDropdown;
     private _getCanvasHandlePoints;
 }
+declare class AdvancedMagnifyViewport {
+    private _viewportId;
+    private _sourceEnabledElement;
+    private _enabledElement;
+    private _sourceToolGroup;
+    private _magnifyToolGroup;
+    private _isViewportReady;
+    private _radius;
+    private _resized;
+    private _resizeViewportAsync;
+    private _canAutoPan;
+    private _autoPan;
+    position: Types.Point2;
+    zoomFactor: number;
+    visible: boolean;
+    constructor({ magnifyViewportId, sourceEnabledElement, radius, position, zoomFactor, autoPan, }: {
+        magnifyViewportId?: string;
+        sourceEnabledElement: Types.IEnabledElement;
+        radius?: number;
+        position?: Types.Point2;
+        zoomFactor: number;
+        autoPan: {
+            enabled: boolean;
+            padding: number;
+            callback: AutoPanCallback;
+        };
+    });
+    get sourceEnabledElement(): Types.IEnabledElement;
+    get viewportId(): string;
+    get radius(): number;
+    set radius(radius: number);
+    update(): void;
+    dispose(): void;
+    private _handleToolModeChanged;
+    private _inheritBorderRadius;
+    private _createViewportNode;
+    private _convertZoomFactorToParallelScale;
+    private _isStackViewport;
+    private _isVolumeViewport;
+    private _cloneToolGroups;
+    private _cloneStack;
+    private _cloneVolumes;
+    private _cloneViewport;
+    private _cancelMouseEventCallback;
+    private _browserMouseUpCallback;
+    private _browserMouseDownCallback;
+    private _mouseDragCallback;
+    private _addBrowserEventListeners;
+    private _removeBrowserEventListeners;
+    private _addEventListeners;
+    private _removeEventListeners;
+    private _initialize;
+    private _syncViewportsCameras;
+    private _syncStackViewports;
+    private _syncViewports;
+    private _resizeViewport;
+}
 export { AdvancedMagnifyTool as default };