@cornerstonejs/core 1.23.4 → 1.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.23.4",
+  "version": "1.24.0",
   "description": "",
   "main": "src/index.ts",
   "types": "dist/esm/index.d.ts",
@@ -46,5 +46,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "fbd7662554d78d9db96d83e3d29369db6024b70b"
+  "gitHead": "7db76a5a136c78e1532f0abe90f4c2f9613ac68f"
 }

package/src/RenderingEngine/helpers/cpuFallback/rendering/renderPseudoColorImage.ts

@@ -8,10 +8,7 @@ import storedPixelDataToCanvasImageDataPseudocolorLUT from './storedPixelDataToC
 import storedPixelDataToCanvasImageDataPseudocolorLUTPET from './storedPixelDataToCanvasImageDataPseudocolorLUTPET';
 import * as colors from '../colors/index';
 import type { IImage, CPUFallbackEnabledElement } from '../../../../types';
-
-function clamp(value: number, min: number, max: number) {
-  return Math.max(min, Math.min(max, value));
-}
+import { clamp } from '../../../../utilities';
 
 /**
  * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate

package/src/types/index.ts

@@ -14,7 +14,7 @@ import type IRegisterImageLoader from './IRegisterImageLoader';
 import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
 import type CustomEventType from './CustomEventType';
 import type { IViewport, PublicViewportInput } from './IViewport';
-import type { VolumeActor, Actor, ActorEntry } from './IActor';
+import type { VolumeActor, Actor, ActorEntry, ImageActor } from './IActor';
 import type {
   IImageLoadObject,
   IVolumeLoadObject,
@@ -121,6 +121,7 @@ export type {
   VolumeActor,
   Actor,
   ActorEntry,
+  ImageActor,
   IImageLoadObject,
   IVolumeLoadObject,
   IVolumeInput,

package/src/utilities/clamp.ts

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

package/src/utilities/eventListener/MultiTargetEventListenerManager.ts

@@ -0,0 +1,90 @@
+import TargetEventListeners from './TargetEventListeners';
+
+/**
+ * MultiTargetEventListenerManager allows you to add event listeners to multiple
+ * HTML elements (targets) with support for event types with namespace,
+ * allow removing events without having to pass a callback and makes it possible
+ * to remove all event lsiteners from all HTML elements in a much simpler avoiding
+ * leaving listeners behind which would result in memory leaks.
+ *
+ * @example
+ * Adding and removing event listeners
+ * ```javascript
+ *   const eventListenerManager = new MultiTargetEventListenerManager()
+ *   const element1 = document.getElementById('foo');
+ *   const element2 = document.getElementById('bar');
+ *   const mouseoverCallback = () => { };
+ *   const mouseoutCallback = () => { };
+ *   const dragCallback = () => { };
+ *
+ *   eventListenerManager.addEventListener(element1, 'mouseover', mouseoverCallback);
+ *   eventListenerManager.addEventListener(element1, 'mouseout', mouseoutCallback);
+ *
+ *   eventListenerManager.addEventListener(element2, 'voi.mousemove', dragCallback);
+ *   eventListenerManager.addEventListener(element2, 'voi.drag', dragCallback);
+ *   eventListenerManager.addEventListener(element2, 'voi.mouseup', () => {
+ *     // do not need to store a reference of this function
+ *   }));
+ *
+ *   // Removes a specific event listener from element2
+ *   eventListenerManager.removeEventListener(element2, 'voi.mousemove', dragCallback)
+ *
+ *   // Removes all "mouseup" event listeners added to "voi" namespace on element2
+ *   eventListenerManager.removeEventListener(element2, 'voi.mouseup')
+ *
+ *   // Removes all event listeners added to element1 and element2
+ *   eventListenerManager.reset();
+ * ```
+ */
+class MultiTargetEventListenerManager {
+  private _targetsEventListeners = new Map<EventTarget, TargetEventListeners>();
+
+  public addEventListener(
+    target: EventTarget,
+    type: string,
+    callback: EventListener,
+    options?: AddEventListenerOptions
+  ) {
+    let eventListeners = this._targetsEventListeners.get(target);
+
+    if (!eventListeners) {
+      eventListeners = new TargetEventListeners(target);
+      this._targetsEventListeners.set(target, eventListeners);
+    }
+
+    eventListeners.addEventListener(type, callback, options);
+  }
+
+  public removeEventListener(
+    target: EventTarget,
+    type: string,
+    callback?: EventListener,
+    options?: EventListenerOptions
+  ) {
+    const eventListeners = this._targetsEventListeners.get(target);
+
+    if (!eventListeners) {
+      return;
+    }
+
+    eventListeners.removeEventListener(type, callback, options);
+
+    if (eventListeners.isEmpty) {
+      this._targetsEventListeners.delete(target);
+    }
+  }
+
+  public reset() {
+    Array.from(this._targetsEventListeners.entries()).forEach(
+      ([target, targetEventListeners]) => {
+        targetEventListeners.reset();
+        this._targetsEventListeners.delete(target);
+      }
+    );
+  }
+}
+
+export {
+  MultiTargetEventListenerManager as default,
+  MultiTargetEventListenerManager,
+};

