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

package/dist/esm/enums/index.js

@@ -4,12 +4,14 @@ import ViewportType from './ViewportType';
 import InterpolationType from './InterpolationType';
 import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
-import SharedArrayBufferModes from './SharedArrayBufferModes';
 import GeometryType from './GeometryType';
 import ContourType from './ContourType';
 import VOILUTFunctionType from './VOILUTFunctionType';
 import DynamicOperatorType from './DynamicOperatorType';
 import CalibrationTypes from './CalibrationTypes';
 import ViewportStatus from './ViewportStatus';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, SharedArrayBufferModes, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, };
-//# sourceMappingURL=index.js.map
+import ImageQualityStatus from './ImageQualityStatus';
+import * as VideoEnums from './VideoEnums';
+import MetadataModules from './MetadataModules';
+import { GenerateImageType } from './GenerateImageType';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, GenerateImageType, };

package/dist/esm/eventTarget.d.ts

@@ -1,8 +1,12 @@
 declare class CornerstoneEventTarget implements EventTarget {
     private listeners;
+    private debouncedListeners;
     constructor();
     reset(): void;
+    addEventListenerOnce(type: any, callback: any): void;
     addEventListener(type: any, callback: any): void;
+    addEventListenerDebounced(type: any, callback: any, delay: any): void;
+    removeEventListenerDebounced(type: any, callback: any): void;
     removeEventListener(type: any, callback: any): void;
     dispatchEvent(event: any): boolean;
 }

package/dist/esm/eventTarget.js

