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

package/dist/esm/types/CPUFallbackViewport.d.ts

@@ -1,7 +1,7 @@
-import CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplayedArea';
-import CPUFallbackColormap from './CPUFallbackColormap';
-import CPUFallbackLUT from './CPUFallbackLUT';
-type CPUFallbackViewport = {
+import type CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplayedArea';
+import type CPUFallbackColormap from './CPUFallbackColormap';
+import type CPUFallbackLUT from './CPUFallbackLUT';
+interface CPUFallbackViewport {
     scale?: number;
     parallelScale?: number;
     focalPoint?: number[];
@@ -23,5 +23,5 @@ type CPUFallbackViewport = {
     colormap?: CPUFallbackColormap;
     displayedArea?: CPUFallbackViewportDisplayedArea;
     modality?: string;
-};
-export default CPUFallbackViewport;
+}
+export type { CPUFallbackViewport as default };

package/dist/esm/types/CPUFallbackViewportDisplayedArea.d.ts

@@ -1,4 +1,4 @@
-type CPUFallbackViewportDisplayedArea = {
+interface CPUFallbackViewportDisplayedArea {
     tlhc: {
         x: number;
         y: number;
@@ -10,5 +10,5 @@ type CPUFallbackViewportDisplayedArea = {
     rowPixelSpacing: number;
     columnPixelSpacing: number;
     presentationSizeMode: string;
-};
-export default CPUFallbackViewportDisplayedArea;
+}
+export type { CPUFallbackViewportDisplayedArea as default };

package/dist/esm/types/CPUIImageData.d.ts

@@ -1,6 +1,11 @@
-import type { Point3, Scaling, Mat3, PixelDataTypedArray } from '../types';
-import IImageCalibration from './IImageCalibration';
-type CPUImageData = {
+import type { Point3 } from './Point3';
+import type { Scaling } from './ScalingParameters';
+import type Mat3 from './Mat3';
+import type { PixelDataTypedArray } from './PixelDataTypedArray';
+import type RGB from './RGB';
+import type IImageCalibration from './IImageCalibration';
+import type { IVoxelManager } from './IVoxelManager';
+interface CPUImageData {
     worldToIndex?: (point: Point3) => Point3;
     indexToWorld?: (point: Point3) => Point3;
     getWorldToIndex?: () => Point3;
@@ -9,11 +14,13 @@ type CPUImageData = {
     getDirection?: () => Mat3;
     getScalarData?: () => PixelDataTypedArray;
     getDimensions?: () => Point3;
-};
-type CPUIImageData = {
+    getRange?: () => [number, number];
+}
+interface CPUIImageData {
     dimensions: Point3;
     direction: Mat3;
     spacing: Point3;
+    numberOfComponents?: number;
     origin: Point3;
     imageData: CPUImageData;
     metadata: {
@@ -21,9 +28,10 @@ type CPUIImageData = {
         FrameOfReferenceUID: string;
     };
     scalarData: PixelDataTypedArray;
-    scaling: Scaling;
+    scaling?: Scaling;
     hasPixelSpacing?: boolean;
     calibration?: IImageCalibration;
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
     preScale?: {
         scaled?: boolean;
         scalingParameters?: {
@@ -33,6 +41,6 @@ type CPUIImageData = {
             suvbw?: number;
         };
     };
-};
-export default CPUIImageData;
-export { CPUImageData };
+}
+export type { CPUIImageData as default };
+export type { CPUImageData };

package/dist/esm/types/Color.d.ts

@@ -1,2 +1,2 @@
 export type Color = [number, number, number, number];
-export type ColorLUT = Array<Color>;
+export type ColorLUT = Color[];

package/dist/esm/types/Colormap.d.ts

@@ -1,15 +1,15 @@
-import RGB from './RGB';
-type ColormapRegistration = {
+import type RGB from './RGB';
+interface ColormapRegistration {
     ColorSpace: string;
     Name: string;
     RGBPoints: RGB[] | number[];
-};
-type OpacityMapping = {
+}
+interface OpacityMapping {
     value: number;
     opacity: number;
-};
-type ColormapPublic = {
+}
+interface ColormapPublic {
     name?: string;
     opacity?: OpacityMapping[] | number;
-};
+}
 export type { ColormapRegistration, ColormapPublic, OpacityMapping };

package/dist/esm/types/ContourData.d.ts

@@ -1,17 +1,17 @@
-import { ContourType } from '../enums';
-import Point3 from './Point3';
+import type { ContourType } from '../enums';
+import type Point3 from './Point3';
 type PublicContourSetData = ContourSetData;
-type ContourSetData = {
+interface ContourSetData {
     id: string;
     data: ContourData[];
     frameOfReferenceUID: string;
     color?: Point3;
     segmentIndex?: number;
-};
-type ContourData = {
+}
+interface ContourData {
     points: Point3[];
     type: ContourType;
     color: Point3;
     segmentIndex: number;
-};
+}
 export type { PublicContourSetData, ContourSetData, ContourData };

package/dist/esm/types/Cornerstone3DConfig.d.ts

@@ -1,14 +1,14 @@
-import type { TierResult, GetGPUTier } from 'detect-gpu';
-type Cornerstone3DConfig = {
-    gpuTier?: TierResult;
+interface Cornerstone3DConfig {
+    gpuTier: {
+        tier: number;
+    };
     isMobile: boolean;
-    detectGPUConfig: GetGPUTier;
     rendering: {
         preferSizeOverAccuracy: boolean;
         useNorm16Texture: boolean;
         useCPURendering: boolean;
         strictZSpacingForVolumeViewport: boolean;
     };
-    enableCacheOptimization: boolean;
-};
-export default Cornerstone3DConfig;
+    peerImport?: (moduleId: string) => any;
+}
+export type { Cornerstone3DConfig as default };

package/dist/esm/types/CustomEventType.d.ts

@@ -1,5 +1,5 @@
-interface CustomEvent<T = any> extends Event {
+interface CustomEvent<T = unknown> extends Event {
     readonly detail: T;
     initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;
 }
-export default CustomEvent;
+export type { CustomEvent as default };

package/dist/esm/types/EventTypes.d.ts

@@ -7,26 +7,26 @@ import type ICamera from './ICamera';
 import type IImage from './IImage';
 import type IImageVolume from './IImageVolume';
 import type { VOIRange } from './voi';
-import VOILUTFunctionType from '../enums/VOILUTFunctionType';
-import ViewportStatus from '../enums/ViewportStatus';
+import type VOILUTFunctionType from '../enums/VOILUTFunctionType';
+import type ViewportStatus from '../enums/ViewportStatus';
 import type DisplayArea from './displayArea';
-import IImageCalibration from './IImageCalibration';
-import { ColormapPublic } from './Colormap';
-type CameraModifiedEventDetail = {
+import type IImageCalibration from './IImageCalibration';
+import type { ColormapPublic } from './Colormap';
+interface CameraModifiedEventDetail {
     previousCamera: ICamera;
     camera: ICamera;
     element: HTMLDivElement;
     viewportId: string;
     renderingEngineId: string;
-};
-type CameraResetEventDetail = {
+}
+interface CameraResetEventDetail {
     element: HTMLDivElement;
     viewportId: string;
     renderingEngineId: string;
     camera: ICamera;
-};
+}
 type CameraResetEvent = CustomEventType<CameraResetEventDetail>;
-type VoiModifiedEventDetail = {
+interface VoiModifiedEventDetail {
     viewportId: string;
     range: VOIRange;
     volumeId?: string;
@@ -34,98 +34,98 @@ type VoiModifiedEventDetail = {
     invert?: boolean;
     invertStateChanged?: boolean;
     colormap?: ColormapPublic;
-};
-type ColormapModifiedEventDetail = {
+}
+interface ColormapModifiedEventDetail {
     viewportId: string;
     colormap: ColormapPublic;
     volumeId?: string;
-};
-type DisplayAreaModifiedEventDetail = {
+}
+interface DisplayAreaModifiedEventDetail {
     viewportId: string;
     displayArea: DisplayArea;
     volumeId?: string;
     storeAsInitialCamera?: boolean;
-};
-type ElementDisabledEventDetail = {
+}
+interface ElementDisabledEventDetail {
     element: HTMLDivElement;
     viewportId: string;
     renderingEngineId: string;
-};
-type ElementEnabledEventDetail = {
+}
+interface ElementEnabledEventDetail {
     element: HTMLDivElement;
     viewportId: string;
     renderingEngineId: string;
-};
-type ImageRenderedEventDetail = {
+}
+interface ImageRenderedEventDetail {
     element: HTMLDivElement;
     viewportId: string;
     renderingEngineId: string;
     suppressEvents?: boolean;
     viewportStatus: ViewportStatus;
-};
-type ImageVolumeModifiedEventDetail = {
-    imageVolume: IImageVolume;
+}
+interface ImageVolumeModifiedEventDetail {
+    volumeId: string;
     FrameOfReferenceUID: string;
     numberOfFrames: number;
     framesProcessed: number;
-};
-type ImageVolumeLoadingCompletedEventDetail = {
+}
+interface ImageVolumeLoadingCompletedEventDetail {
     volumeId: string;
     FrameOfReferenceUID: string;
-};
-type ImageLoadedEventDetail = {
+}
+interface ImageLoadedEventDetail {
     image: IImage;
-};
-export type ImageLoadStageEventDetail = {
+}
+export interface ImageLoadStageEventDetail {
     stageId: string;
     numberOfImages: number;
     numberOfFailures: number;
     stageDurationInMS: number;
     startDurationInMS: number;
-};
-type ImageLoadedFailedEventDetail = {
+}
+interface ImageLoadedFailedEventDetail {
     imageId: string;
     error: unknown;
-};
-type VolumeLoadedEventDetail = {
+}
+interface VolumeLoadedEventDetail {
     volume: IImageVolume;
-};
-type VolumeLoadedFailedEventDetail = {
+}
+interface VolumeLoadedFailedEventDetail {
     volumeId: string;
     error: unknown;
-};
-type ImageCacheImageRemovedEventDetail = {
+}
+interface ImageCacheImageRemovedEventDetail {
     imageId: string;
-};
-type ImageCacheImageAddedEventDetail = {
+}
+interface ImageCacheImageAddedEventDetail {
     image: ICachedImage;
-};
-type VolumeCacheVolumeRemovedEventDetail = {
+}
+interface VolumeCacheVolumeRemovedEventDetail {
     volumeId: string;
-};
-type VolumeCacheVolumeAddedEventDetail = {
+}
+interface VolumeCacheVolumeAddedEventDetail {
     volume: ICachedVolume;
-};
-type PreStackNewImageEventDetail = {
+}
+interface PreStackNewImageEventDetail {
     imageId: string;
     imageIdIndex: number;
     viewportId: string;
     renderingEngineId: string;
-};
-type StackNewImageEventDetail = {
+}
+interface StackNewImageEventDetail {
     image: IImage;
     imageId: string;
     imageIdIndex: number;
     viewportId: string;
     renderingEngineId: string;
-};
-type VolumeNewImageEventDetail = {
+}
+interface VolumeNewImageEventDetail {
     imageIndex: number;
     numberOfSlices: number;
     viewportId: string;
     renderingEngineId: string;
-};
-type ImageSpacingCalibratedEventDetail = {
+}
+interface ImageSpacingCalibratedEventDetail {
     element: HTMLDivElement;
     viewportId: string;
     renderingEngineId: string;
@@ -133,18 +133,18 @@ type ImageSpacingCalibratedEventDetail = {
     calibration: IImageCalibration;
     imageData: vtkImageData;
     worldToIndex: mat4;
-};
-type StackViewportNewStackEventDetail = {
+}
+interface StackViewportNewStackEventDetail {
     imageIds: string[];
     viewportId: string;
     element: HTMLDivElement;
     currentImageIdIndex: number;
-};
-type StackViewportScrollEventDetail = {
+}
+interface StackViewportScrollEventDetail {
     newImageIdIndex: number;
     imageId: string;
     direction: number;
-};
+}
 type CameraModifiedEvent = CustomEventType<CameraModifiedEventDetail>;
 type VoiModifiedEvent = CustomEventType<VoiModifiedEventDetail>;
 type ColormapModifiedEvent = CustomEventType<ColormapModifiedEventDetail>;

package/dist/esm/types/FlipDirection.d.ts

@@ -1,5 +1,5 @@
-type FlipDirection = {
+interface FlipDirection {
     flipHorizontal?: boolean;
     flipVertical?: boolean;
-};
-export default FlipDirection;
+}
+export type { FlipDirection as default };

package/dist/esm/types/IActor.d.ts

@@ -1,5 +1,5 @@
 import type vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
-import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
+import type vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
 import type vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
 export type Actor = vtkActor;
 export type VolumeActor = vtkVolume;
@@ -11,10 +11,10 @@ export interface ICanvasActor {
     isA(actorType: any): boolean;
     getClassName(): string;
 }
-export type ActorEntry = {
+export interface ActorEntry {
     uid: string;
     actor: Actor | VolumeActor | ImageActor | ICanvasActor;
     referencedId?: string;
     slabThickness?: number;
     clippingFilter?: any;
-};
+}

package/dist/esm/types/ICache.d.ts

@@ -1,12 +1,12 @@
-import { IImageLoadObject, IVolumeLoadObject } from './ILoadObject';
+import type { IImageLoadObject, IVolumeLoadObject } from './ILoadObject';
 interface ICache {
     setMaxCacheSize: (maxCacheSize: number) => void;
     getMaxCacheSize: () => number;
     getCacheSize: () => number;
-    putImageLoadObject: (imageId: string, imageLoadObject: IImageLoadObject, updateCache?: boolean) => Promise<any>;
+    putImageLoadObject: (imageId: string, imageLoadObject: IImageLoadObject, updateCache?: boolean) => void;
     getImageLoadObject: (imageId: string) => IImageLoadObject | void;
-    putVolumeLoadObject: (volumeId: string, volumeLoadObject: IVolumeLoadObject) => Promise<any>;
+    putVolumeLoadObject: (volumeId: string, volumeLoadObject: IVolumeLoadObject) => void;
     getVolumeLoadObject: (volumeId: string) => IVolumeLoadObject | void;
     purgeCache: () => void;
 }
-export default ICache;
+export type { ICache as default };

package/dist/esm/types/ICachedGeometry.d.ts

@@ -1,5 +1,5 @@
-import IGeometry from './IGeometry';
-import { IGeometryLoadObject } from './ILoadObject';
+import type IGeometry from './IGeometry';
+import type { IGeometryLoadObject } from './ILoadObject';
 interface ICachedGeometry {
     geometryId: string;
     geometryLoadObject: IGeometryLoadObject;
@@ -8,4 +8,4 @@ interface ICachedGeometry {
     sizeInBytes: number;
     geometry?: IGeometry;
 }
-export default ICachedGeometry;
+export type { ICachedGeometry as default };

package/dist/esm/types/ICachedImage.d.ts

@@ -1,4 +1,5 @@
-import { IImage, IImageLoadObject } from '../types';
+import type IImage from './IImage';
+import type { IImageLoadObject } from './ILoadObject';
 interface ICachedImage {
     image?: IImage;
     imageId: string;
@@ -8,4 +9,4 @@ interface ICachedImage {
     timeStamp: number;
     sizeInBytes: number;
 }
-export default ICachedImage;
+export type { ICachedImage as default };

package/dist/esm/types/ICachedVolume.d.ts

@@ -1,4 +1,5 @@
-import { IImageVolume, IVolumeLoadObject } from '../types';
+import type IImageVolume from './IImageVolume';
+import type { IVolumeLoadObject } from './ILoadObject';
 interface ICachedVolume {
     volume?: IImageVolume;
     volumeId: string;
@@ -7,4 +8,4 @@ interface ICachedVolume {
     timeStamp: number;
     sizeInBytes: number;
 }
-export default ICachedVolume;
+export type { ICachedVolume as default };

package/dist/esm/types/ICamera.d.ts

@@ -1,5 +1,5 @@
-import Point3 from './Point3';
-import Point2 from './Point2';
+import type Point3 from './Point3';
+import type Point2 from './Point2';
 interface ICamera {
     focalPoint?: Point3;
     parallelProjection?: boolean;
@@ -14,4 +14,4 @@ interface ICamera {
     flipVertical?: boolean;
     clippingRange?: Point2;
 }
-export default ICamera;
+export type { ICamera as default };

package/dist/esm/types/IContour.d.ts

@@ -1,10 +1,11 @@
-import { Point3 } from '.';
-import { ContourType } from '../enums';
+import type { Point3 } from './Point3';
+import type { ContourType } from '../enums';
+import type RGB from './RGB';
 export interface IContour {
     readonly id: string;
     readonly sizeInBytes: number;
     points: Point3[];
-    color: any;
+    color: RGB;
     _getSizeInBytes(): number;
     getPoints(): Point3[];
     getColor(): Point3;

package/dist/esm/types/IContourSet.d.ts

@@ -1,4 +1,7 @@
-import { ContourData, IContour, Point3 } from './';
+import type { ContourData } from './ContourData';
+import type { IContour } from './IContour';
+import type { Point3 } from './Point3';
+import type RGB from './RGB';
 export interface IContourSet {
     readonly id: string;
     readonly sizeInBytes: number;
@@ -8,7 +11,7 @@ export interface IContourSet {
     getSizeInBytes(): number;
     getSegmentIndex(): number;
     getCentroid(): Point3;
-    getColor(): any;
+    getColor(): RGB;
     getContours(): IContour[];
     getFlatPointsArray(): Point3[];
     getNumberOfContours(): number;

package/dist/esm/types/IDynamicImageVolume.d.ts

@@ -1,8 +1,8 @@
-import { IImageVolume, PixelDataTypedArray } from '../types';
+import type IImageVolume from './IImageVolume';
 interface IDynamicImageVolume extends IImageVolume {
     get timePointIndex(): number;
     set timePointIndex(newTimePointIndex: number);
     get numTimePoints(): number;
-    getScalarDataArrays(): PixelDataTypedArray[];
+    scroll(delta: number): void;
 }
-export default IDynamicImageVolume;
+export type { IDynamicImageVolume as default };

package/dist/esm/types/IEnabledElement.d.ts

@@ -1,4 +1,4 @@
-import type { IRenderingEngine } from '../types';
+import type IRenderingEngine from './IRenderingEngine';
 import type IStackViewport from './IStackViewport';
 import type IVolumeViewport from './IVolumeViewport';
 interface IEnabledElement {
@@ -8,4 +8,4 @@ interface IEnabledElement {
     renderingEngineId: string;
     FrameOfReferenceUID: string;
 }
-export default IEnabledElement;
+export type { IEnabledElement as default };

package/dist/esm/types/IGeometry.d.ts

@@ -1,10 +1,10 @@
-import { GeometryType } from '../enums';
-import { IContourSet } from './IContourSet';
-import { ISurface } from './ISurface';
+import type { GeometryType } from '../enums';
+import type { IContourSet } from './IContourSet';
+import type { ISurface } from './ISurface';
 interface IGeometry {
     id: string;
     type: GeometryType;
     data: IContourSet | ISurface;
     sizeInBytes: number;
 }
-export default IGeometry;
+export type { IGeometry as default };

package/dist/esm/types/IImage.d.ts

@@ -1,11 +1,12 @@
 import type CPUFallbackLUT from './CPUFallbackLUT';
 import type CPUFallbackColormap from './CPUFallbackColormap';
 import type CPUFallbackEnabledElement from './CPUFallbackEnabledElement';
-import type { PixelDataTypedArray } from './PixelDataTypedArray';
-import type VoxelManager from '../utilities/VoxelManager';
-import { ImageQualityStatus } from '../enums';
-import IImageCalibration from './IImageCalibration';
-import RGB from './RGB';
+import type { PixelDataTypedArray, PixelDataTypedArrayString } from './PixelDataTypedArray';
+import type { ImageQualityStatus } from '../enums';
+import type IImageCalibration from './IImageCalibration';
+import type RGB from './RGB';
+import type IImageFrame from './IImageFrame';
+import type { IVoxelManager } from './IVoxelManager';
 interface IImage {
     imageId: string;
     referencedImageId?: string;
@@ -36,7 +37,7 @@ interface IImage {
     width: number;
     color: boolean;
     rgba: boolean;
-    numComps: number;
+    numberOfComponents: number;
     render?: (enabledElement: CPUFallbackEnabledElement, invalidated: boolean) => unknown;
     columnPixelSpacing: number;
     rowPixelSpacing: number;
@@ -70,17 +71,18 @@ interface IImage {
         windowCenter?: number | number[];
         invert?: boolean;
         lutArray?: Uint8ClampedArray;
-        modalityLUT?: unknown;
+        modalityLUT?: CPUFallbackLUT;
         voiLUT?: CPUFallbackLUT;
     };
     imageQualityStatus?: ImageQualityStatus;
     calibration?: IImageCalibration;
-    imageFrame?: any;
+    imageFrame?: IImageFrame;
     FrameOfReferenceUID?: string;
-    voxelManager?: VoxelManager<number> | VoxelManager<RGB>;
+    dataType: PixelDataTypedArrayString;
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
     bufferView?: {
         buffer: ArrayBuffer;
         offset: number;
     };
 }
-export default IImage;
+export type { IImage as default };

package/dist/esm/types/IImageCalibration.d.ts

@@ -1,4 +1,4 @@
-import CalibrationTypes from '../enums/CalibrationTypes';
+import type CalibrationTypes from '../enums/CalibrationTypes';
 export interface IImageCalibration {
     rowPixelSpacing?: number;
     columnPixelSpacing?: number;
@@ -8,4 +8,4 @@ export interface IImageCalibration {
     tooltip?: string;
     sequenceOfUltrasoundRegions?: Record<string, unknown>[];
 }
-export default IImageCalibration;
+export type { IImageCalibration as default };

package/dist/esm/types/IImageData.d.ts

@@ -1,12 +1,18 @@
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { Point3, Scaling, Mat3 } from '../types';
-import IImageCalibration from './IImageCalibration';
+import type { Point3 } from './Point3';
+import type { Scaling } from './ScalingParameters';
+import type Mat3 from './Mat3';
+import type { PixelDataTypedArray } from './PixelDataTypedArray';
+import type RGB from './RGB';
+import type IImageCalibration from './IImageCalibration';
+import type { IVoxelManager } from './IVoxelManager';
 interface IImageData {
     dimensions: Point3;
     direction: Mat3;
     spacing: Point3;
+    numberOfComponents?: number;
     origin: Point3;
-    scalarData: Float32Array | Uint16Array | Uint8Array | Int16Array;
+    scalarData: PixelDataTypedArray;
     imageData: vtkImageData;
     metadata: {
         Modality: string;
@@ -14,6 +20,7 @@ interface IImageData {
     };
     scaling?: Scaling;
     hasPixelSpacing?: boolean;
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
     calibration?: IImageCalibration;
     preScale?: {
         scaled?: boolean;
@@ -25,4 +32,4 @@ interface IImageData {
         };
     };
 }
-export default IImageData;
+export type { IImageData as default };