package/src/utilities/eventListener/TargetEventListeners.ts

@@ -0,0 +1,278 @@
+enum EventListenerPhases {
+  None = 0,
+  Capture = 1,
+  Bubble = 2,
+}
+
+type ListenersMap = Map<EventListener, EventListenerPhases>;
+
+/**
+ * TargetEventListeners adds support for event types with namespace, allow
+ * removing events without having to pass a callback and makes it possible to
+ * remove all event listeners in a much simpler avoiding leaving listeners behind
+ * which would result in memory leaks.
+ *
+ * @example
+ * Creating a new TargetEventListeners instance
+ * ```javascript
+ *   const element = document.getElementById('foo');
+ *   const targetEventListeners = new TargetEventListeners(element)
+ * ```
+ *
+ * @example
+ * Adding and removing event listeners
+ * ```javascript
+ *   const dragCallback = () => { };
+ *
+ *   targetEventListeners.addEventListener('voi.mousemove', dragCallback);
+ *   targetEventListeners.addEventListener('voi.drag', dragCallback);
+ *   targetEventListeners.addEventListener('voi.mouseup', () => {
+ *     // do not need to store a reference of this function
+ *   }));
+ *
+ *   // Removes a specific event listener
+ *   targetEventListeners.removeEventListener('voi.mousemove', dragCallback)
+ *
+ *   // Removes all "mouseup" event listeners added to "colorbar.voi" namespace
+ *   targetEventListeners.removeEventListener('voi.mouseup')
+ *
+ *   // Removes all event listeners added to the element using this targetEventListeners
+ *   // instance. A TargetEventListeners instance does not removes the event listeners
+ *   // added by another one.
+ *   targetEventListeners.reset();
+ * ```
+ *
+ * @example
+ * Adding and removing event listeners for capture and bubble phases. Each
+ * listener must be removed indenpendently
+ * ```javascript
+ *   const clickCaptureCallback = () => { };
+ *   const clickBubbleCallback = () => { };
+ *
+ *   targetEventListeners.addEventListener('click', clickCaptureCallback, { capture: true });
+ *   targetEventListeners.addEventListener('click', clickBubbleCallback);
+ *
+ *   // Removes the event listener added to the capture phase
+ *   targetEventListeners.removeEventListener('click', clickCaptureCallback, { capture: true });
+ *
+ *   // Removes the event listener added to the bubble phase
+ *   targetEventListeners.removeEventListener('click', clickBubbleCallback);
+ *
+ *   // Removes all event listeners added to the HTML element
+ *   targetEventListeners.reset();
+ * ```
+
+ */
+class TargetEventListeners {
+  private _target: EventTarget;
+  private _eventListeners = new Map<string, ListenersMap>();
+  private _children = new Map<string, TargetEventListeners>();
+
+  constructor(target: EventTarget) {
+    this._target = target;
+  }
+
+  public get isEmpty() {
+    return this._eventListeners.size === 0 && this._children.size === 0;
+  }
+
+  public addEventListener(
+    type: string,
+    callback: EventListener,
+    options?: AddEventListenerOptions
+  ) {
+    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);
+    }
+  }
+
+  /**
+   * Remove an event listener with support for namespaces and optional callback
+   * which makes it remove all listeners of a given type
+   * @param type - Event type
+   * @param callback - Event listener
+   * @param options - Event options
+   */
+  public removeEventListener(
+    type: string,
+    callback?: EventListener,
+    options?: EventListenerOptions
+  ): void {
+    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);
+
+      // remove empty child objects
+      if (childElementEventListener.isEmpty) {
+        this._children.delete(namespaceToken);
+      }
+    } else {
+      this._removeEventListener(type, callback, options);
+    }
+  }
+
+  /**
+   * Loop through all types, listeners and phases and removing all of them
+   */
+  public reset() {
+    // Destroy all children (DFS - depth first search)
+    Array.from(this._children.entries()).forEach(([namespace, child]) => {
+      child.reset();
+
+      if (child.isEmpty) {
+        this._children.delete(namespace);
+      } else {
+        // This scenario must never happen (safety only)
+        throw new Error('Child is not empty and cannot be removed');
+      }
+    });
+
+    this._unregisterAllEvents();
+  }
+
+  private _addEventListener(
+    type: string,
+    callback: EventListener,
+    options?: AddEventListenerOptions
+  ) {
+    let listenersMap = this._eventListeners.get(type);
+
+    if (!listenersMap) {
+      listenersMap = new Map<EventListener, EventListenerPhases>();
+      this._eventListeners.set(type, listenersMap);
+    }
+
+    const useCapture = options?.capture ?? false;
+    const listenerPhase = useCapture
+      ? EventListenerPhases.Capture
+      : EventListenerPhases.Bubble;
+    const registeredPhases =
+      listenersMap.get(callback) ?? EventListenerPhases.None;
+
+    // Bitwise operator to see if the current phase is already registered
+    // because the same listener may be register twice (capturing and bubbling
+    // phases)
+    if (registeredPhases & listenerPhase) {
+      console.warn('A listener is already registered for this phase');
+      return;
+    }
+
+    // Add a new event listener or updates the existing one for the phase requested
+    listenersMap.set(callback, registeredPhases | listenerPhase);
+
+    // Add the event listener to the target
+    this._target.addEventListener(type, callback, options);
+  }
+
+  private _removeEventListener(
+    type: string,
+    callback?: EventListener,
+    options?: EventListenerOptions
+  ): void {
+    const useCapture = options?.capture ?? false;
+    const listenerPhase = useCapture
+      ? EventListenerPhases.Capture
+      : EventListenerPhases.Bubble;
+
+    const listenersMap = this._eventListeners.get(type);
+
+    if (!listenersMap) {
+      return;
+    }
+
+    // It can remove a single or all callbacks for a given namespace
+    const callbacks = callback ? [callback] : Array.from(listenersMap.keys());
+
+    callbacks.forEach((callbackItem) => {
+      const registeredPhases =
+        listenersMap.get(callbackItem) ?? EventListenerPhases.None;
+
+      // Bitwise operation to see if the phase is registered
+      const phaseRegistered = !!(registeredPhases & listenerPhase);
+
+      if (!phaseRegistered) {
+        return;
+      }
+
+      // Remove the event listener from the target
+      this._target.removeEventListener(type, callbackItem, options);
+
+      // Since it is enabled we can XOR it to zero the bit in that position
+      //   00000011 (capture & buble) ^ 00000010 (buble) = 00000001 (capture)
+      const newListenerPhase = registeredPhases ^ listenerPhase;
+
+      // Deletes the listener if it is no more used in capturing or bubbling
+      // phases or updates it otherwise
+      if (newListenerPhase === EventListenerPhases.None) {
+        listenersMap.delete(callbackItem);
+      } else {
+        listenersMap.set(callbackItem, newListenerPhase);
+      }
+    });
+
+    // Deletes the event from the main map if there are no listeners anymore
+    if (!listenersMap.size) {
+      this._eventListeners.delete(type);
+    }
+  }
+
+  private _unregisterAllListeners(type: string, listenersMap: ListenersMap) {
+    // Creates a copy with Array.from() because the map mutates every
+    // time an event listener is removed
+    Array.from(listenersMap.entries()).forEach(([listener, eventPhases]) => {
+      const startPhase = EventListenerPhases.Capture;
+
+      // currentPhase start at 1 and shifts 1 bit to the left because
+      // EventListenerPhases is a power of 2
+      for (let currentPhase = startPhase; eventPhases; currentPhase <<= 1) {
+        // Check if the current phase is registered
+        if (!(eventPhases & currentPhase)) {
+          continue;
+        }
+
+        const useCapture =
+          currentPhase === EventListenerPhases.Capture ? true : false;
+
+        // Remove the event listener for this given phase
+        this.removeEventListener(type, listener, { capture: useCapture });
+
+        // Switch the bit from the "currentPhase" from 1 to 0
+        eventPhases ^= currentPhase;
+      }
+    });
+  }
+
+  private _unregisterAllEvents() {
+    // Creates a copy with Array.from() because the map mutates every
+    // time an event listener is removed
+    Array.from(this._eventListeners.entries()).forEach(([type, listenersMap]) =>
+      this._unregisterAllListeners(type, listenersMap)
+    );
+  }
+}
+
+export { TargetEventListeners as default, TargetEventListeners };

