@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/esm/utilities/applyPreset.js

@@ -33,24 +33,26 @@ export default function applyPreset(actor, preset) {
         normPoints.push([value, opacity]);
     }
     applyPointsToPiecewiseFunction(normPoints, shiftRange, ofun);
-    actor.getProperty().setScalarOpacity(0, ofun);
+    const property = actor.getProperty();
+    property.setScalarOpacity(0, ofun);
     const [gradientMinValue, gradientMinOpacity, gradientMaxValue, gradientMaxOpacity,] = preset.gradientOpacity.split(' ').splice(1).map(parseFloat);
-    actor.getProperty().setUseGradientOpacity(0, true);
-    actor.getProperty().setGradientOpacityMinimumValue(0, gradientMinValue);
-    actor.getProperty().setGradientOpacityMinimumOpacity(0, gradientMinOpacity);
-    actor.getProperty().setGradientOpacityMaximumValue(0, gradientMaxValue);
-    actor.getProperty().setGradientOpacityMaximumOpacity(0, gradientMaxOpacity);
+    property.setUseGradientOpacity(0, true);
+    property.setGradientOpacityMinimumValue(0, gradientMinValue);
+    property.setGradientOpacityMinimumOpacity(0, gradientMinOpacity);
+    property.setGradientOpacityMaximumValue(0, gradientMaxValue);
+    property.setGradientOpacityMaximumOpacity(0, gradientMaxOpacity);
     if (preset.interpolation === '1') {
-        actor.getProperty().setInterpolationTypeToFastLinear();
+        property.setInterpolationTypeToFastLinear();
     }
+    property.setShade(preset.shade === '1');
     const ambient = parseFloat(preset.ambient);
     const diffuse = parseFloat(preset.diffuse);
     const specular = parseFloat(preset.specular);
     const specularPower = parseFloat(preset.specularPower);
-    actor.getProperty().setAmbient(ambient);
-    actor.getProperty().setDiffuse(diffuse);
-    actor.getProperty().setSpecular(specular);
-    actor.getProperty().setSpecularPower(specularPower);
+    property.setAmbient(ambient);
+    property.setDiffuse(diffuse);
+    property.setSpecular(specular);
+    property.setSpecularPower(specularPower);
 }
 function getShiftRange(colorTransferArray) {
     let min = Infinity;
@@ -85,4 +87,3 @@ function applyPointsToPiecewiseFunction(points, range, pwf) {
     rescaled.forEach(([x, y]) => pwf.addPoint(x, y));
     return rescaled;
 }
-//# sourceMappingURL=applyPreset.js.map

package/dist/esm/utilities/calculateViewportsSpatialRegistration.d.ts

@@ -1,3 +1,3 @@
-import { IStackViewport } from '../types';
-declare function calculateViewportsSpatialRegistration(viewport1: IStackViewport, viewport2: IStackViewport): void;
+import type { IStackViewport, IVolumeViewport } from '../types';
+declare function calculateViewportsSpatialRegistration(viewport1: IStackViewport | IVolumeViewport, viewport2: IStackViewport | IVolumeViewport): void;
 export default calculateViewportsSpatialRegistration;

package/dist/esm/utilities/calculateViewportsSpatialRegistration.js

@@ -3,10 +3,10 @@ import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataPr
 import { metaData } from '..';
 const ALLOWED_DELTA = 0.05;
 function calculateViewportsSpatialRegistration(viewport1, viewport2) {
-    const imageId1 = viewport1.getCurrentImageId();
-    const imageId2 = viewport2.getCurrentImageId();
-    const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
-    const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2);
+    const imageId1 = viewport1.getSliceIndex();
+    const imageId2 = viewport2.getSliceIndex();
+    const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1.toString());
+    const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2.toString());
     if (!imagePlaneModule1 || !imagePlaneModule2) {
         console.log('Viewport spatial registration requires image plane module');
         return;
@@ -24,4 +24,3 @@ function calculateViewportsSpatialRegistration(viewport1, viewport2) {
     spatialRegistrationMetadataProvider.add([viewport1.id, viewport2.id], mat);
 }
 export default calculateViewportsSpatialRegistration;
-//# sourceMappingURL=calculateViewportsSpatialRegistration.js.map

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.d.ts

@@ -1,4 +1,4 @@
-import { IImageCalibration } from '../types';
+import type { IImageCalibration } from '../types/IImageCalibration';
 declare const metadataProvider: {
     add: (imageId: string, payload: IImageCalibration) => void;
     get: (type: string, imageId: string) => IImageCalibration;

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.js

@@ -13,4 +13,3 @@ const metadataProvider = {
     },
 };
 export default metadataProvider;
-//# sourceMappingURL=calibratedPixelSpacingMetadataProvider.js.map

package/dist/esm/utilities/clamp.d.ts

@@ -0,0 +1,2 @@
+declare function clamp(value: number, min: number, max: number): number;
+export { clamp as default, clamp };

package/dist/esm/utilities/clamp.js

@@ -0,0 +1,4 @@
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+export { clamp as default, clamp };

package/dist/esm/utilities/color.d.ts

@@ -0,0 +1,7 @@
+declare function rgbToHex(r: any, g: any, b: any): string;
+declare function hexToRgb(hex: any): {
+    r: number;
+    g: number;
+    b: number;
+};
+export { hexToRgb, rgbToHex };

package/dist/esm/utilities/color.js

@@ -0,0 +1,18 @@
+function componentToHex(c) {
+    const hex = c.toString(16);
+    return hex.length == 1 ? '0' + hex : hex;
+}
+function rgbToHex(r, g, b) {
+    return '#' + componentToHex(r) + componentToHex(g) + componentToHex(b);
+}
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : null;
+}
+export { hexToRgb, rgbToHex };