@@ -1,9 +1,18 @@
 class CornerstoneEventTarget {
     constructor() {
         this.listeners = {};
+        this.debouncedListeners = {};
     }
     reset() {
         this.listeners = {};
+        this.debouncedListeners = {};
+    }
+    addEventListenerOnce(type, callback) {
+        const onceWrapper = (event) => {
+            this.removeEventListener(type, onceWrapper);
+            callback.call(this, event);
+        };
+        this.addEventListener(type, onceWrapper);
     }
     addEventListener(type, callback) {
         if (!this.listeners[type]) {
@@ -14,6 +23,34 @@ class CornerstoneEventTarget {
         }
         this.listeners[type].push(callback);
     }
+    addEventListenerDebounced(type, callback, delay) {
+        this.debouncedListeners[type] = this.debouncedListeners[type] || {};
+        const debouncedCallbacks = this.debouncedListeners[type];
+        if (!debouncedCallbacks[callback]) {
+            const handle = (event) => {
+                if (debouncedCallbacks[callback]) {
+                    clearTimeout(debouncedCallbacks[callback].timeoutId);
+                }
+                debouncedCallbacks[callback].timeoutId = setTimeout(() => {
+                    callback.call(this, event);
+                }, delay);
+            };
+            debouncedCallbacks[callback] = {
+                original: callback,
+                handle,
+                timeoutId: null,
+            };
+            this.addEventListener(type, handle);
+        }
+    }
+    removeEventListenerDebounced(type, callback) {
+        if (this.debouncedListeners[type]?.[callback]) {
+            const debounced = this.debouncedListeners[type][callback];
+            this.removeEventListener(type, debounced.handle);
+            clearTimeout(debounced.timeoutId);
+            delete this.debouncedListeners[type][callback];
+        }
+    }
     removeEventListener(type, callback) {
         if (!this.listeners[type]) {
             return;
@@ -29,16 +66,20 @@ class CornerstoneEventTarget {
     }
     dispatchEvent(event) {
         if (!this.listeners[event.type]) {
-            return;
+            return !event.defaultPrevented;
         }
         const stack = this.listeners[event.type].slice();
         const stackLength = stack.length;
         for (let i = 0; i < stackLength; i++) {
-            stack[i].call(this, event);
+            try {
+                stack[i].call(this, event);
+            }
+            catch (error) {
+                console.error(`error in event listener of type:  ${event.type}`, error);
+            }
         }
         return !event.defaultPrevented;
     }
 }
 const eventTarget = new CornerstoneEventTarget();
 export default eventTarget;
-//# sourceMappingURL=eventTarget.js.map

package/dist/esm/getEnabledElement.d.ts

@@ -1,4 +1,5 @@
-import { IEnabledElement } from './types';
+import type { IEnabledElement } from './types';
 export default function getEnabledElement(element: HTMLDivElement | undefined): IEnabledElement | undefined;
 export declare function getEnabledElementByIds(viewportId: string, renderingEngineId: string): IEnabledElement;
+export declare function getEnabledElementByViewportId(viewportId: string): IEnabledElement;
 export declare function getEnabledElements(): IEnabledElement[];

package/dist/esm/getEnabledElement.js

@@ -27,6 +27,16 @@ export function getEnabledElementByIds(viewportId, renderingEngineId) {
         FrameOfReferenceUID,
     };
 }
+export function getEnabledElementByViewportId(viewportId) {
+    const renderingEngines = getRenderingEngines();
+    for (let i = 0; i < renderingEngines.length; i++) {
+        const renderingEngine = renderingEngines[i];
+        const viewport = renderingEngine.getViewport(viewportId);
+        if (viewport) {
+            return getEnabledElementByIds(viewportId, renderingEngine.id);
+        }
+    }
+}
 export function getEnabledElements() {
     const enabledElements = [];
     const renderingEngines = getRenderingEngines();
@@ -38,4 +48,3 @@ export function getEnabledElements() {
     });
     return enabledElements;
 }
-//# sourceMappingURL=getEnabledElement.js.map

package/dist/esm/global.d.ts

@@ -1,7 +1,6 @@
 declare global {
     interface Window {
         crossOriginIsolated: unknown;
-        SharedArrayBuffer: unknown;
     }
 }
 export default global;

package/dist/esm/global.js

@@ -1,2 +1 @@
 export default global;
-//# sourceMappingURL=global.js.map

package/dist/esm/index.d.ts

@@ -7,23 +7,27 @@ import VolumeViewport from './RenderingEngine/VolumeViewport';
 import VolumeViewport3D from './RenderingEngine/VolumeViewport3D';
 import BaseVolumeViewport from './RenderingEngine/BaseVolumeViewport';
 import StackViewport from './RenderingEngine/StackViewport';
+import VideoViewport from './RenderingEngine/VideoViewport';
+import WSIViewport from './RenderingEngine/WSIViewport';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { getRenderingEngine, getRenderingEngines } from './RenderingEngine/getRenderingEngine';
-import cache, { ImageVolume } from './cache';
+import cache, { ImageVolume, Surface } from './cache';
 import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
-import getEnabledElement, { getEnabledElementByIds, getEnabledElements } from './getEnabledElement';
+import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements } from './getEnabledElement';
 import * as metaData from './metaData';
-import { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, setUseSharedArrayBuffer, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration } from './init';
+import { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport } from './init';
 import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
 import * as geometryLoader from './loaders/geometryLoader';
-import * as Types from './types';
+import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
+import type * as Types from './types';
+import type { IRetrieveConfiguration, IImagesLoader, RetrieveOptions, RetrieveStage, ImageLoadListener } from './types';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
-import { setVolumesForViewports, addVolumesToViewports } from './RenderingEngine/helpers';
-export type { Types };
-export { init, isCornerstoneInitialized, getConfiguration, setConfiguration, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, RenderingEngine, ImageVolume, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getShouldUseSharedArrayBuffer, setUseSharedArrayBuffer, resetUseSharedArrayBuffer, geometryLoader, };
+import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
+export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
+export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, };

package/dist/esm/index.js

@@ -7,23 +7,24 @@ import VolumeViewport from './RenderingEngine/VolumeViewport';
 import VolumeViewport3D from './RenderingEngine/VolumeViewport3D';
 import BaseVolumeViewport from './RenderingEngine/BaseVolumeViewport';
 import StackViewport from './RenderingEngine/StackViewport';