package/src/utilities/eventListener/index.ts

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

package/src/utilities/getViewportModality.ts

@@ -0,0 +1,23 @@
+import { IViewport } from '../types';
+import { StackViewport, VolumeViewport } from '../RenderingEngine';
+import cache from '../cache';
+
+function getViewportModality(viewport: IViewport, volumeId?: string): string {
+  if (viewport instanceof StackViewport) {
+    return viewport.modality;
+  }
+
+  if (viewport instanceof VolumeViewport) {
+    volumeId = volumeId ?? viewport.getDefaultActor()?.uid;
+
+    if (!volumeId) {
+      return;
+    }
+
+    return cache.getVolume(volumeId)?.metadata.Modality;
+  }
+
+  throw new Error('Invalid viewport type');
+}
+
+export { getViewportModality as default, getViewportModality };

package/src/utilities/index.ts

@@ -1,3 +1,4 @@
+import * as eventListener from './eventListener';
 import csUtils from './invertRgbTransferFunction';
 import createSigmoidRGBTransferFunction from './createSigmoidRGBTransferFunction';
 import getVoiFromSigmoidRGBTransferFunction from './getVoiFromSigmoidRGBTransferFunction';
@@ -9,12 +10,14 @@ import getMinMax from './getMinMax';
 import getRuntimeId from './getRuntimeId';
 import imageIdToURI from './imageIdToURI';
 import calibratedPixelSpacingMetadataProvider from './calibratedPixelSpacingMetadataProvider';
+import clamp from './clamp';
 import isEqual from './isEqual';
 import isOpposite from './isOpposite';
 import createUint8SharedArray from './createUint8SharedArray';
 import createFloat32SharedArray from './createFloat32SharedArray';
 import createUint16SharedArray from './createUInt16SharedArray';
 import createInt16SharedArray from './createInt16SharedArray';
+import getViewportModality from './getViewportModality';
 import getClosestImageId from './getClosestImageId';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
@@ -54,6 +57,7 @@ import * as colormap from './colormap';
 import * as transferFunctionUtils from './transferFunctionUtils';
 
 export {
+  eventListener,
   csUtils as invertRgbTransferFunction,
   createSigmoidRGBTransferFunction,
   getVoiFromSigmoidRGBTransferFunction,
@@ -62,6 +66,7 @@ export {
   triggerEvent,
   imageIdToURI,
   calibratedPixelSpacingMetadataProvider,
+  clamp,
   uuidv4,
   planar,
   getMinMax,
@@ -72,6 +77,7 @@ export {
   createUint8SharedArray,
   createUint16SharedArray,
   createInt16SharedArray,
+  getViewportModality,
   windowLevel,
   getClosestImageId,
   getSpacingInNormalDirection,