package/dist/esm/utilities/colormap.d.ts

@@ -1,5 +1,6 @@
-import { ColormapRegistration } from '../types';
+import type { ColormapPublic, ColormapRegistration } from '../types';
 declare function registerColormap(colormap: ColormapRegistration): void;
 declare function getColormap(name: any): any;
 declare function getColormapNames(): any[];
-export { getColormap, getColormapNames, registerColormap };
+declare function findMatchingColormap(rgbPoints: any, actor: any): ColormapPublic | null;
+export { getColormap, getColormapNames, registerColormap, findMatchingColormap, };

package/dist/esm/utilities/colormap.js

@@ -1,3 +1,6 @@
+import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import isEqual from './isEqual';
+import { actorIsA } from './actorCheck';
 const _colormaps = new Map();
 function registerColormap(colormap) {
     _colormaps.set(colormap.Name, colormap);
@@ -8,5 +11,46 @@ function getColormap(name) {
 function getColormapNames() {
     return Array.from(_colormaps.keys());
 }
-export { getColormap, getColormapNames, registerColormap };
-//# sourceMappingURL=colormap.js.map
+function findMatchingColormap(rgbPoints, actor) {
+    const colormapsVTK = vtkColorMaps.rgbPresetNames.map((presetName) => vtkColorMaps.getPresetByName(presetName));
+    const colormapsCS3D = getColormapNames().map((colormapName) => getColormap(colormapName));
+    const colormaps = colormapsVTK.concat(colormapsCS3D);
+    const matchedColormap = colormaps.find((colormap) => {
+        const { RGBPoints: presetRGBPoints } = colormap;
+        if (presetRGBPoints.length !== rgbPoints.length) {
+            return false;
+        }
+        for (let i = 0; i < presetRGBPoints.length; i += 4) {
+            if (!isEqual(presetRGBPoints.slice(i + 1, i + 4), rgbPoints.slice(i + 1, i + 4))) {
+                return false;
+            }
+        }
+        return true;
+    });
+    if (!matchedColormap) {
+        return null;
+    }
+    const opacity = [];
+    if (actorIsA(actor, 'vtkVolume')) {
+        const opacityPoints = actor
+            .getProperty()
+            .getScalarOpacity(0)
+            .getDataPointer();
+        if (!opacityPoints) {
+            return {
+                name: matchedColormap.Name,
+            };
+        }
+        for (let i = 0; i < opacityPoints.length; i += 2) {
+            opacity.push({
+                value: opacityPoints[i],
+                opacity: opacityPoints[i + 1],
+            });
+        }
+    }
+    return {
+        name: matchedColormap.Name,
+        opacity,
+    };
+}
+export { getColormap, getColormapNames, registerColormap, findMatchingColormap, };

package/dist/esm/utilities/convertStackToVolumeViewport.d.ts

@@ -0,0 +1,12 @@
+import type { IStackViewport, IVolumeViewport, Point3 } from '../types';
+import type { OrientationAxis } from '../enums';
+declare function convertStackToVolumeViewport({ viewport, options, }: {
+    viewport: IStackViewport;
+    options: {
+        volumeId: string;
+        viewportId?: string;
+        background?: Point3;
+        orientation?: OrientationAxis;
+    };
+}): Promise<IVolumeViewport>;
+export { convertStackToVolumeViewport };

package/dist/esm/utilities/convertStackToVolumeViewport.js

@@ -0,0 +1,46 @@
+import { setVolumesForViewports } from '../RenderingEngine/helpers';
+import { createAndCacheVolume, getUnknownVolumeLoaderSchema, } from '../loaders/volumeLoader';
+import { Events, ViewportType } from '../enums';
+async function convertStackToVolumeViewport({ viewport, options, }) {
+    const renderingEngine = viewport.getRenderingEngine();
+    let { volumeId } = options;
+    if (volumeId.split(':').length === 1) {
+        const schema = getUnknownVolumeLoaderSchema();
+        volumeId = `${schema}:${volumeId}`;
+    }
+    const { id, element } = viewport;
+    const viewportId = options.viewportId || id;
+    const imageIds = viewport.getImageIds();
+    const prevView = viewport.getViewReference();
+    renderingEngine.enableElement({
+        viewportId,
+        type: ViewportType.ORTHOGRAPHIC,
+        element,
+        defaultOptions: {
+            background: options.background,
+            orientation: options.orientation,
+        },
+    });
+    const volume = await createAndCacheVolume(volumeId, {
+        imageIds,
+    });
+    volume.load();
+    const volumeViewport = renderingEngine.getViewport(viewportId);
+    await setVolumesForViewports(renderingEngine, [
+        {
+            volumeId,
+        },
+    ], [viewportId]);
+    const volumeViewportNewVolumeHandler = () => {
+        volumeViewport.setViewReference(prevView);
+        volumeViewport.render();
+        element.removeEventListener(Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
+    };
+    const addVolumeViewportNewVolumeListener = () => {
+        element.addEventListener(Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
+    };
+    addVolumeViewportNewVolumeListener();
+    volumeViewport.render();
+    return volumeViewport;
+}
+export { convertStackToVolumeViewport };

package/dist/esm/utilities/convertToGrayscale.d.ts

@@ -0,0 +1 @@
+export default function convertToGrayscale(scalarData: any, width: number, height: number): any;

package/dist/esm/utilities/convertToGrayscale.js

@@ -0,0 +1,24 @@
+export default function convertToGrayscale(scalarData, width, height) {
+    const isRGBA = scalarData.length === width * height * 4;
+    const isRGB = scalarData.length === width * height * 3;
+    if (isRGBA || isRGB) {
+        const newScalarData = new Float32Array(width * height);
+        let offset = 0;
+        let destOffset = 0;
+        const increment = isRGBA ? 4 : 3;
+        for (let x = 0; x < width; x++) {
+            for (let y = 0; y < height; y++) {
+                const r = scalarData[offset];
+                const g = scalarData[offset + 1];
+                const b = scalarData[offset + 2];
+                newScalarData[destOffset] = (r + g + b) / 3;
+                offset += increment;
+                destOffset++;
+            }
+        }
+        return newScalarData;
+    }
+    else {
+        return scalarData;
+    }
+}

package/dist/esm/utilities/convertVolumeToStackViewport.d.ts

@@ -0,0 +1,9 @@
+import type * as Types from '../types';
+declare function convertVolumeToStackViewport({ viewport, options, }: {
+    viewport: Types.IVolumeViewport;
+    options: {
+        viewportId?: string;
+        background?: Types.Point3;
+    };
+}): Promise<Types.IStackViewport>;
+export { convertVolumeToStackViewport };

package/dist/esm/utilities/convertVolumeToStackViewport.js

@@ -0,0 +1,31 @@
+import cache, { ImageVolume } from '../cache';
+import { ViewportType } from '../enums';
+async function convertVolumeToStackViewport({ viewport, options, }) {
+    const volumeViewport = viewport;
+    const { id, element } = volumeViewport;
+    const renderingEngine = viewport.getRenderingEngine();
+    const { background } = options;
+    const viewportId = options.viewportId || id;
+    const actorEntry = volumeViewport.getDefaultActor();
+    const { uid: volumeId } = actorEntry;
+    const volume = cache.getVolume(volumeId);
+    if (!(volume instanceof ImageVolume)) {
+        throw new Error('Currently, you cannot decache a volume that is not an ImageVolume. So, unfortunately, volumes such as nifti  (which are basic Volume, without imageIds) cannot be decached.');
+    }
+    const viewportInput = {
+        viewportId,
+        type: ViewportType.STACK,
+        element,
+        defaultOptions: {
+            background,
+        },
+    };
+    const prevView = volumeViewport.getViewReference();
+    renderingEngine.enableElement(viewportInput);
+    const stackViewport = renderingEngine.getViewport(viewportId);
+    await stackViewport.setStack(volume.imageIds);
+    stackViewport.setViewReference(prevView);
+    stackViewport.render();
+    return stackViewport;
+}
+export { convertVolumeToStackViewport };

package/dist/esm/utilities/createLinearRGBTransferFunction.d.ts

@@ -1,3 +1,3 @@
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { VOIRange } from '../types';
+import type { VOIRange } from '../types/voi';
 export default function createLinearRGBTransferFunction(voiRange: VOIRange): vtkColorTransferFunction;

package/dist/esm/utilities/createLinearRGBTransferFunction.js

@@ -3,9 +3,7 @@ export default function createLinearRGBTransferFunction(voiRange) {
     const cfun = vtkColorTransferFunction.newInstance();
     let lower = 0;
     let upper = 1024;
-    if (voiRange &&
-        voiRange.lower !== undefined &&
-        voiRange.upper !== undefined) {
+    if (voiRange.lower !== undefined && voiRange.upper !== undefined) {
         lower = voiRange.lower;
         upper = voiRange.upper;
     }
@@ -13,4 +11,3 @@ export default function createLinearRGBTransferFunction(voiRange) {
     cfun.addRGBPoint(upper, 1.0, 1.0, 1.0);
     return cfun;
 }
-//# sourceMappingURL=createLinearRGBTransferFunction.js.map

package/dist/esm/utilities/createSigmoidRGBTransferFunction.d.ts

@@ -1,3 +1,2 @@
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { VOIRange } from '../types';
-export default function createSigmoidRGBTransferFunction(voiRange: VOIRange, approximationNodes?: number): vtkColorTransferFunction;
+import type { VOIRange } from '../types/voi';
+export default function createSigmoidRGBTransferFunction(voiRange: VOIRange, approximationNodes?: number): unknown;

package/dist/esm/utilities/createSigmoidRGBTransferFunction.js

@@ -1,6 +1,6 @@
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import { windowLevel as windowLevelUtil } from '.';
+import * as windowLevelUtil from './windowLevel';
 export default function createSigmoidRGBTransferFunction(voiRange, approximationNodes = 1024) {
     const { windowWidth, windowCenter } = windowLevelUtil.toWindowLevel(voiRange.lower, voiRange.upper);
     const sigmoid = (x, wc, ww) => {
@@ -9,15 +9,15 @@ export default function createSigmoidRGBTransferFunction(voiRange, approximation
     const logit = (y, wc, ww) => {
         return wc - (ww / 4) * Math.log((1 - y) / y);
     };
-    const range = [...Array(approximationNodes + 2).keys()]
-        .map((v) => v / (approximationNodes + 2))
-        .slice(1, -1);
-    const table = range.reduce((res, y) => {
+    const range = Array.from({ length: approximationNodes }, (_, i) => (i + 1) / (approximationNodes + 2));
+    const table = range.flatMap((y) => {
         const x = logit(y, windowCenter, windowWidth);
-        return res.concat(x, y, y, y, 0.5, 0.0);
-    }, []);
+        return [x, y, y, y, 0.5, 0.0];
+    });
     const cfun = vtkColorTransferFunction.newInstance();
-    cfun.buildFunctionFromArray(vtkDataArray.newInstance({ values: table, numberOfComponents: 6 }));
+    cfun.buildFunctionFromArray(vtkDataArray.newInstance({
+        values: table,
+        numberOfComponents: 6,
+    }));
     return cfun;
 }
-//# sourceMappingURL=createSigmoidRGBTransferFunction.js.map

package/dist/esm/utilities/decimate.d.ts

@@ -0,0 +1 @@
+export default function decimate(list: unknown[], interleave: number, offset?: number): number[];

package/dist/esm/utilities/decimate.js

@@ -0,0 +1,7 @@
+export default function decimate(list, interleave, offset = 0) {
+    const interleaveIndices = [];
+    for (let i = offset; i < list.length; i += interleave) {
+        interleaveIndices.push(i);
+    }
+    return interleaveIndices;
+}

package/dist/esm/utilities/deepFreeze.js

@@ -9,4 +9,3 @@ function deepFreeze(object) {
     return Object.freeze(object);
 }
 export default deepFreeze;
-//# sourceMappingURL=deepFreeze.js.map

package/dist/esm/utilities/deepMerge.js

@@ -24,7 +24,7 @@ const defaultArrayMerge = (target, source, optionsArgument) => {
             destination[i] = deepMerge(target[i], e, optionsArgument);
         }
         else if (target.indexOf(e) === -1) {
-            destination.push(cloneIfNecessary(e, optionsArgument));
+            destination[i] = cloneIfNecessary(e, optionsArgument);
         }
     });
     return destination;
@@ -58,4 +58,3 @@ const deepMerge = (target = {}, source = {}, optionsArgument = undefined) => {
     return mergeObject(target, source, optionsArgument);
 };
 export default deepMerge;
-//# sourceMappingURL=deepMerge.js.map

package/dist/esm/utilities/eventListener/MultiTargetEventListenerManager.d.ts

@@ -0,0 +1,7 @@
+declare class MultiTargetEventListenerManager {
+    private _targetsEventListeners;
+    addEventListener(target: EventTarget, type: string, callback: EventListener, options?: AddEventListenerOptions): void;
+    removeEventListener(target: EventTarget, type: string, callback?: EventListener, options?: EventListenerOptions): void;
+    reset(): void;
+}
+export { MultiTargetEventListenerManager as default, MultiTargetEventListenerManager, };

package/dist/esm/utilities/eventListener/MultiTargetEventListenerManager.js

@@ -0,0 +1,31 @@
+import TargetEventListeners from './TargetEventListeners';
+class MultiTargetEventListenerManager {
+    constructor() {
+        this._targetsEventListeners = new Map();
+    }
+    addEventListener(target, type, callback, options) {
+        let eventListeners = this._targetsEventListeners.get(target);
+        if (!eventListeners) {
+            eventListeners = new TargetEventListeners(target);
+            this._targetsEventListeners.set(target, eventListeners);
+        }
+        eventListeners.addEventListener(type, callback, options);
+    }
+    removeEventListener(target, type, callback, options) {
+        const eventListeners = this._targetsEventListeners.get(target);
+        if (!eventListeners) {
+            return;
+        }
+        eventListeners.removeEventListener(type, callback, options);
+        if (eventListeners.isEmpty) {
+            this._targetsEventListeners.delete(target);
+        }
+    }
+    reset() {
+        Array.from(this._targetsEventListeners.entries()).forEach(([target, targetEventListeners]) => {
+            targetEventListeners.reset();
+            this._targetsEventListeners.delete(target);
+        });
+    }
+}
+export { MultiTargetEventListenerManager as default, MultiTargetEventListenerManager, };

package/dist/esm/utilities/eventListener/TargetEventListeners.d.ts

@@ -0,0 +1,15 @@
+declare class TargetEventListeners {
+    private _target;
+    private _eventListeners;
+    private _children;
+    constructor(target: EventTarget);
+    get isEmpty(): boolean;
+    addEventListener(type: string, callback: EventListener, options?: AddEventListenerOptions): void;
+    removeEventListener(type: string, callback?: EventListener, options?: EventListenerOptions): void;
+    reset(): void;
+    private _addEventListener;
+    private _removeEventListener;
+    private _unregisterAllListeners;
+    private _unregisterAllEvents;
+}
+export { TargetEventListeners as default, TargetEventListeners };

package/dist/esm/utilities/eventListener/TargetEventListeners.js

@@ -0,0 +1,130 @@
+var EventListenerPhases;
+(function (EventListenerPhases) {
+    EventListenerPhases[EventListenerPhases["None"] = 0] = "None";
+    EventListenerPhases[EventListenerPhases["Capture"] = 1] = "Capture";
+    EventListenerPhases[EventListenerPhases["Bubble"] = 2] = "Bubble";
+})(EventListenerPhases || (EventListenerPhases = {}));
+class TargetEventListeners {
+    constructor(target) {
+        this._eventListeners = new Map();
+        this._children = new Map();
+        this._target = target;
+    }
+    get isEmpty() {
+        return this._eventListeners.size === 0 && this._children.size === 0;
+    }
+    addEventListener(type, callback, options) {
+        const dotIndex = type.indexOf('.');
+        const isNamespace = dotIndex !== -1;
+        if (isNamespace) {
+            const namespaceToken = type.substring(0, dotIndex);
+            let childElementEventListener = this._children.get(namespaceToken);
+            if (!childElementEventListener) {
+                childElementEventListener = new TargetEventListeners(this._target);
+                this._children.set(namespaceToken, childElementEventListener);
+            }
+            type = type.substring(dotIndex + 1);
+            childElementEventListener.addEventListener(type, callback, options);
+        }
+        else {
+            this._addEventListener(type, callback, options);
+        }
+    }
+    removeEventListener(type, callback, options) {
+        const dotIndex = type.indexOf('.');
+        const isNamespace = dotIndex !== -1;
+        if (isNamespace) {
+            const namespaceToken = type.substring(0, dotIndex);
+            const childElementEventListener = this._children.get(namespaceToken);
+            if (!childElementEventListener) {
+                return;
+            }
+            type = type.substring(dotIndex + 1);
+            childElementEventListener.removeEventListener(type, callback, options);
+            if (childElementEventListener.isEmpty) {
+                this._children.delete(namespaceToken);
+            }
+        }
+        else {
+            this._removeEventListener(type, callback, options);
+        }
+    }
+    reset() {
+        Array.from(this._children.entries()).forEach(([namespace, child]) => {
+            child.reset();
+            if (child.isEmpty) {
+                this._children.delete(namespace);
+            }
+            else {
+                throw new Error('Child is not empty and cannot be removed');
+            }
+        });
+        this._unregisterAllEvents();
+    }
+    _addEventListener(type, callback, options) {
+        let listenersMap = this._eventListeners.get(type);
+        if (!listenersMap) {
+            listenersMap = new Map();
+            this._eventListeners.set(type, listenersMap);
+        }
+        const useCapture = options.capture ?? false;
+        const listenerPhase = useCapture
+            ? EventListenerPhases.Capture
+            : EventListenerPhases.Bubble;
+        const registeredPhases = listenersMap.get(callback) ?? EventListenerPhases.None;
+        if (registeredPhases & listenerPhase) {
+            console.warn('A listener is already registered for this phase');
+            return;
+        }
+        listenersMap.set(callback, registeredPhases | listenerPhase);
+        this._target.addEventListener(type, callback, options);
+    }
+    _removeEventListener(type, callback, options) {
+        const useCapture = options.capture ?? false;
+        const listenerPhase = useCapture
+            ? EventListenerPhases.Capture
+            : EventListenerPhases.Bubble;
+        const listenersMap = this._eventListeners.get(type);
+        if (!listenersMap) {
+            return;
+        }
+        const callbacks = callback ? [callback] : Array.from(listenersMap.keys());
+        callbacks.forEach((callbackItem) => {
+            const registeredPhases = listenersMap.get(callbackItem) ?? EventListenerPhases.None;
+            const phaseRegistered = !!(registeredPhases & listenerPhase);
+            if (!phaseRegistered) {
+                return;
+            }
+            this._target.removeEventListener(type, callbackItem, options);
+            const newListenerPhase = registeredPhases ^ listenerPhase;
+            if (newListenerPhase === EventListenerPhases.None) {
+                listenersMap.delete(callbackItem);
+            }
+            else {
+                listenersMap.set(callbackItem, newListenerPhase);
+            }
+        });
+        if (!listenersMap.size) {
+            this._eventListeners.delete(type);
+        }
+    }
+    _unregisterAllListeners(type, listenersMap) {
+        Array.from(listenersMap.entries()).forEach(([listener, eventPhases]) => {
+            const startPhase = EventListenerPhases.Capture;
+            for (let currentPhase = startPhase; eventPhases; currentPhase <<= 1) {
+                if (!(eventPhases & currentPhase)) {
+                    continue;
+                }
+                const useCapture = currentPhase === EventListenerPhases.Capture ? true : false;
+                this.removeEventListener(type, listener, { capture: useCapture });
+                eventPhases ^= currentPhase;
+            }
+        });
+    }
+    _unregisterAllEvents() {
+        Array.from(this._eventListeners.entries()).forEach(([type, listenersMap]) => {
+            this._unregisterAllListeners(type, listenersMap);
+        });
+    }
+}
+export { TargetEventListeners as default, TargetEventListeners };

package/dist/esm/utilities/eventListener/index.d.ts

@@ -0,0 +1,2 @@
+export { TargetEventListeners } from './TargetEventListeners';
+export { MultiTargetEventListenerManager } from './MultiTargetEventListenerManager';

package/dist/esm/utilities/eventListener/index.js

@@ -0,0 +1,2 @@
+export { TargetEventListeners } from './TargetEventListeners';
+export { MultiTargetEventListenerManager } from './MultiTargetEventListenerManager';

package/dist/esm/utilities/generateVolumePropsFromImageIds.d.ts

@@ -0,0 +1,3 @@
+import type { ImageVolumeProps } from '../types';
+declare function generateVolumePropsFromImageIds(imageIds: string[], volumeId: string): ImageVolumeProps;
+export { generateVolumePropsFromImageIds };