@cornerstonejs/tools 3.0.2 → 3.0.4

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

@@ -0,0 +1,118 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, triggerAnnotationRemoved, } from './helpers/state';
+let defaultManager;
+function getAnnotationManager() {
+    return defaultManager;
+}
+function setAnnotationManager(annotationManager) {
+    defaultManager = annotationManager;
+}
+function getAnnotations(toolName, annotationGroupSelector) {
+    const manager = getAnnotationManager();
+    const groupKey = manager.getGroupKey(annotationGroupSelector);
+    return manager.getAnnotations(groupKey, toolName);
+}
+function getAnnotation(annotationUID) {
+    const manager = getAnnotationManager();
+    return manager.getAnnotation(annotationUID);
+}
+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) {
+        annotation.annotationUID = csUtils.uuidv4();
+    }
+    const manager = getAnnotationManager();
+    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;
+}
+function getNumberOfAnnotations(toolName, annotationGroupSelector) {
+    const manager = getAnnotationManager();
+    const groupKey = manager.getGroupKey(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);
+    triggerAnnotationRemoved({ annotation, annotationManagerUID: manager.uid });
+}
+function removeAllAnnotations() {
+    const manager = getAnnotationManager();
+    const removedAnnotations = manager.removeAllAnnotations();
+    for (const annotation of removedAnnotations) {
+        triggerAnnotationRemoved({
+            annotation,
+            annotationManagerUID: manager.uid,
+        });
+    }
+}
+function removeAnnotations(toolName, annotationGroupSelector) {
+    const manager = getAnnotationManager();
+    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 { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, invalidateAnnotation, getAnnotation, };

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

@@ -0,0 +1,5 @@
+declare function setAnnotationVisibility(annotationUID: string, visible?: boolean): void;
+declare function showAllAnnotations(): void;
+declare function isAnnotationVisible(annotationUID: string): boolean | undefined;
+declare function checkAndSetAnnotationVisibility(annotationUID: string): boolean;
+export { setAnnotationVisibility, showAllAnnotations, isAnnotationVisible, checkAndSetAnnotationVisibility, };

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

@@ -0,0 +1,65 @@
+import { eventTarget, triggerEvent } from '@cornerstonejs/core';
+import { Events } from '../../enums';
+import { isAnnotationSelected, deselectAnnotation, } from './annotationSelection';
+import { getAnnotation } from './annotationState';
+const globalHiddenAnnotationUIDsSet = new Set();
+function setAnnotationVisibility(annotationUID, visible = true) {
+    const detail = makeEventDetail();
+    if (annotationUID) {
+        if (visible) {
+            show(annotationUID, globalHiddenAnnotationUIDsSet, detail);
+        }
+        else {
+            hide(annotationUID, globalHiddenAnnotationUIDsSet, detail);
+        }
+    }
+    publish(detail);
+}
+function showAllAnnotations() {
+    const detail = makeEventDetail();
+    globalHiddenAnnotationUIDsSet.forEach((annotationUID) => {
+        show(annotationUID, globalHiddenAnnotationUIDsSet, detail);
+    });
+    publish(detail);
+}
+function isAnnotationVisible(annotationUID) {
+    const annotation = getAnnotation(annotationUID);
+    if (annotation) {
+        return !globalHiddenAnnotationUIDsSet.has(annotationUID);
+    }
+}
+function makeEventDetail() {
+    return Object.freeze({
+        lastVisible: [],
+        lastHidden: [],
+        hidden: [],
+    });
+}
+function show(annotationUID, annotationUIDsSet, detail) {
+    if (annotationUIDsSet.delete(annotationUID)) {
+        detail.lastVisible.push(annotationUID);
+        const annotation = getAnnotation(annotationUID);
+        annotation.isVisible = true;
+    }
+}
+function hide(annotationUID, annotationUIDsSet, detail) {
+    if (!annotationUIDsSet.has(annotationUID)) {
+        annotationUIDsSet.add(annotationUID);
+        if (isAnnotationSelected(annotationUID)) {
+            deselectAnnotation(annotationUID);
+        }
+        detail.lastHidden.push(annotationUID);
+    }
+}
+function publish(detail) {
+    if (detail.lastHidden.length > 0 || detail.lastVisible.length > 0) {
+        globalHiddenAnnotationUIDsSet.forEach((item) => void detail.hidden.push(item));
+        triggerEvent(eventTarget, Events.ANNOTATION_VISIBILITY_CHANGE, detail);
+    }
+}
+function checkAndSetAnnotationVisibility(annotationUID) {
+    const isVisible = !globalHiddenAnnotationUIDsSet.has(annotationUID);
+    setAnnotationVisibility(annotationUID, isVisible);
+    return isVisible;
+}
+export { setAnnotationVisibility, showAllAnnotations, isAnnotationVisible, checkAndSetAnnotationVisibility, };

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

@@ -0,0 +1,18 @@
+import type { StyleConfig, ToolStyleConfig, StyleSpecifier, AnnotationStyle } from '../../../types/AnnotationStyle';
+declare class ToolStyle {
+    config: StyleConfig;
+    constructor();
+    getAnnotationToolStyles(annotationUID: string): AnnotationStyle;
+    getViewportToolStyles(viewportId: string): ToolStyleConfig;
+    getToolGroupToolStyles(toolGroupId: string): ToolStyleConfig;
+    getDefaultToolStyles(): ToolStyleConfig;
+    setAnnotationStyles(annotationUID: string, styles: AnnotationStyle): void;
+    setViewportToolStyles(viewportId: string, styles: ToolStyleConfig): void;
+    setToolGroupToolStyles(toolGroupId: string, styles: ToolStyleConfig): void;
+    setDefaultToolStyles(styles: ToolStyleConfig): void;
+    getStyleProperty(toolStyle: string, specifications: StyleSpecifier): any;
+    private _getToolStyle;
+    private _initializeConfig;
+}
+declare const toolStyle: ToolStyle;
+export default toolStyle;

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

@@ -0,0 +1,135 @@
+class ToolStyle {
+    constructor() {
+        const defaultConfig = {
+            color: 'rgb(255, 255, 0)',
+            colorHighlighted: 'rgb(0, 255, 0)',
+            colorSelected: 'rgb(0, 220, 0)',
+            colorLocked: 'rgb(209, 193, 90)',
+            lineWidth: '1',
+            lineDash: '',
+            shadow: true,
+            textBoxVisibility: true,
+            textBoxFontFamily: 'Helvetica Neue, Helvetica, Arial, sans-serif',
+            textBoxFontSize: '14px',
+            textBoxColor: 'rgb(255, 255, 0)',
+            textBoxColorHighlighted: 'rgb(0, 255, 0)',
+            textBoxColorSelected: 'rgb(0, 255, 0)',
+            textBoxColorLocked: 'rgb(209, 193, 90)',
+            textBoxBackground: '',
+            textBoxLinkLineWidth: '1',
+            textBoxLinkLineDash: '2,3',
+            textBoxShadow: true,
+            markerSize: '10',
+        };
+        this._initializeConfig(defaultConfig);
+    }
+    getAnnotationToolStyles(annotationUID) {
+        return this.config.annotations && this.config.annotations[annotationUID];
+    }
+    getViewportToolStyles(viewportId) {
+        return this.config.viewports && this.config.viewports[viewportId];
+    }
+    getToolGroupToolStyles(toolGroupId) {
+        return this.config.toolGroups && this.config.toolGroups[toolGroupId];
+    }
+    getDefaultToolStyles() {
+        return this.config.default;
+    }
+    setAnnotationStyles(annotationUID, styles) {
+        let annotationSpecificStyles = this.config.annotations;
+        if (!annotationSpecificStyles) {
+            this.config = {
+                ...this.config,
+                annotations: {},
+            };
+            annotationSpecificStyles = this.config.annotations;
+        }
+        annotationSpecificStyles[annotationUID] = styles;
+    }
+    setViewportToolStyles(viewportId, styles) {
+        let viewportSpecificStyles = this.config.viewports;
+        if (!viewportSpecificStyles) {
+            this.config = {
+                ...this.config,
+                viewports: {},
+            };
+            viewportSpecificStyles = this.config.viewports;
+        }
+        viewportSpecificStyles[viewportId] = styles;
+    }
+    setToolGroupToolStyles(toolGroupId, styles) {
+        let toolGroupSpecificStyles = this.config.toolGroups;
+        if (!toolGroupSpecificStyles) {
+            this.config = {
+                ...this.config,
+                toolGroups: {},
+            };
+            toolGroupSpecificStyles = this.config.toolGroups;
+        }
+        toolGroupSpecificStyles[toolGroupId] = styles;
+    }
+    setDefaultToolStyles(styles) {
+        this.config.default = styles;
+    }
+    getStyleProperty(toolStyle, specifications) {
+        const { annotationUID, viewportId, toolGroupId, toolName } = specifications;
+        return this._getToolStyle(toolStyle, annotationUID, viewportId, toolGroupId, toolName);
+    }
+    _getToolStyle(property, annotationUID, viewportId, toolGroupId, toolName) {
+        if (annotationUID) {
+            const annotationToolStyles = this.getAnnotationToolStyles(annotationUID);
+            if (annotationToolStyles) {
+                if (annotationToolStyles[property] !== undefined) {
+                    return annotationToolStyles[property];
+                }
+            }
+        }
+        if (viewportId) {
+            const viewportToolStyles = this.getViewportToolStyles(viewportId);
+            if (viewportToolStyles) {
+                if (viewportToolStyles[toolName] &&
+                    viewportToolStyles[toolName][property] !== undefined) {
+                    return viewportToolStyles[toolName][property];
+                }
+                if (viewportToolStyles.global &&
+                    viewportToolStyles.global[property] !== undefined) {
+                    return viewportToolStyles.global[property];
+                }
+            }
+        }
+        if (toolGroupId) {
+            const toolGroupToolStyles = this.getToolGroupToolStyles(toolGroupId);
+            if (toolGroupToolStyles) {
+                if (toolGroupToolStyles[toolName] &&
+                    toolGroupToolStyles[toolName][property] !== undefined) {
+                    return toolGroupToolStyles[toolName][property];
+                }
+                if (toolGroupToolStyles.global &&
+                    toolGroupToolStyles.global[property] !== undefined) {
+                    return toolGroupToolStyles.global[property];
+                }
+            }
+        }
+        const globalStyles = this.getDefaultToolStyles();
+        if (globalStyles[toolName] &&
+            globalStyles[toolName][property] !== undefined) {
+            return globalStyles[toolName][property];
+        }
+        if (globalStyles.global && globalStyles.global[property] !== undefined) {
+            return globalStyles.global[property];
+        }
+    }
+    _initializeConfig(config) {
+        const toolStyles = {};
+        for (const name in config) {
+            toolStyles[name] = config[name];
+        }
+        this.config = {
+            default: {
+                global: toolStyles,
+            },
+        };
+    }
+}
+const toolStyle = new ToolStyle();
+export default toolStyle;

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,7 @@
+import { getStyleProperty } from './helpers';
+function getFont(styleSpecifier, state, mode) {
+    const fontSize = getStyleProperty('textBoxFontSize', styleSpecifier, state, mode);
+    const fontFamily = getStyleProperty('textBoxFontFamily', styleSpecifier, state, mode);
+    return `${fontSize}px ${fontFamily}`;
+}
+export default getFont;

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,21 @@
+import { isAnnotationLocked } from '../annotationLocking';
+import { isAnnotationSelected } from '../annotationSelection';
+import { AnnotationStyleStates } from '../../../enums';
+function getState(annotation) {
+    if (annotation) {
+        if (annotation.data && annotation.highlighted) {
+            return AnnotationStyleStates.Highlighted;
+        }
+        if (isAnnotationSelected(annotation.annotationUID)) {
+            return AnnotationStyleStates.Selected;
+        }
+        if (isAnnotationLocked(annotation.annotationUID)) {
+            return AnnotationStyleStates.Locked;
+        }
+        if (annotation.data && annotation.autoGenerated) {
+            return AnnotationStyleStates.AutoGenerated;
+        }
+    }
+    return AnnotationStyleStates.Default;
+}
+export default getState;

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,21 @@
+import toolStyle from './ToolStyle';
+function getHierarchalPropertyStyles(property, state, mode) {
+    const list = [`${property}`];
+    if (state) {
+        list.push(`${list[0]}${state}`);
+    }
+    if (mode) {
+        list.push(`${list[list.length - 1]}${mode}`);
+    }
+    return list;
+}
+function getStyleProperty(property, styleSpecifier, state, mode) {
+    const alternatives = getHierarchalPropertyStyles(property, state, mode);
+    for (let i = alternatives.length - 1; i >= 0; --i) {
+        const style = toolStyle.getStyleProperty(alternatives[i], styleSpecifier);
+        if (style !== undefined) {
+            return style;
+        }
+    }
+}
+export { getStyleProperty };

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

@@ -0,0 +1,4 @@
+import getState from './getState';
+import getFont from './getFont';
+import style from './ToolStyle';
+export { getState, getFont, style };

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

@@ -0,0 +1,4 @@
+import getState from './getState';
+import getFont from './getFont';
+import style from './ToolStyle';
+export { getState, getFont, style };

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

@@ -0,0 +1,10 @@
+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;
+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

@@ -0,0 +1,76 @@
+import { getEnabledElement, triggerEvent, eventTarget, getEnabledElementByIds, } from '@cornerstonejs/core';
+import { Events, ChangeTypes } from '../../../enums';
+import { getToolGroupsWithToolName } from '../../../store/ToolGroupManager';
+function triggerAnnotationAddedForElement(annotation, element) {
+    const enabledElement = getEnabledElement(element);
+    const { renderingEngine, viewportId } = enabledElement;
+    const eventType = Events.ANNOTATION_ADDED;
+    const eventDetail = {
+        annotation,
+        viewportId,
+        renderingEngineId: renderingEngine.id,
+    };
+    triggerEvent(eventTarget, eventType, eventDetail);
+}
+function triggerAnnotationAddedForFOR(annotation) {
+    const { toolName } = annotation.metadata;
+    const toolGroups = getToolGroupsWithToolName(toolName);
+    if (!toolGroups.length) {
+        return;
+    }
+    const viewportsToRender = [];
+    toolGroups.forEach((toolGroup) => {
+        toolGroup.viewportsInfo.forEach((viewportInfo) => {
+            const { renderingEngineId, viewportId } = viewportInfo;
+            const { FrameOfReferenceUID } = getEnabledElementByIds(viewportId, renderingEngineId);
+            if (annotation.metadata.FrameOfReferenceUID === FrameOfReferenceUID) {
+                viewportsToRender.push(viewportInfo);
+            }
+        });
+    });
+    const eventType = Events.ANNOTATION_ADDED;
+    const eventDetail = { annotation };
+    if (!viewportsToRender.length) {
+        triggerEvent(eventTarget, eventType, eventDetail);
+        return;
+    }
+    viewportsToRender.forEach(({ renderingEngineId, viewportId }) => {
+        eventDetail.viewportId = viewportId;
+        eventDetail.renderingEngineId = renderingEngineId;
+        triggerEvent(eventTarget, eventType, eventDetail);
+    });
+}
+function triggerAnnotationRemoved(eventDetail) {
+    const eventType = Events.ANNOTATION_REMOVED;
+    triggerEvent(eventTarget, eventType, eventDetail);
+}
+function triggerAnnotationModified(annotation, element, changeType = ChangeTypes.HandlesUpdated) {
+    const enabledElement = element && 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

@@ -0,0 +1,34 @@
+import * as config from './config';
+import * as locking from './annotationLocking';
+import * as selection from './annotationSelection';
+import * as annotationState from './annotationState';
+import * as annotationStateHelpers from './helpers/state';
+import * as visibility from './annotationVisibility';
+import FrameOfReferenceSpecificAnnotationManager from './FrameOfReferenceSpecificAnnotationManager';
+import AnnotationGroup from './AnnotationGroup';
+import { resetAnnotationManager } from './resetAnnotationManager';
+declare const state: {
+    resetAnnotationManager: typeof resetAnnotationManager;
+    triggerAnnotationAddedForElement: typeof annotationStateHelpers.triggerAnnotationAddedForElement;
+    triggerAnnotationAddedForFOR: typeof annotationStateHelpers.triggerAnnotationAddedForFOR;
+    triggerAnnotationRemoved: typeof annotationStateHelpers.triggerAnnotationRemoved;
+    triggerAnnotationModified: typeof annotationStateHelpers.triggerAnnotationModified;
+    triggerAnnotationCompleted: typeof annotationStateHelpers.triggerAnnotationCompleted;
+    triggerContourAnnotationCompleted: typeof annotationStateHelpers.triggerContourAnnotationCompleted;
+    getAllAnnotations: typeof annotationState.getAllAnnotations;
+    getAnnotations: typeof annotationState.getAnnotations;
+    getParentAnnotation: typeof annotationState.getParentAnnotation;
+    getChildAnnotations: typeof annotationState.getChildAnnotations;
+    clearParentAnnotation: typeof annotationState.clearParentAnnotation;
+    addChildAnnotation: typeof annotationState.addChildAnnotation;
+    getNumberOfAnnotations: typeof annotationState.getNumberOfAnnotations;
+    addAnnotation: typeof annotationState.addAnnotation;
+    removeAnnotation: typeof annotationState.removeAnnotation;
+    removeAnnotations: typeof annotationState.removeAnnotations;
+    removeAllAnnotations: typeof annotationState.removeAllAnnotations;
+    setAnnotationManager: typeof annotationState.setAnnotationManager;
+    getAnnotationManager: typeof annotationState.getAnnotationManager;
+    invalidateAnnotation: typeof annotationState.invalidateAnnotation;
+    getAnnotation: typeof annotationState.getAnnotation;
+};
+export { config, locking, selection, state, visibility, FrameOfReferenceSpecificAnnotationManager, AnnotationGroup, };

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

@@ -0,0 +1,15 @@
+import * as config from './config';
+import * as locking from './annotationLocking';
+import * as selection from './annotationSelection';
+import * as annotationState from './annotationState';
+import * as annotationStateHelpers from './helpers/state';
+import * as visibility from './annotationVisibility';
+import FrameOfReferenceSpecificAnnotationManager from './FrameOfReferenceSpecificAnnotationManager';
+import AnnotationGroup from './AnnotationGroup';
+import { resetAnnotationManager } from './resetAnnotationManager';
+const state = {
+    ...annotationState,
+    ...annotationStateHelpers,
+    resetAnnotationManager,
+};
+export { config, locking, selection, state, visibility, FrameOfReferenceSpecificAnnotationManager, AnnotationGroup, };

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

@@ -0,0 +1 @@
+export declare function resetAnnotationManager(): void;

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

@@ -0,0 +1,21 @@
+import { checkAndDefineCachedStatsProperty, checkAndDefineTextBoxProperty, } from './utilities/defineProperties';
+import { checkAndSetAnnotationLocked } from './annotationLocking';
+import { checkAndSetAnnotationVisibility } from './annotationVisibility';
+import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
+import { setAnnotationManager } from './annotationState';
+const defaultManager = defaultFrameOfReferenceSpecificAnnotationManager;
+const preprocessingFn = (annotation) => {
+    annotation = checkAndDefineTextBoxProperty(annotation);
+    annotation = checkAndDefineCachedStatsProperty(annotation);
+    const uid = annotation.annotationUID;
+    const isLocked = checkAndSetAnnotationLocked(uid);
+    annotation.isLocked = isLocked;
+    const isVisible = checkAndSetAnnotationVisibility(uid);
+    annotation.isVisible = isVisible;
+    return annotation;
+};
+defaultManager.setPreprocessingFn(preprocessingFn);
+setAnnotationManager(defaultManager);
+export function resetAnnotationManager() {
+    setAnnotationManager(defaultManager);
+}

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 };

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

@@ -0,0 +1,18 @@
+import FrameOfReferenceSpecificAnnotationManager from './annotation/FrameOfReferenceSpecificAnnotationManager';
+import { defaultFrameOfReferenceSpecificAnnotationManager } from './annotation/FrameOfReferenceSpecificAnnotationManager';
+import * as annotationLocking from './annotation/annotationLocking';
+import * as annotationSelection from './annotation/annotationSelection';
+import { getAnnotations } from './annotation/annotationState';
+import { addAnnotation } from './annotation/annotationState';
+import { getNumberOfAnnotations } from './annotation/annotationState';
+import { removeAnnotation } from './annotation/annotationState';
+import { getAnnotation } from './annotation/annotationState';
+import { getParentAnnotation } from './annotation/annotationState';
+import { getChildAnnotations } from './annotation/annotationState';
+import { clearParentAnnotation } from './annotation/annotationState';
+import { addChildAnnotation } from './annotation/annotationState';
+import { setAnnotationManager } from './annotation/annotationState';
+import { getAnnotationManager } from './annotation/annotationState';
+import { resetAnnotationManager } from './annotation/resetAnnotationManager';
+import { invalidateAnnotation } from './annotation/annotationState';
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation };

package/dist/esm/stateManagement/index.js

@@ -0,0 +1,6 @@
+import FrameOfReferenceSpecificAnnotationManager, { defaultFrameOfReferenceSpecificAnnotationManager, } from './annotation/FrameOfReferenceSpecificAnnotationManager';
+import * as annotationLocking from './annotation/annotationLocking';
+import * as annotationSelection from './annotation/annotationSelection';
+import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
+import { resetAnnotationManager } from './annotation/resetAnnotationManager';
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, };