@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/drawingSvg/drawRedactionRect.js

@@ -0,0 +1,37 @@
+import _getHash from './_getHash';
+import _setAttributesIfNecessary from './setAttributesIfNecessary';
+import _setNewAttributesIfValid from './setNewAttributesIfValid';
+export default function drawRedactionRect(svgDrawingHelper, annotationUID, rectangleUID, start, end, options = {}) {
+    const { color, width: _width, lineWidth, lineDash, } = Object.assign({
+        color: 'rgb(0, 255, 0)',
+        width: '2',
+        lineWidth: undefined,
+        lineDash: undefined,
+    }, options);
+    const strokeWidth = lineWidth || _width;
+    const svgns = 'http://www.w3.org/2000/svg';
+    const svgNodeHash = _getHash(annotationUID, 'rect', rectangleUID);
+    const existingRect = svgDrawingHelper.getSvgNode(svgNodeHash);
+    const tlhc = [Math.min(start[0], end[0]), Math.min(start[1], end[1])];
+    const width = Math.abs(start[0] - end[0]);
+    const height = Math.abs(start[1] - end[1]);
+    const attributes = {
+        x: `${tlhc[0]}`,
+        y: `${tlhc[1]}`,
+        width: `${width}`,
+        height: `${height}`,
+        stroke: color,
+        fill: 'black',
+        'stroke-width': strokeWidth,
+        'stroke-dasharray': lineDash,
+    };
+    if (existingRect) {
+        _setAttributesIfNecessary(attributes, existingRect);
+        svgDrawingHelper.setNodeTouched(svgNodeHash);
+    }
+    else {
+        const svgRectElement = document.createElementNS(svgns, 'rect');
+        _setNewAttributesIfValid(attributes, svgRectElement);
+        svgDrawingHelper.appendNode(svgRectElement, svgNodeHash);
+    }
+}

package/dist/esm/drawingSvg/drawTextBox.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+declare function drawTextBox(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, textUID: string, textLines: Array<string>, position: Types.Point2, options?: {}): SVGRect;
+export default drawTextBox;

package/dist/esm/drawingSvg/drawTextBox.js