+import VideoViewport from './RenderingEngine/VideoViewport';
+import WSIViewport from './RenderingEngine/WSIViewport';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { getRenderingEngine, getRenderingEngines, } from './RenderingEngine/getRenderingEngine';
-import cache, { ImageVolume } from './cache';
+import cache, { ImageVolume, Surface } from './cache';
 import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
-import getEnabledElement, { getEnabledElementByIds, getEnabledElements, } from './getEnabledElement';
+import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements, } from './getEnabledElement';
 import * as metaData from './metaData';
-import { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, setUseSharedArrayBuffer, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration, } from './init';
+import { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, } from './init';
 import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
 import * as geometryLoader from './loaders/geometryLoader';
-import * as Types from './types';
+import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
-import { setVolumesForViewports, addVolumesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, getConfiguration, setConfiguration, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, RenderingEngine, ImageVolume, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getShouldUseSharedArrayBuffer, setUseSharedArrayBuffer, resetUseSharedArrayBuffer, geometryLoader, };
-//# sourceMappingURL=index.js.map
+import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
+export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, };

package/dist/esm/init.d.ts

@@ -1,14 +1,13 @@
-import { SharedArrayBufferModes } from './enums';
-import { Cornerstone3DConfig } from './types';
-declare function init(configuration?: Cornerstone3DConfig): Promise<boolean>;
-declare function setUseCPURendering(status: boolean): void;
+import type { Cornerstone3DConfig } from './types';
+declare function init(configuration?: Cornerstone3DConfig): boolean;
+declare function setUseCPURendering(status: boolean, updateViewports?: boolean): void;
 declare function setPreferSizeOverAccuracy(status: boolean): void;
+declare function canRenderFloatTextures(): boolean;
 declare function resetUseCPURendering(): void;
 declare function getShouldUseCPURendering(): boolean;
-declare function setUseSharedArrayBuffer(mode: SharedArrayBufferModes | boolean): void;
-declare function resetUseSharedArrayBuffer(): void;
-declare function getShouldUseSharedArrayBuffer(): boolean;
 declare function isCornerstoneInitialized(): boolean;
 declare function getConfiguration(): Cornerstone3DConfig;
 declare function setConfiguration(c: Cornerstone3DConfig): void;
-export { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setUseSharedArrayBuffer, setPreferSizeOverAccuracy, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration, };
+declare function getWebWorkerManager(): any;
+declare function peerImport(moduleId: string): any;
+export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, };

package/dist/esm/init.js

@@ -1,30 +1,23 @@
-import { getGPUTier } from 'detect-gpu';
-import { SharedArrayBufferModes } from './enums';
 import { getRenderingEngines } from './RenderingEngine/getRenderingEngine';
 let csRenderInitialized = false;
-let useSharedArrayBuffer = true;
-let sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
 import { deepMerge } from './utilities';
+import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager';
 const defaultConfig = {
-    gpuTier: undefined,
-    detectGPUConfig: {},
+    gpuTier: { tier: 2 },
+    isMobile: false,
     rendering: {
         useCPURendering: false,
         preferSizeOverAccuracy: false,
         useNorm16Texture: false,
         strictZSpacingForVolumeViewport: true,
     },
+    peerImport: (moduleId) => null,
 };
 let config = {
-    gpuTier: undefined,
-    detectGPUConfig: {},
-    rendering: {
-        useCPURendering: false,
-        preferSizeOverAccuracy: false,
-        useNorm16Texture: false,
-        strictZSpacingForVolumeViewport: true,
-    },
+    ...defaultConfig,
+    rendering: { ...defaultConfig.rendering },
 };
