@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.js

@@ -1,7 +1,4 @@
-import cloneDeep from 'lodash.clonedeep';
 import { Enums, eventTarget, getEnabledElement, utilities, } from '@cornerstonejs/core';
-import { checkAndDefineIsLockedProperty } from './annotationLocking';
-import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 class FrameOfReferenceSpecificAnnotationManager {
     constructor(uid) {
         this.getGroupKey = (annotationGroupSelector) => {
@@ -42,7 +39,9 @@ class FrameOfReferenceSpecificAnnotationManager {
                 return [];
             }
             if (toolName) {
-                return annotations[groupKey][toolName];
+                return annotations[groupKey][toolName]
+                    ? annotations[groupKey][toolName]
+                    : [];
             }
             return annotations[groupKey];
         };
@@ -89,9 +88,10 @@ class FrameOfReferenceSpecificAnnotationManager {
                 frameOfReferenceSpecificAnnotations[toolName] = [];
                 toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
             }
+            if (this.preprocessingFn) {
+                annotation = this.preprocessingFn(annotation);
+            }
             toolSpecificAnnotations.push(annotation);
-            checkAndDefineIsLockedProperty(annotation);
-            checkAndDefineIsVisibleProperty(annotation);
         };
         this.removeAnnotation = (annotationUID) => {
             const { annotations } = this;
@@ -114,14 +114,27 @@ class FrameOfReferenceSpecificAnnotationManager {
         };
         this.removeAnnotations = (groupKey, toolName) => {
             const annotations = this.annotations;
-            if (annotations[groupKey]) {
-                if (toolName) {
-                    delete annotations[groupKey][toolName];
+            const removedAnnotations = [];
+            if (!annotations[groupKey]) {
+                return removedAnnotations;
+            }
+            if (toolName) {
+                const annotationsForTool = annotations[groupKey][toolName];
+                for (const annotation of annotationsForTool) {
+                    this.removeAnnotation(annotation.annotationUID);
+                    removedAnnotations.push(annotation);
                 }
-                else {
-                    delete annotations[groupKey];
+            }
+            else {
+                for (const toolName in annotations[groupKey]) {
+                    const annotationsForTool = annotations[groupKey][toolName];
+                    for (const annotation of annotationsForTool) {
+                        this.removeAnnotation(annotation.annotationUID);
+                        removedAnnotations.push(annotation);
+                    }
                 }
             }
+            return removedAnnotations;
         };
         this.saveAnnotations = (groupKey, toolName) => {
             const annotations = this.annotations;
@@ -131,13 +144,13 @@ class FrameOfReferenceSpecificAnnotationManager {
                     return;
                 }
                 const toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
-                return cloneDeep(toolSpecificAnnotations);
+                return structuredClone(toolSpecificAnnotations);
             }
             else if (groupKey) {
                 const frameOfReferenceSpecificAnnotations = annotations[groupKey];
-                return cloneDeep(frameOfReferenceSpecificAnnotations);
+                return structuredClone(frameOfReferenceSpecificAnnotations);
             }
-            return cloneDeep(annotations);
+            return structuredClone(annotations);
         };
         this.restoreAnnotations = (state, groupKey, toolName) => {
             const annotations = this.annotations;
@@ -153,9 +166,14 @@ class FrameOfReferenceSpecificAnnotationManager {
                 annotations[groupKey] = state;
             }
             else {
-                this.annotations = cloneDeep(state);
+                this.annotations = structuredClone(state);
             }
         };
+        this.getAllAnnotations = () => {
+            return Object.values(this.annotations)
+                .map((frameOfReferenceSpecificAnnotations) => Object.values(frameOfReferenceSpecificAnnotations))
+                .flat(2);
+        };
         this.getNumberOfAllAnnotations = () => {
             let count = 0;
             const annotations = this.annotations;
@@ -169,7 +187,12 @@ class FrameOfReferenceSpecificAnnotationManager {
             return count;
         };
         this.removeAllAnnotations = () => {
-            this.annotations = {};
+            const removedAnnotations = [];
+            for (const annotation of this.getAllAnnotations()) {
+                this.removeAnnotation(annotation.annotationUID);
+                removedAnnotations.push(annotation);
+            }
+            return removedAnnotations;
         };
         if (!uid) {
             uid = utilities.uuidv4();
@@ -178,8 +201,10 @@ class FrameOfReferenceSpecificAnnotationManager {
         this.uid = uid;
         eventTarget.addEventListener(Enums.Events.IMAGE_VOLUME_MODIFIED, this._imageVolumeModifiedHandler);
     }
+    setPreprocessingFn(preprocessingFn) {
+        this.preprocessingFn = preprocessingFn;
+    }
 }
 const defaultFrameOfReferenceSpecificAnnotationManager = new FrameOfReferenceSpecificAnnotationManager('DEFAULT');
 export { defaultFrameOfReferenceSpecificAnnotationManager };
 export default FrameOfReferenceSpecificAnnotationManager;
-//# sourceMappingURL=FrameOfReferenceSpecificAnnotationManager.js.map

package/dist/esm/stateManagement/annotation/annotationLocking.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../types';
+import type { Annotation } from '../../types';
 declare function setAnnotationLocked(annotation: Annotation, locked?: boolean): void;
 declare function unlockAllAnnotations(): void;
 declare function getAnnotationsLocked(): Array<Annotation>;

package/dist/esm/stateManagement/annotation/annotationLocking.js

@@ -85,4 +85,3 @@ function getIsLocked() {
     return isAnnotationLocked(this);
 }
 export { setAnnotationLocked, getAnnotationsLocked, getAnnotationsLockedCount, unlockAllAnnotations, isAnnotationLocked, checkAndDefineIsLockedProperty, };
-//# sourceMappingURL=annotationLocking.js.map

package/dist/esm/stateManagement/annotation/annotationSelection.js

@@ -1,6 +1,6 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import { Events } from '../../enums';
-import { getAnnotation } from './annotationState';
+import { getAnnotation } from './getAnnotation';
 const selectedAnnotationUIDs = new Set();
 function setAnnotationSelected(annotationUID, selected = true, preserveSelected = false) {
     if (selected) {
@@ -39,7 +39,7 @@ function getAnnotationsSelected() {
 function getAnnotationsSelectedByToolName(toolName) {
     return getAnnotationsSelected().filter((annotationUID) => {
         const annotation = getAnnotation(annotationUID);
-        return annotation.metadata.toolName === toolName;
+        return annotation?.metadata?.toolName === toolName;
     });
 }
 function isAnnotationSelected(annotationUID) {
@@ -69,4 +69,3 @@ function publish(detail, selectionSet) {
     }
 }
 export { setAnnotationSelected, getAnnotationsSelected, getAnnotationsSelectedByToolName, getAnnotationsSelectedCount, deselectAnnotation, isAnnotationSelected, };
-//# sourceMappingURL=annotationSelection.js.map

package/dist/esm/stateManagement/annotation/annotationState.d.ts

@@ -1,12 +1,19 @@
-import { Annotations, Annotation } from '../../types/AnnotationTypes';
-import { AnnotationGroupSelector } from '../../types';
+import type { Annotations, Annotation } from '../../types/AnnotationTypes';
+import type { AnnotationGroupSelector } from '../../types';
+import { getAnnotation } from './getAnnotation';
 declare function getAnnotationManager(): import("./FrameOfReferenceSpecificAnnotationManager").default;
 declare function setAnnotationManager(annotationManager: any): void;
 declare function resetAnnotationManager(): void;
 declare function getAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): Annotations;
+declare function getAllAnnotations(): Annotations;
+declare function clearParentAnnotation(annotation: Annotation): void;
+declare function addChildAnnotation(parentAnnotation: Annotation, childAnnotation: Annotation): void;
+declare function getParentAnnotation(annotation: Annotation): Annotation;
+declare function getChildAnnotations(annotation: Annotation): Annotation[];
 declare function addAnnotation(annotation: Annotation, annotationGroupSelector: AnnotationGroupSelector): string;
 declare function getNumberOfAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): number;
 declare function removeAnnotation(annotationUID: string): void;
-declare function getAnnotation(annotationUID: string): Annotation;
 declare function removeAllAnnotations(): void;
-export { getAnnotations, getNumberOfAnnotations, addAnnotation, getAnnotation, removeAnnotation, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, };
+declare function removeAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): void;
+declare function invalidateAnnotation(annotation: Annotation): void;
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, getAnnotation, };

package/dist/esm/stateManagement/annotation/annotationState.js

@@ -1,8 +1,19 @@
-import { triggerEvent, eventTarget, utilities as csUtils, } from '@cornerstonejs/core';
-import { Events } from '../../enums';
+import { utilities as csUtils } from '@cornerstonejs/core';
 import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
-import { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, } from './helpers/state';
+import { getAnnotation } from './getAnnotation';
+import { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, triggerAnnotationRemoved, } from './helpers/state';
+import { checkAndDefineIsLockedProperty } from './annotationLocking';
+import { checkAndDefineCachedStatsProperty, checkAndDefineTextBoxProperty, } from './utilities/defineProperties';
+import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 let defaultManager = defaultFrameOfReferenceSpecificAnnotationManager;
+const preprocessingFn = (annotation) => {
+    checkAndDefineIsLockedProperty(annotation);
+    checkAndDefineTextBoxProperty(annotation);
+    checkAndDefineIsVisibleProperty(annotation);
+    checkAndDefineCachedStatsProperty(annotation);
+    return annotation;
+};
+defaultManager.setPreprocessingFn(preprocessingFn);
 function getAnnotationManager() {
     return defaultManager;
 }
@@ -17,17 +28,53 @@ function getAnnotations(toolName, annotationGroupSelector) {
     const groupKey = manager.getGroupKey(annotationGroupSelector);
     return manager.getAnnotations(groupKey, toolName);
 }
+function getAllAnnotations() {
+    const manager = getAnnotationManager();
+    return manager.getAllAnnotations();
+}
+function clearParentAnnotation(annotation) {
+    const { annotationUID: childUID, parentAnnotationUID } = annotation;
+    if (!parentAnnotationUID) {
+        return;
+    }
+    const parentAnnotation = getAnnotation(parentAnnotationUID);
+    const childUIDIndex = parentAnnotation.childAnnotationUIDs.indexOf(childUID);
+    parentAnnotation.childAnnotationUIDs.splice(childUIDIndex, 1);
+    annotation.parentAnnotationUID = undefined;
+}
+function addChildAnnotation(parentAnnotation, childAnnotation) {
+    const { annotationUID: parentUID } = parentAnnotation;
+    const { annotationUID: childUID } = childAnnotation;
+    clearParentAnnotation(childAnnotation);
+    if (!parentAnnotation.childAnnotationUIDs) {
+        parentAnnotation.childAnnotationUIDs = [];
+    }
+    if (parentAnnotation.childAnnotationUIDs.includes(childUID)) {
+        return;
+    }
+    parentAnnotation.childAnnotationUIDs.push(childUID);
+    childAnnotation.parentAnnotationUID = parentUID;
+}
+function getParentAnnotation(annotation) {
+    return annotation.parentAnnotationUID
+        ? getAnnotation(annotation.parentAnnotationUID)
+        : undefined;
+}
+function getChildAnnotations(annotation) {
+    return (annotation.childAnnotationUIDs?.map((childAnnotationUID) => getAnnotation(childAnnotationUID)) ?? []);
+}
 function addAnnotation(annotation, annotationGroupSelector) {
-    if (annotation.annotationUID === undefined) {
+    if (!annotation.annotationUID) {
         annotation.annotationUID = csUtils.uuidv4();
     }
     const manager = getAnnotationManager();
-    const groupKey = manager.getGroupKey(annotationGroupSelector);
-    manager.addAnnotation(annotation, groupKey);
     if (annotationGroupSelector instanceof HTMLDivElement) {
+        const groupKey = manager.getGroupKey(annotationGroupSelector);
+        manager.addAnnotation(annotation, groupKey);
         triggerAnnotationAddedForElement(annotation, annotationGroupSelector);
     }
     else {
+        manager.addAnnotation(annotation, undefined);
         triggerAnnotationAddedForFOR(annotation);
     }
     return annotation.annotationUID;
@@ -38,27 +85,46 @@ function getNumberOfAnnotations(toolName, annotationGroupSelector) {
     return manager.getNumberOfAnnotations(groupKey, toolName);
 }
 function removeAnnotation(annotationUID) {
+    if (!annotationUID) {
+        return;
+    }
     const manager = getAnnotationManager();
     const annotation = manager.getAnnotation(annotationUID);
     if (!annotation) {
         return;
     }
+    annotation.childAnnotationUIDs?.forEach((childAnnotationUID) => removeAnnotation(childAnnotationUID));
     manager.removeAnnotation(annotationUID);
-    const eventType = Events.ANNOTATION_REMOVED;
-    const eventDetail = {
-        annotation,
-        annotationManagerUID: manager.uid,
-    };
-    triggerEvent(eventTarget, eventType, eventDetail);
+    triggerAnnotationRemoved({ annotation, annotationManagerUID: manager.uid });
 }
-function getAnnotation(annotationUID) {
+function removeAllAnnotations() {
     const manager = getAnnotationManager();
-    const annotation = manager.getAnnotation(annotationUID);
-    return annotation;
+    const removedAnnotations = manager.removeAllAnnotations();
+    for (const annotation of removedAnnotations) {
+        triggerAnnotationRemoved({
+            annotation,
+            annotationManagerUID: manager.uid,
+        });
+    }
 }
-function removeAllAnnotations() {
+function removeAnnotations(toolName, annotationGroupSelector) {
     const manager = getAnnotationManager();
-    manager.removeAllAnnotations();
+    const groupKey = manager.getGroupKey(annotationGroupSelector);
+    const removedAnnotations = manager.removeAnnotations(groupKey, toolName);
+    for (const annotation of removedAnnotations) {
+        triggerAnnotationRemoved({
+            annotation,
+            annotationManagerUID: manager.uid,
+        });
+    }
+}
+function invalidateAnnotation(annotation) {
+    let currAnnotation = annotation;
+    while (currAnnotation) {
+        currAnnotation.invalidated = true;
+        currAnnotation = currAnnotation.parentAnnotationUID
+            ? getAnnotation(currAnnotation.parentAnnotationUID)
+            : undefined;
+    }
 }
-export { getAnnotations, getNumberOfAnnotations, addAnnotation, getAnnotation, removeAnnotation, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, };
-//# sourceMappingURL=annotationState.js.map
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, getAnnotation, };

package/dist/esm/stateManagement/annotation/annotationVisibility.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../types';
+import type { Annotation } from '../../types';
 declare function setAnnotationVisibility(annotationUID: string, visible?: boolean): void;
 declare function showAllAnnotations(): void;
 declare function isAnnotationVisible(annotationUID: string): boolean | undefined;

package/dist/esm/stateManagement/annotation/annotationVisibility.js

@@ -1,7 +1,7 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
-import { getAnnotation } from './annotationState';
 import { Events } from '../../enums';
 import { isAnnotationSelected, deselectAnnotation, } from './annotationSelection';
+import { getAnnotation } from './getAnnotation';
 const globalHiddenAnnotationUIDsSet = new Set();
 function setAnnotationVisibility(annotationUID, visible = true) {
     const detail = makeEventDetail();
@@ -84,4 +84,3 @@ function getIsVisible() {
     return isAnnotationVisible(this.annotationUID);
 }
 export { setAnnotationVisibility, showAllAnnotations, isAnnotationVisible, checkAndDefineIsVisibleProperty, };
-//# sourceMappingURL=annotationVisibility.js.map

package/dist/esm/stateManagement/annotation/config/ToolStyle.d.ts

@@ -1,4 +1,4 @@
-import { StyleConfig, ToolStyleConfig, StyleSpecifier, AnnotationStyle } from '../../../types/AnnotationStyle';
+import type { StyleConfig, ToolStyleConfig, StyleSpecifier, AnnotationStyle } from '../../../types/AnnotationStyle';
 declare class ToolStyle {
     config: StyleConfig;
     constructor();

package/dist/esm/stateManagement/annotation/config/ToolStyle.js

@@ -76,40 +76,45 @@ class ToolStyle {
     }
     _getToolStyle(property, annotationUID, viewportId, toolGroupId, toolName) {
         if (annotationUID) {
-            const styles = this.getAnnotationToolStyles(annotationUID);
-            if (styles) {
-                if (styles[property]) {
-                    return styles[property];
+            const annotationToolStyles = this.getAnnotationToolStyles(annotationUID);
+            if (annotationToolStyles) {
+                if (annotationToolStyles[property] !== undefined) {
+                    return annotationToolStyles[property];
                 }
             }
         }
         if (viewportId) {
-            const styles = this.getViewportToolStyles(viewportId);
-            if (styles) {
-                if (styles[toolName] && styles[toolName][property]) {
-                    return styles[toolName][property];
+            const viewportToolStyles = this.getViewportToolStyles(viewportId);
+            if (viewportToolStyles) {
+                if (viewportToolStyles[toolName] &&
+                    viewportToolStyles[toolName][property] !== undefined) {
+                    return viewportToolStyles[toolName][property];
                 }
-                if (styles.global && styles.global[property]) {
-                    return styles.global[property];
+                if (viewportToolStyles.global &&
+                    viewportToolStyles.global[property] !== undefined) {
+                    return viewportToolStyles.global[property];
                 }
             }
         }
         if (toolGroupId) {
-            const styles = this.getToolGroupToolStyles(toolGroupId);
-            if (styles) {
-                if (styles[toolName] && styles[toolName][property]) {
-                    return styles[toolName][property];
+            const toolGroupToolStyles = this.getToolGroupToolStyles(toolGroupId);
+            if (toolGroupToolStyles) {
+                if (toolGroupToolStyles[toolName] &&
+                    toolGroupToolStyles[toolName][property] !== undefined) {
+                    return toolGroupToolStyles[toolName][property];
                 }
-                if (styles.global && styles.global[property]) {
-                    return styles.global[property];
+                if (toolGroupToolStyles.global &&
+                    toolGroupToolStyles.global[property] !== undefined) {
+                    return toolGroupToolStyles.global[property];
                 }
             }
         }
         const globalStyles = this.getDefaultToolStyles();
-        if (globalStyles[toolName] && globalStyles[toolName][property]) {
+        if (globalStyles[toolName] &&
+            globalStyles[toolName][property] !== undefined) {
             return globalStyles[toolName][property];
         }
-        if (globalStyles.global && globalStyles.global[property]) {
+        if (globalStyles.global && globalStyles.global[property] !== undefined) {
             return globalStyles.global[property];
         }
     }
@@ -127,4 +132,3 @@ class ToolStyle {
 }
 const toolStyle = new ToolStyle();
 export default toolStyle;
-//# sourceMappingURL=ToolStyle.js.map

package/dist/esm/stateManagement/annotation/config/getFont.d.ts

@@ -1,4 +1,4 @@
-import { ToolModes, AnnotationStyleStates } from '../../../enums';
-import { StyleSpecifier } from '../../../types/AnnotationStyle';
+import type { ToolModes, AnnotationStyleStates } from '../../../enums';
+import type { StyleSpecifier } from '../../../types/AnnotationStyle';
 declare function getFont(styleSpecifier: StyleSpecifier, state?: AnnotationStyleStates, mode?: ToolModes): string;
 export default getFont;

package/dist/esm/stateManagement/annotation/config/getFont.js

@@ -5,4 +5,3 @@ function getFont(styleSpecifier, state, mode) {
     return `${fontSize}px ${fontFamily}`;
 }
 export default getFont;
-//# sourceMappingURL=getFont.js.map

package/dist/esm/stateManagement/annotation/config/getState.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../../types';
+import type { Annotation } from '../../../types';
 import { AnnotationStyleStates } from '../../../enums';
 declare function getState(annotation?: Annotation): AnnotationStyleStates;
 export default getState;

package/dist/esm/stateManagement/annotation/config/getState.js

@@ -12,8 +12,10 @@ function getState(annotation) {
         if (isAnnotationLocked(annotation)) {
             return AnnotationStyleStates.Locked;
         }
+        if (annotation.data && annotation.autoGenerated) {
+            return AnnotationStyleStates.AutoGenerated;
+        }
     }
     return AnnotationStyleStates.Default;
 }
 export default getState;
-//# sourceMappingURL=getState.js.map

package/dist/esm/stateManagement/annotation/config/helpers.d.ts

@@ -1,4 +1,4 @@
-import { StyleSpecifier } from '../../../types/AnnotationStyle';
-import { ToolModes, AnnotationStyleStates } from '../../../enums';
+import type { StyleSpecifier } from '../../../types/AnnotationStyle';
+import type { ToolModes, AnnotationStyleStates } from '../../../enums';
 declare function getStyleProperty(property: string, styleSpecifier: StyleSpecifier, state?: AnnotationStyleStates, mode?: ToolModes): string;
 export { getStyleProperty };

package/dist/esm/stateManagement/annotation/config/helpers.js

@@ -19,4 +19,3 @@ function getStyleProperty(property, styleSpecifier, state, mode) {
     }
 }
 export { getStyleProperty };
-//# sourceMappingURL=helpers.js.map

package/dist/esm/stateManagement/annotation/config/index.js

@@ -2,4 +2,3 @@ import getState from './getState';
 import getFont from './getFont';
 import style from './ToolStyle';
 export { getState, getFont, style };
-//# sourceMappingURL=index.js.map

package/dist/esm/stateManagement/annotation/getAnnotation.d.ts

@@ -0,0 +1,2 @@
+import type { Annotation } from '../../types';
+export declare function getAnnotation(annotationUID: string): Annotation;

package/dist/esm/stateManagement/annotation/getAnnotation.js

@@ -0,0 +1,6 @@
+import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
+export function getAnnotation(annotationUID) {
+    const manager = defaultFrameOfReferenceSpecificAnnotationManager;
+    const annotation = manager.getAnnotation(annotationUID);
+    return annotation;
+}

package/dist/esm/stateManagement/annotation/helpers/state.d.ts

@@ -1,4 +1,10 @@
-import { Annotation } from '../../../types/AnnotationTypes';
+import { ChangeTypes } from '../../../enums';
+import type { Annotation } from '../../../types/AnnotationTypes';
+import type { AnnotationRemovedEventDetail } from '../../../types/EventTypes';
 declare function triggerAnnotationAddedForElement(annotation: Annotation, element: HTMLDivElement): void;
 declare function triggerAnnotationAddedForFOR(annotation: Annotation): void;
-export { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR };
+declare function triggerAnnotationRemoved(eventDetail: AnnotationRemovedEventDetail): void;
+declare function triggerAnnotationModified(annotation: Annotation, element: HTMLDivElement, changeType?: ChangeTypes): void;
+declare function triggerAnnotationCompleted(annotation: Annotation): void;
+declare function triggerContourAnnotationCompleted(annotation: Annotation, contourHoleProcessingEnabled?: boolean): void;
+export { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, triggerAnnotationRemoved, triggerAnnotationModified, triggerAnnotationCompleted, triggerContourAnnotationCompleted, };

package/dist/esm/stateManagement/annotation/helpers/state.js

@@ -1,5 +1,5 @@
 import { getEnabledElement, triggerEvent, eventTarget, getEnabledElementByIds, } from '@cornerstonejs/core';
-import { Events } from '../../../enums';
+import { Events, ChangeTypes } from '../../../enums';
 import { getToolGroupsWithToolName } from '../../../store/ToolGroupManager';
 function triggerAnnotationAddedForElement(annotation, element) {
     const enabledElement = getEnabledElement(element);
@@ -28,18 +28,49 @@ function triggerAnnotationAddedForFOR(annotation) {
             }
         });
     });
+    const eventType = Events.ANNOTATION_ADDED;
+    const eventDetail = { annotation };
     if (!viewportsToRender.length) {
+        triggerEvent(eventTarget, eventType, eventDetail);
         return;
     }
-    const eventType = Events.ANNOTATION_ADDED;
     viewportsToRender.forEach(({ renderingEngineId, viewportId }) => {
-        const eventDetail = {
-            annotation,
-            viewportId,
-            renderingEngineId,
-        };
+        eventDetail.viewportId = viewportId;
+        eventDetail.renderingEngineId = renderingEngineId;
         triggerEvent(eventTarget, eventType, eventDetail);
     });
 }
-export { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR };
-//# sourceMappingURL=state.js.map
+function triggerAnnotationRemoved(eventDetail) {
+    const eventType = Events.ANNOTATION_REMOVED;
+    triggerEvent(eventTarget, eventType, eventDetail);
+}
+function triggerAnnotationModified(annotation, element, changeType = ChangeTypes.HandlesUpdated) {
+    const enabledElement = getEnabledElement(element);
+    const { viewportId, renderingEngineId } = enabledElement;
+    const eventType = Events.ANNOTATION_MODIFIED;
+    const eventDetail = {
+        annotation,
+        viewportId,
+        renderingEngineId,
+        changeType,
+    };
+    triggerEvent(eventTarget, eventType, eventDetail);
+}
+function triggerAnnotationCompleted(annotation) {
+    const eventDetail = {
+        annotation,
+    };
+    _triggerAnnotationCompleted(eventDetail);
+}
+function triggerContourAnnotationCompleted(annotation, contourHoleProcessingEnabled = false) {
+    const eventDetail = {
+        annotation,
+        contourHoleProcessingEnabled,
+    };
+    _triggerAnnotationCompleted(eventDetail);
+}
+function _triggerAnnotationCompleted(eventDetail) {
+    const eventType = Events.ANNOTATION_COMPLETED;
+    triggerEvent(eventTarget, eventType, eventDetail);
+}
+export { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, triggerAnnotationRemoved, triggerAnnotationModified, triggerAnnotationCompleted, triggerContourAnnotationCompleted, };

package/dist/esm/stateManagement/annotation/index.d.ts

@@ -4,4 +4,5 @@ import * as selection from './annotationSelection';
 import * as state from './annotationState';
 import * as visibility from './annotationVisibility';
 import FrameOfReferenceSpecificAnnotationManager from './FrameOfReferenceSpecificAnnotationManager';
-export { config, locking, selection, state, visibility, FrameOfReferenceSpecificAnnotationManager, };
+import AnnotationGroup from './AnnotationGroup';
+export { config, locking, selection, state, visibility, FrameOfReferenceSpecificAnnotationManager, AnnotationGroup, };

package/dist/esm/stateManagement/annotation/index.js

@@ -4,5 +4,5 @@ import * as selection from './annotationSelection';
 import * as state from './annotationState';
 import * as visibility from './annotationVisibility';
 import FrameOfReferenceSpecificAnnotationManager from './FrameOfReferenceSpecificAnnotationManager';
-export { config, locking, selection, state, visibility, FrameOfReferenceSpecificAnnotationManager, };
-//# sourceMappingURL=index.js.map
+import AnnotationGroup from './AnnotationGroup';
+export { config, locking, selection, state, visibility, FrameOfReferenceSpecificAnnotationManager, AnnotationGroup, };

package/dist/esm/stateManagement/annotation/utilities/defineProperties.d.ts

@@ -0,0 +1,4 @@
+import type { Annotation } from '../../../types';
+declare const checkAndDefineTextBoxProperty: (annotation: Annotation) => Annotation;
+declare const checkAndDefineCachedStatsProperty: (annotation: Annotation) => Annotation;
+export { checkAndDefineTextBoxProperty, checkAndDefineCachedStatsProperty };

package/dist/esm/stateManagement/annotation/utilities/defineProperties.js

@@ -0,0 +1,22 @@
+const checkAndDefineTextBoxProperty = (annotation) => {
+    if (!annotation.data) {
+        annotation.data = {};
+    }
+    if (!annotation.data.handles) {
+        annotation.data.handles = {};
+    }
+    if (!annotation.data.handles.textBox) {
+        annotation.data.handles.textBox = {};
+    }
+    return annotation;
+};
+const checkAndDefineCachedStatsProperty = (annotation) => {
+    if (!annotation.data) {
+        annotation.data = {};
+    }
+    if (!annotation.data.cachedStats) {
+        annotation.data.cachedStats = {};
+    }
+    return annotation;
+};
+export { checkAndDefineTextBoxProperty, checkAndDefineCachedStatsProperty };