@@ -0,0 +1,123 @@
+import _getHash from './_getHash';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+function drawTextBox(svgDrawingHelper, annotationUID, textUID, textLines, position, options = {}) {
+    const mergedOptions = Object.assign({
+        fontFamily: 'Helvetica, Arial, sans-serif',
+        fontSize: '14px',
+        color: 'rgb(255, 255, 0)',
+        background: '',
+        padding: 25,
+        centerX: false,
+        centerY: true,
+    }, options);
+    const textGroupBoundingBox = _drawTextGroup(svgDrawingHelper, annotationUID, textUID, textLines, position, mergedOptions);
+    return textGroupBoundingBox;
+}
+function _drawTextGroup(svgDrawingHelper, annotationUID, textUID, textLines = [''], position, options) {
+    const { padding, color, fontFamily, fontSize, background } = options;
+    let textGroupBoundingBox;
+    const [x, y] = [position[0] + padding, position[1] + padding];
+    const svgns = 'http://www.w3.org/2000/svg';
+    const svgNodeHash = _getHash(annotationUID, 'text', textUID);
+    const existingTextGroup = svgDrawingHelper.getSvgNode(svgNodeHash);
+    if (existingTextGroup) {
+        const textElement = existingTextGroup.querySelector('text');
+        const textSpans = Array.from(textElement.children);
+        for (let i = 0; i < textSpans.length; i++) {
+            const textSpanElement = textSpans[i];
+            const text = textLines[i] || '';
+            textSpanElement.textContent = text;
+        }
+        if (textLines.length > textSpans.length) {
+            for (let i = 0; i < textLines.length - textSpans.length; i++) {
+                const textLine = textLines[i + textSpans.length];
+                const textSpan = _createTextSpan(textLine);
+                textElement.appendChild(textSpan);
+            }
+            existingTextGroup.appendChild(textElement);
+            svgDrawingHelper.appendNode(existingTextGroup, svgNodeHash);
+        }
+        const textAttributes = {
+            fill: color,
+            'font-size': fontSize,
+            'font-family': fontFamily,
+        };
+        const textGroupAttributes = {
+            transform: `translate(${x} ${y})`,
+        };
+        setAttributesIfNecessary(textAttributes, textElement);
+        setAttributesIfNecessary(textGroupAttributes, existingTextGroup);
+        existingTextGroup.setAttribute('data-annotation-uid', annotationUID);
+        textGroupBoundingBox = _drawTextBackground(existingTextGroup, background);
+        svgDrawingHelper.setNodeTouched(svgNodeHash);
+    }
+    else {
+        const textGroup = document.createElementNS(svgns, 'g');
+        textGroup.setAttribute('data-annotation-uid', annotationUID);
+        textGroup.setAttribute('transform', `translate(${x} ${y})`);
+        const textElement = _createTextElement(svgDrawingHelper, options);
+        for (let i = 0; i < textLines.length; i++) {
+            const textLine = textLines[i];
+            const textSpan = _createTextSpan(textLine);
+            textElement.appendChild(textSpan);
+        }
+        textGroup.appendChild(textElement);
+        svgDrawingHelper.appendNode(textGroup, svgNodeHash);
+        textGroupBoundingBox = _drawTextBackground(textGroup, background);
+    }
+    return Object.assign({}, textGroupBoundingBox, {
+        x,
+        y,
+        height: textGroupBoundingBox.height + padding,
+        width: textGroupBoundingBox.width + padding,
+    });
+}
+function _createTextElement(svgDrawingHelper, options) {
+    const { color, fontFamily, fontSize } = options;
+    const svgns = 'http://www.w3.org/2000/svg';
+    const textElement = document.createElementNS(svgns, 'text');
+    const noSelectStyle = 'user-select: none; pointer-events: none; -webkit-tap-highlight-color:  rgba(255, 255, 255, 0);';
+    const dropShadowStyle = `filter:url(#shadow-${svgDrawingHelper.svgLayerElement.id});`;
+    const combinedStyle = `${noSelectStyle}${dropShadowStyle}`;
+    textElement.setAttribute('x', '0');
+    textElement.setAttribute('y', '0');
+    textElement.setAttribute('fill', color);
+    textElement.setAttribute('font-family', fontFamily);
+    textElement.setAttribute('font-size', fontSize);
+    textElement.setAttribute('style', combinedStyle);
+    textElement.setAttribute('pointer-events', 'visible');
+    return textElement;
+}
+function _createTextSpan(text) {
+    const svgns = 'http://www.w3.org/2000/svg';
+    const textSpanElement = document.createElementNS(svgns, 'tspan');
+    textSpanElement.setAttribute('x', '0');
+    textSpanElement.setAttribute('dy', '1.2em');
+    textSpanElement.textContent = text;
+    return textSpanElement;
+}
+function _drawTextBackground(group, color) {
+    let element = group.querySelector('rect.background');
+    if (!color) {
+        if (element) {
+            group.removeChild(element);
+        }
+        return group.getBBox();
+    }
+    if (!element) {
+        element = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
+        element.setAttribute('class', 'background');
+        group.insertBefore(element, group.firstChild);
+    }
+    const bBox = group.getBBox();
+    const attributes = {
+        x: `${bBox.x}`,
+        y: `${bBox.y}`,
+        width: `${bBox.width}`,
+        height: `${bBox.height}`,
+        fill: color,
+    };
+    setAttributesIfNecessary(attributes, element);
+    return bBox;
+}
+export default drawTextBox;

package/dist/esm/drawingSvg/getSvgDrawingHelper.d.ts

@@ -0,0 +1,3 @@
+import type { SVGDrawingHelper } from '../types';
+declare function getSvgDrawingHelper(element: HTMLDivElement): SVGDrawingHelper;
+export default getSvgDrawingHelper;

package/dist/esm/drawingSvg/getSvgDrawingHelper.js