+let webWorkerManager = null;
 function _getGLContext() {
     const canvas = document.createElement('canvas');
     const gl = canvas.getContext('webgl2') ||
@@ -36,55 +29,74 @@ function _hasActiveWebGLContext() {
     const gl = _getGLContext();
     return (gl instanceof WebGLRenderingContext || gl instanceof WebGL2RenderingContext);
 }
-function hasSharedArrayBuffer() {
-    try {
-        if (new SharedArrayBuffer(0)) {
+function _hasNorm16TextureSupport() {
+    const gl = _getGLContext();
+    if (gl) {
+        const ext = gl.getExtension('EXT_texture_norm16');
+        if (ext) {
             return true;
         }
-        else {
-            return false;
-        }
     }
-    catch {
-        return false;
+    return false;
+}
+function isIOS() {
+    if (/iPad|iPhone|iPod/.test(navigator.platform)) {
+        return true;
+    }
+    else {
+        return (navigator.maxTouchPoints &&
+            navigator.maxTouchPoints > 2 &&
+            navigator.platform.includes('MacIntel'));
     }
 }
-async function init(configuration = config) {
+function init(configuration = config) {
     if (csRenderInitialized) {
         return csRenderInitialized;
     }
     config = deepMerge(defaultConfig, configuration);
+    if (isIOS()) {
+        config.rendering.useNorm16Texture = _hasNorm16TextureSupport();
+        if (!config.rendering.useNorm16Texture) {
+            if (configuration.rendering.preferSizeOverAccuracy) {
+                config.rendering.preferSizeOverAccuracy = true;
+            }
+            else {
+                console.log('norm16 texture not supported, you can turn on the preferSizeOverAccuracy flag to use native data type, but be aware of the inaccuracy of the rendering in high bits');
+            }
+        }
+    }
     const hasWebGLContext = _hasActiveWebGLContext();
     if (!hasWebGLContext) {
         console.log('CornerstoneRender: GPU not detected, using CPU rendering');
         config.rendering.useCPURendering = true;
     }
     else {
-        config.gpuTier =
-            config.gpuTier || (await getGPUTier(config.detectGPUConfig));
-        console.log('CornerstoneRender: Using detect-gpu to get the GPU benchmark:', config.gpuTier);
-        if (config.gpuTier.tier < 1) {
-            console.log('CornerstoneRender: GPU is not powerful enough, using CPU rendering');
-            config.rendering.useCPURendering = true;
-        }
-        else {
-            console.log('CornerstoneRender: using GPU rendering');
-        }
+        console.log('CornerstoneRender: using GPU rendering');
     }
-    setUseSharedArrayBuffer(sharedArrayBufferMode);
     csRenderInitialized = true;
+    if (!webWorkerManager) {
+        webWorkerManager = new CentralizedWebWorkerManager();
+    }
     return csRenderInitialized;
 }
-function setUseCPURendering(status) {
+function setUseCPURendering(status, updateViewports = true) {
     config.rendering.useCPURendering = status;
     csRenderInitialized = true;
-    _updateRenderingPipelinesForAllViewports();
+    if (updateViewports) {
+        _updateRenderingPipelinesForAllViewports();
+    }
 }
 function setPreferSizeOverAccuracy(status) {
     config.rendering.preferSizeOverAccuracy = status;
     csRenderInitialized = true;
     _updateRenderingPipelinesForAllViewports();
 }
+function canRenderFloatTextures() {
+    if (!isIOS()) {
+        return true;
+    }
+    return false;
+}
 function resetUseCPURendering() {
     config.rendering.useCPURendering = !_hasActiveWebGLContext();
     _updateRenderingPipelinesForAllViewports();
@@ -92,38 +104,6 @@ function resetUseCPURendering() {
 function getShouldUseCPURendering() {
     return config.rendering.useCPURendering;
 }
-function setUseSharedArrayBuffer(mode) {
-    if (mode == SharedArrayBufferModes.AUTO) {
-        sharedArrayBufferMode = SharedArrayBufferModes.AUTO;
-        const hasSharedBuffer = hasSharedArrayBuffer();
-        if (!hasSharedBuffer) {
-            useSharedArrayBuffer = false;
-            console.warn(`CornerstoneRender: SharedArray Buffer not allowed, performance may be slower.
-        Try ensuring page is cross-origin isolated to enable SharedArrayBuffer.`);
-        }
-        else {
-            useSharedArrayBuffer = true;
-            console.log('CornerstoneRender: using SharedArrayBuffer');
-        }
-        return;
-    }
-    if (mode == SharedArrayBufferModes.TRUE || mode == true) {
-        sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
-        useSharedArrayBuffer = true;
-        return;
-    }
-    if (mode == SharedArrayBufferModes.FALSE || mode == false) {
-        sharedArrayBufferMode = SharedArrayBufferModes.FALSE;
-        useSharedArrayBuffer = false;
-        return;
-    }
-}
-function resetUseSharedArrayBuffer() {
-    setUseSharedArrayBuffer(sharedArrayBufferMode);
-}
-function getShouldUseSharedArrayBuffer() {
-    return useSharedArrayBuffer;
-}
 function isCornerstoneInitialized() {
     return csRenderInitialized;
 }
@@ -135,9 +115,19 @@ function setConfiguration(c) {
     _updateRenderingPipelinesForAllViewports();
 }
 function _updateRenderingPipelinesForAllViewports() {
-    getRenderingEngines().forEach((engine) => engine
-        .getViewports()
-        .forEach((viewport) => viewport.updateRenderingPipeline?.()));
+    getRenderingEngines().forEach((engine) => {
+        engine.getViewports().forEach((viewport) => {
+            viewport.updateRenderingPipeline();
+        });
+    });
+}
+function getWebWorkerManager() {
+    if (!webWorkerManager) {
+        webWorkerManager = new CentralizedWebWorkerManager();
+    }
+    return webWorkerManager;
+}
+function peerImport(moduleId) {
+    return config.peerImport(moduleId);
 }
-export { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setUseSharedArrayBuffer, setPreferSizeOverAccuracy, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration, };
-//# sourceMappingURL=init.js.map
+export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, };

package/dist/esm/loaders/ProgressiveRetrieveImages.d.ts

@@ -0,0 +1,35 @@
+import type { IRetrieveConfiguration, IImagesLoader, RetrieveStage, ImageLoadListener, RetrieveOptions } from '../types';
+import singleRetrieveStages from './configuration/singleRetrieve';
+import sequentialRetrieveStages from './configuration/sequentialRetrieve';
+import interleavedRetrieveStages from './configuration/interleavedRetrieve';
+import { ImageQualityStatus } from '../enums';
+export { sequentialRetrieveStages, interleavedRetrieveStages, singleRetrieveStages, };
+export interface NearbyRequest {
+    itemId: string;
+    linearId?: string;
+    imageQualityStatus: ImageQualityStatus;
+}
+export interface ProgressiveRequest {
+    imageId: string;
+    stage: RetrieveStage;
+    next?: ProgressiveRequest;
+    nearbyRequests?: NearbyRequest[];
+}
+export declare class ProgressiveRetrieveImages implements IImagesLoader, IRetrieveConfiguration {
+    static createProgressive: typeof createProgressive;
+    static interleavedRetrieveStages: {
+        stages: RetrieveStage[];
+    };
+    static singleRetrieveStages: {
+        stages: RetrieveStage[];
+    };
+    static sequentialRetrieveStages: {
+        stages: RetrieveStage[];
+    };
+    stages: RetrieveStage[];
+    retrieveOptions: Record<string, RetrieveOptions>;
+    constructor(imageRetrieveConfiguration: IRetrieveConfiguration);
+    loadImages(imageIds: string[], listener: ImageLoadListener): Promise<any>;
+}
+export declare function createProgressive(configuration: IRetrieveConfiguration): ProgressiveRetrieveImages;
+export default ProgressiveRetrieveImages;