@@ -0,0 +1,65 @@
+import { state } from '../store/state';
+import { getEnabledElement } from '@cornerstonejs/core';
+const VIEWPORT_ELEMENT = 'viewport-element';
+function getSvgDrawingHelper(element) {
+    const enabledElement = getEnabledElement(element);
+    const { viewportId, renderingEngineId } = enabledElement;
+    const canvasHash = `${viewportId}:${renderingEngineId}`;
+    const svgLayerElement = _getSvgLayer(element);
+    Object.keys(state.svgNodeCache[canvasHash]).forEach((cacheKey) => {
+        state.svgNodeCache[canvasHash][cacheKey].touched = false;
+    });
+    return {
+        svgLayerElement: svgLayerElement,
+        svgNodeCacheForCanvas: state.svgNodeCache,
+        getSvgNode: getSvgNode.bind(this, canvasHash),
+        appendNode: appendNode.bind(this, svgLayerElement, canvasHash),
+        setNodeTouched: setNodeTouched.bind(this, canvasHash),
+        clearUntouched: clearUntouched.bind(this, svgLayerElement, canvasHash),
+    };
+}
+function _getSvgLayer(element) {
+    const viewportElement = `.${VIEWPORT_ELEMENT}`;
+    const internalDivElement = element.querySelector(viewportElement);
+    const svgLayer = internalDivElement?.querySelector(':scope > .svg-layer');
+    return svgLayer;
+}
+function getSvgNode(canvasHash, cacheKey) {
+    if (!state.svgNodeCache[canvasHash]) {
+        return;
+    }
+    if (state.svgNodeCache[canvasHash][cacheKey]) {
+        return state.svgNodeCache[canvasHash][cacheKey].domRef;
+    }
+}
+function appendNode(svgLayerElement, canvasHash, svgNode, cacheKey) {
+    if (!state.svgNodeCache[canvasHash]) {
+        return null;
+    }
+    state.svgNodeCache[canvasHash][cacheKey] = {
+        touched: true,
+        domRef: svgNode,
+    };
+    svgLayerElement.appendChild(svgNode);
+}
+function setNodeTouched(canvasHash, cacheKey) {
+    if (!state.svgNodeCache[canvasHash]) {
+        return;
+    }
+    if (state.svgNodeCache[canvasHash][cacheKey]) {
+        state.svgNodeCache[canvasHash][cacheKey].touched = true;
+    }
+}
+function clearUntouched(svgLayerElement, canvasHash) {
+    if (!state.svgNodeCache[canvasHash]) {
+        return;
+    }
+    Object.keys(state.svgNodeCache[canvasHash]).forEach((cacheKey) => {
+        const cacheEntry = state.svgNodeCache[canvasHash][cacheKey];
+        if (!cacheEntry.touched && cacheEntry.domRef) {
+            svgLayerElement.removeChild(cacheEntry.domRef);
+            delete state.svgNodeCache[canvasHash][cacheKey];
+        }
+    });
+}
+export default getSvgDrawingHelper;

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

@@ -0,0 +1,19 @@
+import draw from './draw';
+import drawCircle from './drawCircle';
+import drawEllipse from './drawEllipse';
+import drawEllipseByCoordinates from './drawEllipseByCoordinates';
+import drawHandles from './drawHandles';
+import drawHandle from './drawHandle';
+import drawLine from './drawLine';
+import drawHeight from './drawHeight';
+import drawPolyline from './drawPolyline';
+import drawPath from './drawPath';
+import drawLinkedTextBox from './drawLinkedTextBox';
+import drawRect from './drawRect';
+import drawRectByCoordinates from './drawRectByCoordinates';
+import drawTextBox from './drawTextBox';
+import drawArrow from './drawArrow';
+import drawRedactionRect from './drawRedactionRect';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+export { draw, drawCircle, drawEllipse, drawEllipseByCoordinates, drawHandles, drawHandle, drawLine, drawHeight, drawPolyline, drawPath, drawLinkedTextBox, drawRect, drawRectByCoordinates, drawTextBox, drawArrow, drawRedactionRect, setAttributesIfNecessary, setNewAttributesIfValid, };

package/dist/esm/drawingSvg/index.js

@@ -0,0 +1,19 @@
+import draw from './draw';
+import drawCircle from './drawCircle';
+import drawEllipse from './drawEllipse';
+import drawEllipseByCoordinates from './drawEllipseByCoordinates';
+import drawHandles from './drawHandles';
+import drawHandle from './drawHandle';
+import drawLine from './drawLine';
+import drawHeight from './drawHeight';
+import drawPolyline from './drawPolyline';
+import drawPath from './drawPath';
+import drawLinkedTextBox from './drawLinkedTextBox';
+import drawRect from './drawRect';
+import drawRectByCoordinates from './drawRectByCoordinates';
+import drawTextBox from './drawTextBox';
+import drawArrow from './drawArrow';
+import drawRedactionRect from './drawRedactionRect';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+export { draw, drawCircle, drawEllipse, drawEllipseByCoordinates, drawHandles, drawHandle, drawLine, drawHeight, drawPolyline, drawPath, drawLinkedTextBox, drawRect, drawRectByCoordinates, drawTextBox, drawArrow, drawRedactionRect, setAttributesIfNecessary, setNewAttributesIfValid, };

package/dist/esm/drawingSvg/setAttributesIfNecessary.d.ts

@@ -0,0 +1,2 @@
+export declare function setAttributesIfNecessary(attributes: any, svgNode: any): void;
+export default setAttributesIfNecessary;

package/dist/esm/drawingSvg/setAttributesIfNecessary.js

@@ -0,0 +1,13 @@
+export function setAttributesIfNecessary(attributes, svgNode) {
+    Object.keys(attributes).forEach((key) => {
+        const currentValue = svgNode.getAttribute(key);
+        const newValue = attributes[key];
+        if (newValue === undefined || newValue === '') {
+            svgNode.removeAttribute(key);
+        }
+        else if (currentValue !== newValue) {
+            svgNode.setAttribute(key, newValue);
+        }
+    });
+}
+export default setAttributesIfNecessary;

package/dist/esm/drawingSvg/setNewAttributesIfValid.d.ts

@@ -0,0 +1,2 @@
+export declare function setNewAttributesIfValid(attributes: any, svgNode: any): void;
+export default setNewAttributesIfValid;

package/dist/esm/drawingSvg/setNewAttributesIfValid.js

@@ -0,0 +1,9 @@
+export function setNewAttributesIfValid(attributes, svgNode) {
+    Object.keys(attributes).forEach((key) => {
+        const newValue = attributes[key];
+        if (newValue !== undefined && newValue !== '') {
+            svgNode.setAttribute(key, newValue);
+        }
+    });
+}
+export default setNewAttributesIfValid;

package/dist/esm/enums/AnnotationStyleStates.d.ts

@@ -0,0 +1,8 @@
+declare enum AnnotationStyleStates {
+    Default = "",
+    Highlighted = "Highlighted",
+    Selected = "Selected",
+    Locked = "Locked",
+    AutoGenerated = "AutoGenerated"
+}
+export default AnnotationStyleStates;

package/dist/esm/enums/AnnotationStyleStates.js

@@ -0,0 +1,9 @@
+var AnnotationStyleStates;
+(function (AnnotationStyleStates) {
+    AnnotationStyleStates["Default"] = "";
+    AnnotationStyleStates["Highlighted"] = "Highlighted";
+    AnnotationStyleStates["Selected"] = "Selected";
+    AnnotationStyleStates["Locked"] = "Locked";
+    AnnotationStyleStates["AutoGenerated"] = "AutoGenerated";
+})(AnnotationStyleStates || (AnnotationStyleStates = {}));
+export default AnnotationStyleStates;

package/dist/esm/enums/ChangeTypes.d.ts

@@ -0,0 +1,11 @@
+declare enum ChangeTypes {
+    Interaction = "Interaction",
+    HandlesUpdated = "HandlesUpdated",
+    StatsUpdated = "StatsUpdated",
+    InitialSetup = "InitialSetup",
+    Completed = "Completed",
+    InterpolationUpdated = "InterpolationUpdated",
+    History = "History",
+    MetadataReferenceModified = "MetadataReferenceModified"
+}
+export default ChangeTypes;

package/dist/esm/enums/ChangeTypes.js

@@ -0,0 +1,12 @@
+var ChangeTypes;
+(function (ChangeTypes) {
+    ChangeTypes["Interaction"] = "Interaction";
+    ChangeTypes["HandlesUpdated"] = "HandlesUpdated";
+    ChangeTypes["StatsUpdated"] = "StatsUpdated";
+    ChangeTypes["InitialSetup"] = "InitialSetup";
+    ChangeTypes["Completed"] = "Completed";
+    ChangeTypes["InterpolationUpdated"] = "InterpolationUpdated";
+    ChangeTypes["History"] = "History";
+    ChangeTypes["MetadataReferenceModified"] = "MetadataReferenceModified";
+})(ChangeTypes || (ChangeTypes = {}));
+export default ChangeTypes;

package/dist/esm/enums/Events.d.ts

@@ -0,0 +1,42 @@
+declare enum Events {
+    TOOL_ACTIVATED = "CORNERSTONE_TOOLS_TOOL_ACTIVATED",
+    TOOLGROUP_VIEWPORT_ADDED = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_ADDED",
+    TOOLGROUP_VIEWPORT_REMOVED = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_REMOVED",
+    TOOL_MODE_CHANGED = "CORNERSTONE_TOOLS_TOOL_MODE_CHANGED",
+    ANNOTATION_ADDED = "CORNERSTONE_TOOLS_ANNOTATION_ADDED",
+    ANNOTATION_COMPLETED = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED",
+    ANNOTATION_MODIFIED = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED",
+    ANNOTATION_REMOVED = "CORNERSTONE_TOOLS_ANNOTATION_REMOVED",
+    ANNOTATION_SELECTION_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_SELECTION_CHANGE",
+    ANNOTATION_LOCK_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_LOCK_CHANGE",
+    ANNOTATION_VISIBILITY_CHANGE = "CORNERSTONE_TOOLS_ANNOTATION_VISIBILITY_CHANGE",
+    ANNOTATION_RENDERED = "CORNERSTONE_TOOLS_ANNOTATION_RENDERED",
+    ANNOTATION_INTERPOLATION_PROCESS_COMPLETED = "CORNERSTONE_TOOLS_ANNOTATION_INTERPOLATION_PROCESS_COMPLETED",
+    INTERPOLATED_ANNOTATIONS_REMOVED = "CORNERSTONE_TOOLS_INTERPOLATED_ANNOTATIONS_REMOVED",
+    SEGMENTATION_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_MODIFIED",
+    SEGMENTATION_RENDERED = "CORNERSTONE_TOOLS_SEGMENTATION_RENDERED",
+    SEGMENTATION_REPRESENTATION_ADDED = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_ADDED",
+    SEGMENTATION_ADDED = "CORNERSTONE_TOOLS_SEGMENTATION_ADDED",
+    SEGMENTATION_REPRESENTATION_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_MODIFIED",
+    SEGMENTATION_REMOVED = "CORNERSTONE_TOOLS_SEGMENTATION_REMOVED",
+    SEGMENTATION_REPRESENTATION_REMOVED = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_REMOVED",
+    SEGMENTATION_DATA_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_DATA_MODIFIED",
+    KEY_DOWN = "CORNERSTONE_TOOLS_KEY_DOWN",
+    KEY_UP = "CORNERSTONE_TOOLS_KEY_UP",
+    MOUSE_DOWN = "CORNERSTONE_TOOLS_MOUSE_DOWN",
+    MOUSE_UP = "CORNERSTONE_TOOLS_MOUSE_UP",
+    MOUSE_DOWN_ACTIVATE = "CORNERSTONE_TOOLS_MOUSE_DOWN_ACTIVATE",
+    MOUSE_DRAG = "CORNERSTONE_TOOLS_MOUSE_DRAG",
+    MOUSE_MOVE = "CORNERSTONE_TOOLS_MOUSE_MOVE",
+    MOUSE_CLICK = "CORNERSTONE_TOOLS_MOUSE_CLICK",
+    MOUSE_DOUBLE_CLICK = "CORNERSTONE_TOOLS_MOUSE_DOUBLE_CLICK",
+    MOUSE_WHEEL = "CORNERSTONE_TOOLS_MOUSE_WHEEL",
+    TOUCH_START = "CORNERSTONE_TOOLS_TOUCH_START",
+    TOUCH_START_ACTIVATE = "CORNERSTONE_TOOLS_TOUCH_START_ACTIVATE",
+    TOUCH_PRESS = "CORNERSTONE_TOOLS_TOUCH_PRESS",
+    TOUCH_DRAG = "CORNERSTONE_TOOLS_TOUCH_DRAG",
+    TOUCH_END = "CORNERSTONE_TOOLS_TOUCH_END",
+    TOUCH_TAP = "CORNERSTONE_TOOLS_TAP",
+    TOUCH_SWIPE = "CORNERSTONE_TOOLS_SWIPE"
+}
+export default Events;

package/dist/esm/enums/Events.js

@@ -0,0 +1,43 @@
+var Events;
+(function (Events) {
+    Events["TOOL_ACTIVATED"] = "CORNERSTONE_TOOLS_TOOL_ACTIVATED";
+    Events["TOOLGROUP_VIEWPORT_ADDED"] = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_ADDED";
+    Events["TOOLGROUP_VIEWPORT_REMOVED"] = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_REMOVED";
+    Events["TOOL_MODE_CHANGED"] = "CORNERSTONE_TOOLS_TOOL_MODE_CHANGED";
+    Events["ANNOTATION_ADDED"] = "CORNERSTONE_TOOLS_ANNOTATION_ADDED";
+    Events["ANNOTATION_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED";
+    Events["ANNOTATION_MODIFIED"] = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED";
+    Events["ANNOTATION_REMOVED"] = "CORNERSTONE_TOOLS_ANNOTATION_REMOVED";
+    Events["ANNOTATION_SELECTION_CHANGE"] = "CORNERSTONE_TOOLS_ANNOTATION_SELECTION_CHANGE";
+    Events["ANNOTATION_LOCK_CHANGE"] = "CORNERSTONE_TOOLS_ANNOTATION_LOCK_CHANGE";
+    Events["ANNOTATION_VISIBILITY_CHANGE"] = "CORNERSTONE_TOOLS_ANNOTATION_VISIBILITY_CHANGE";
+    Events["ANNOTATION_RENDERED"] = "CORNERSTONE_TOOLS_ANNOTATION_RENDERED";
+    Events["ANNOTATION_INTERPOLATION_PROCESS_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_INTERPOLATION_PROCESS_COMPLETED";
+    Events["INTERPOLATED_ANNOTATIONS_REMOVED"] = "CORNERSTONE_TOOLS_INTERPOLATED_ANNOTATIONS_REMOVED";
+    Events["SEGMENTATION_MODIFIED"] = "CORNERSTONE_TOOLS_SEGMENTATION_MODIFIED";
+    Events["SEGMENTATION_RENDERED"] = "CORNERSTONE_TOOLS_SEGMENTATION_RENDERED";
+    Events["SEGMENTATION_REPRESENTATION_ADDED"] = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_ADDED";
+    Events["SEGMENTATION_ADDED"] = "CORNERSTONE_TOOLS_SEGMENTATION_ADDED";
+    Events["SEGMENTATION_REPRESENTATION_MODIFIED"] = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_MODIFIED";
+    Events["SEGMENTATION_REMOVED"] = "CORNERSTONE_TOOLS_SEGMENTATION_REMOVED";
+    Events["SEGMENTATION_REPRESENTATION_REMOVED"] = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_REMOVED";
+    Events["SEGMENTATION_DATA_MODIFIED"] = "CORNERSTONE_TOOLS_SEGMENTATION_DATA_MODIFIED";
+    Events["KEY_DOWN"] = "CORNERSTONE_TOOLS_KEY_DOWN";
+    Events["KEY_UP"] = "CORNERSTONE_TOOLS_KEY_UP";
+    Events["MOUSE_DOWN"] = "CORNERSTONE_TOOLS_MOUSE_DOWN";
+    Events["MOUSE_UP"] = "CORNERSTONE_TOOLS_MOUSE_UP";
+    Events["MOUSE_DOWN_ACTIVATE"] = "CORNERSTONE_TOOLS_MOUSE_DOWN_ACTIVATE";
+    Events["MOUSE_DRAG"] = "CORNERSTONE_TOOLS_MOUSE_DRAG";
+    Events["MOUSE_MOVE"] = "CORNERSTONE_TOOLS_MOUSE_MOVE";
+    Events["MOUSE_CLICK"] = "CORNERSTONE_TOOLS_MOUSE_CLICK";
+    Events["MOUSE_DOUBLE_CLICK"] = "CORNERSTONE_TOOLS_MOUSE_DOUBLE_CLICK";
+    Events["MOUSE_WHEEL"] = "CORNERSTONE_TOOLS_MOUSE_WHEEL";
+    Events["TOUCH_START"] = "CORNERSTONE_TOOLS_TOUCH_START";
+    Events["TOUCH_START_ACTIVATE"] = "CORNERSTONE_TOOLS_TOUCH_START_ACTIVATE";
+    Events["TOUCH_PRESS"] = "CORNERSTONE_TOOLS_TOUCH_PRESS";
+    Events["TOUCH_DRAG"] = "CORNERSTONE_TOOLS_TOUCH_DRAG";
+    Events["TOUCH_END"] = "CORNERSTONE_TOOLS_TOUCH_END";
+    Events["TOUCH_TAP"] = "CORNERSTONE_TOOLS_TAP";
+    Events["TOUCH_SWIPE"] = "CORNERSTONE_TOOLS_SWIPE";
+})(Events || (Events = {}));
+export default Events;

package/dist/esm/enums/SegmentationRepresentations.d.ts

@@ -0,0 +1,6 @@
+declare enum SegmentationRepresentations {
+    Labelmap = "Labelmap",
+    Contour = "Contour",
+    Surface = "Surface"
+}
+export default SegmentationRepresentations;

package/dist/esm/enums/SegmentationRepresentations.js

@@ -0,0 +1,7 @@
+var SegmentationRepresentations;
+(function (SegmentationRepresentations) {
+    SegmentationRepresentations["Labelmap"] = "Labelmap";
+    SegmentationRepresentations["Contour"] = "Contour";
+    SegmentationRepresentations["Surface"] = "Surface";
+})(SegmentationRepresentations || (SegmentationRepresentations = {}));
+export default SegmentationRepresentations;

package/dist/esm/enums/StrategyCallbacks.d.ts

@@ -0,0 +1,19 @@
+declare enum StrategyCallbacks {
+    OnInteractionStart = "onInteractionStart",
+    OnInteractionEnd = "onInteractionEnd",
+    Preview = "preview",
+    RejectPreview = "rejectPreview",
+    AcceptPreview = "acceptPreview",
+    Fill = "fill",
+    Interpolate = "interpolate",
+    StrategyFunction = "strategyFunction",
+    CreateIsInThreshold = "createIsInThreshold",
+    Initialize = "initialize",
+    INTERNAL_setValue = "setValue",
+    AddPreview = "addPreview",
+    ComputeInnerCircleRadius = "computeInnerCircleRadius",
+    GetStatistics = "getStatistics",
+    EnsureImageVolumeFor3DManipulation = "ensureImageVolumeFor3DManipulation",
+    EnsureSegmentationVolumeFor3DManipulation = "ensureSegmentationVolumeFor3DManipulation"
+}
+export default StrategyCallbacks;

package/dist/esm/enums/StrategyCallbacks.js

@@ -0,0 +1,20 @@
+var StrategyCallbacks;
+(function (StrategyCallbacks) {
+    StrategyCallbacks["OnInteractionStart"] = "onInteractionStart";
+    StrategyCallbacks["OnInteractionEnd"] = "onInteractionEnd";
+    StrategyCallbacks["Preview"] = "preview";
+    StrategyCallbacks["RejectPreview"] = "rejectPreview";
+    StrategyCallbacks["AcceptPreview"] = "acceptPreview";
+    StrategyCallbacks["Fill"] = "fill";
+    StrategyCallbacks["Interpolate"] = "interpolate";
+    StrategyCallbacks["StrategyFunction"] = "strategyFunction";
+    StrategyCallbacks["CreateIsInThreshold"] = "createIsInThreshold";
+    StrategyCallbacks["Initialize"] = "initialize";
+    StrategyCallbacks["INTERNAL_setValue"] = "setValue";
+    StrategyCallbacks["AddPreview"] = "addPreview";
+    StrategyCallbacks["ComputeInnerCircleRadius"] = "computeInnerCircleRadius";
+    StrategyCallbacks["GetStatistics"] = "getStatistics";
+    StrategyCallbacks["EnsureImageVolumeFor3DManipulation"] = "ensureImageVolumeFor3DManipulation";
+    StrategyCallbacks["EnsureSegmentationVolumeFor3DManipulation"] = "ensureSegmentationVolumeFor3DManipulation";
+})(StrategyCallbacks || (StrategyCallbacks = {}));
+export default StrategyCallbacks;

package/dist/esm/enums/ToolBindings.d.ts

@@ -0,0 +1,26 @@
+declare enum MouseBindings {
+    Primary = 1,
+    Secondary = 2,
+    Primary_And_Secondary = 3,
+    Auxiliary = 4,
+    Primary_And_Auxiliary = 5,
+    Secondary_And_Auxiliary = 6,
+    Primary_And_Secondary_And_Auxiliary = 7,
+    Fourth_Button = 8,
+    Fifth_Button = 16,
+    Wheel = 524288,
+    Wheel_Primary = 524289
+}
+declare enum KeyboardBindings {
+    Shift = 16,
+    Ctrl = 17,
+    Alt = 18,
+    Meta = 91,
+    ShiftCtrl = 1617,
+    ShiftAlt = 1618,
+    ShiftMeta = 1691,
+    CtrlAlt = 1718,
+    CtrlMeta = 1791,
+    AltMeta = 1891
+}
+export { MouseBindings, KeyboardBindings };

package/dist/esm/enums/ToolBindings.js

@@ -0,0 +1,28 @@
+var MouseBindings;
+(function (MouseBindings) {
+    MouseBindings[MouseBindings["Primary"] = 1] = "Primary";
+    MouseBindings[MouseBindings["Secondary"] = 2] = "Secondary";
+    MouseBindings[MouseBindings["Primary_And_Secondary"] = 3] = "Primary_And_Secondary";
+    MouseBindings[MouseBindings["Auxiliary"] = 4] = "Auxiliary";
+    MouseBindings[MouseBindings["Primary_And_Auxiliary"] = 5] = "Primary_And_Auxiliary";
+    MouseBindings[MouseBindings["Secondary_And_Auxiliary"] = 6] = "Secondary_And_Auxiliary";
+    MouseBindings[MouseBindings["Primary_And_Secondary_And_Auxiliary"] = 7] = "Primary_And_Secondary_And_Auxiliary";
+    MouseBindings[MouseBindings["Fourth_Button"] = 8] = "Fourth_Button";
+    MouseBindings[MouseBindings["Fifth_Button"] = 16] = "Fifth_Button";
+    MouseBindings[MouseBindings["Wheel"] = 524288] = "Wheel";
+    MouseBindings[MouseBindings["Wheel_Primary"] = 524289] = "Wheel_Primary";
+})(MouseBindings || (MouseBindings = {}));
+var KeyboardBindings;
+(function (KeyboardBindings) {
+    KeyboardBindings[KeyboardBindings["Shift"] = 16] = "Shift";
+    KeyboardBindings[KeyboardBindings["Ctrl"] = 17] = "Ctrl";
+    KeyboardBindings[KeyboardBindings["Alt"] = 18] = "Alt";
+    KeyboardBindings[KeyboardBindings["Meta"] = 91] = "Meta";
+    KeyboardBindings[KeyboardBindings["ShiftCtrl"] = 1617] = "ShiftCtrl";
+    KeyboardBindings[KeyboardBindings["ShiftAlt"] = 1618] = "ShiftAlt";
+    KeyboardBindings[KeyboardBindings["ShiftMeta"] = 1691] = "ShiftMeta";
+    KeyboardBindings[KeyboardBindings["CtrlAlt"] = 1718] = "CtrlAlt";
+    KeyboardBindings[KeyboardBindings["CtrlMeta"] = 1791] = "CtrlMeta";
+    KeyboardBindings[KeyboardBindings["AltMeta"] = 1891] = "AltMeta";
+})(KeyboardBindings || (KeyboardBindings = {}));
+export { MouseBindings, KeyboardBindings };

package/dist/esm/enums/ToolModes.d.ts

@@ -0,0 +1,7 @@
+declare enum ToolModes {
+    Active = "Active",
+    Passive = "Passive",
+    Enabled = "Enabled",
+    Disabled = "Disabled"
+}
+export default ToolModes;

package/dist/esm/enums/ToolModes.js

@@ -0,0 +1,8 @@
+var ToolModes;
+(function (ToolModes) {
+    ToolModes["Active"] = "Active";
+    ToolModes["Passive"] = "Passive";
+    ToolModes["Enabled"] = "Enabled";
+    ToolModes["Disabled"] = "Disabled";
+})(ToolModes || (ToolModes = {}));
+export default ToolModes;

package/dist/esm/enums/Touch.d.ts

@@ -0,0 +1,7 @@
+declare enum Swipe {
+    UP = "UP",
+    DOWN = "DOWN",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT"
+}
+export { Swipe };

package/dist/esm/enums/Touch.js

@@ -0,0 +1,8 @@
+var Swipe;
+(function (Swipe) {
+    Swipe["UP"] = "UP";
+    Swipe["DOWN"] = "DOWN";
+    Swipe["LEFT"] = "LEFT";
+    Swipe["RIGHT"] = "RIGHT";
+})(Swipe || (Swipe = {}));
+export { Swipe };

package/dist/esm/enums/WorkerTypes.d.ts

@@ -0,0 +1,10 @@
+declare enum ChangeTypes {
+    POLYSEG_CONTOUR_TO_LABELMAP = "Converting Contour to Labelmap",
+    POLYSEG_SURFACE_TO_LABELMAP = "Converting Surfaces to Labelmap",
+    POLYSEG_CONTOUR_TO_SURFACE = "Converting Contour to Surface",
+    POLYSEG_LABELMAP_TO_SURFACE = "Converting Labelmap to Surface",
+    SURFACE_CLIPPING = "Clipping Surfaces",
+    COMPUTE_STATISTICS = "Computing Statistics",
+    INTERPOLATE_LABELMAP = "Interpolating Labelmap"
+}
+export default ChangeTypes;

package/dist/esm/enums/WorkerTypes.js

@@ -0,0 +1,11 @@
+var ChangeTypes;
+(function (ChangeTypes) {
+    ChangeTypes["POLYSEG_CONTOUR_TO_LABELMAP"] = "Converting Contour to Labelmap";
+    ChangeTypes["POLYSEG_SURFACE_TO_LABELMAP"] = "Converting Surfaces to Labelmap";
+    ChangeTypes["POLYSEG_CONTOUR_TO_SURFACE"] = "Converting Contour to Surface";
+    ChangeTypes["POLYSEG_LABELMAP_TO_SURFACE"] = "Converting Labelmap to Surface";
+    ChangeTypes["SURFACE_CLIPPING"] = "Clipping Surfaces";
+    ChangeTypes["COMPUTE_STATISTICS"] = "Computing Statistics";
+    ChangeTypes["INTERPOLATE_LABELMAP"] = "Interpolating Labelmap";
+})(ChangeTypes || (ChangeTypes = {}));
+export default ChangeTypes;

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

@@ -0,0 +1,11 @@
+import { MouseBindings } from './ToolBindings';
+import { KeyboardBindings } from './ToolBindings';
+import ToolModes from './ToolModes';
+import AnnotationStyleStates from './AnnotationStyleStates';
+import Events from './Events';
+import SegmentationRepresentations from './SegmentationRepresentations';
+import { Swipe } from './Touch';
+import StrategyCallbacks from './StrategyCallbacks';
+import ChangeTypes from './ChangeTypes';
+import WorkerTypes from './WorkerTypes';
+export { MouseBindings, KeyboardBindings, ToolModes, AnnotationStyleStates, Events, SegmentationRepresentations, Swipe, StrategyCallbacks, ChangeTypes, WorkerTypes };