@cornerstonejs/core 2.0.0-beta.8 → 2.0.0

package/dist/esm/cache/cache.js

@@ -1,16 +1,17 @@
-import { triggerEvent, imageIdToURI } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
+import imageIdToURI from '../utilities/imageIdToURI';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
-import { ImageVolume } from './classes/ImageVolume';
+import { ImageQualityStatus } from '../enums';
 const ONE_GB = 1073741824;
 class Cache {
     constructor() {
         this._imageCache = new Map();
         this._volumeCache = new Map();
+        this._geometryCache = new Map();
         this._imageCacheSize = 0;
-        this._volumeCacheSize = 0;
         this._maxCacheSize = 3 * ONE_GB;
-        this._maxInstanceSize = 4 * ONE_GB - 8;
+        this._geometryCacheSize = 0;
         this.setMaxCacheSize = (newMaxCacheSize) => {
             if (!newMaxCacheSize || typeof newMaxCacheSize !== 'number') {
                 const errorMessage = `New max cacheSize ${this._maxCacheSize} should be defined and should be a number.`;
@@ -19,47 +20,66 @@ class Cache {
             this._maxCacheSize = newMaxCacheSize;
         };
         this.isCacheable = (byteLength) => {
-            if (byteLength > this._maxInstanceSize) {
-                return false;
-            }
-            const unallocatedSpace = this.getBytesAvailable();
-            const imageCacheSize = this._imageCacheSize;
-            const availableSpace = unallocatedSpace + imageCacheSize;
-            return availableSpace > byteLength;
+            const bytesAvailable = this.getBytesAvailable();
+            const purgableImageBytes = Array.from(this._imageCache.values()).reduce((total, image) => {
+                if (!image.sharedCacheKey) {
+                    return total + image.sizeInBytes;
+                }
+                return total;
+            }, 0);
+            const availableSpaceWithoutSharedCacheKey = bytesAvailable + purgableImageBytes;
+            return availableSpaceWithoutSharedCacheKey >= byteLength;
         };
         this.getMaxCacheSize = () => this._maxCacheSize;
-        this.getMaxInstanceSize = () => this._maxInstanceSize;
-        this.getCacheSize = () => this._imageCacheSize + this._volumeCacheSize;
+        this.getCacheSize = () => this._imageCacheSize;
         this._decacheImage = (imageId) => {
-            const { imageLoadObject } = this._imageCache.get(imageId);
-            if (imageLoadObject.cancelFn) {
+            const cachedImage = this._imageCache.get(imageId);
+            if (!cachedImage) {
+                return;
+            }
+            if (cachedImage.sharedCacheKey) {
+                throw new Error('Cannot decache an image with a shared cache key. You need to manually decache the volume first.');
+            }
+            const { imageLoadObject } = cachedImage;
+            if (imageLoadObject?.cancelFn) {
                 imageLoadObject.cancelFn();
             }
-            if (imageLoadObject.decache) {
+            if (imageLoadObject?.decache) {
                 imageLoadObject.decache();
             }
             this._imageCache.delete(imageId);
         };
         this._decacheVolume = (volumeId) => {
             const cachedVolume = this._volumeCache.get(volumeId);
+            if (!cachedVolume) {
+                return;
+            }
             const { volumeLoadObject, volume } = cachedVolume;
+            if (!volume) {
+                return;
+            }
             if (volume.cancelLoading) {
                 volume.cancelLoading();
             }
             if (volume.imageData) {
                 volume.imageData.delete();
             }
-            this._restoreImagesFromBuffer(volume);
             if (volumeLoadObject.cancelFn) {
                 volumeLoadObject.cancelFn();
             }
-            if (volumeLoadObject.decache) {
-                volumeLoadObject.decache();
+            if (volume.imageIds) {
+                volume.imageIds.forEach((imageId) => {
+                    const cachedImage = this._imageCache.get(imageId);
+                    if (cachedImage && cachedImage.sharedCacheKey === volumeId) {
+                        cachedImage.sharedCacheKey = undefined;
+                    }
+                });
             }
             this._volumeCache.delete(volumeId);
         };
         this.purgeCache = () => {
             const imageIterator = this._imageCache.keys();
+            this.purgeVolumeCache();
             while (true) {
                 const { value: imageId, done } = imageIterator.next();
                 if (done) {
@@ -68,7 +88,6 @@ class Cache {
                 this.removeImageLoadObject(imageId);
                 triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_REMOVED, { imageId });
             }
-            this.purgeVolumeCache();
         };
         this.purgeVolumeCache = () => {
             const volumeIterator = this._volumeCache.keys();
@@ -88,41 +107,120 @@ class Cache {
                 throw new Error('getVolumeLoadObject: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 return;
             }
             cachedVolume.timeStamp = Date.now();
             return cachedVolume.volumeLoadObject;
         };
+        this.putGeometryLoadObject = (geometryId, geometryLoadObject) => {
+            if (geometryId === undefined) {
+                throw new Error('putGeometryLoadObject: geometryId must not be undefined');
+            }
+            if (geometryLoadObject.promise === undefined) {
+                throw new Error('putGeometryLoadObject: geometryLoadObject.promise must not be undefined');
+            }
+            if (this._geometryCache.has(geometryId)) {
+                throw new Error('putGeometryLoadObject: geometryId already present in geometryCache');
+            }
+            if (geometryLoadObject.cancelFn &&
+                typeof geometryLoadObject.cancelFn !== 'function') {
+                throw new Error('putGeometryLoadObject: geometryLoadObject.cancel must be a function');
+            }
+            const cachedGeometry = {
+                loaded: false,
+                geometryId,
+                geometryLoadObject,
+                timeStamp: Date.now(),
+                sizeInBytes: 0,
+            };
+            this._geometryCache.set(geometryId, cachedGeometry);
+            return geometryLoadObject.promise
+                .then((geometry) => {
+                try {
+                    this._putGeometryCommon(geometryId, geometry, cachedGeometry);
+                }
+                catch (error) {
+                    console.debug(`Error in _putGeometryCommon for geometry ${geometryId}:`, error);
+                    throw error;
+                }
+            })
+                .catch((error) => {
+                console.debug(`Error caching geometry ${geometryId}:`, error);
+                this._geometryCache.delete(geometryId);
+                throw error;
+            });
+        };
         this.getGeometry = (geometryId) => {
-            if (geometryId == null) {
+            if (geometryId === undefined) {
                 throw new Error('getGeometry: geometryId must not be undefined');
             }
             const cachedGeometry = this._geometryCache.get(geometryId);
-            if (cachedGeometry === undefined) {
+            if (!cachedGeometry) {
                 return;
             }
             cachedGeometry.timeStamp = Date.now();
             return cachedGeometry.geometry;
         };
-        this.getImage = (imageId) => {
+        this.removeGeometryLoadObject = (geometryId) => {
+            if (geometryId === undefined) {
+                throw new Error('removeGeometryLoadObject: geometryId must not be undefined');
+            }
+            const cachedGeometry = this._geometryCache.get(geometryId);
+            if (!cachedGeometry) {
+                throw new Error('removeGeometryLoadObject: geometryId was not present in geometryCache');
+            }
+            this.decrementGeometryCacheSize(cachedGeometry.sizeInBytes);
+            const eventDetails = {
+                geometry: cachedGeometry,
+                geometryId,
+            };
+            triggerEvent(eventTarget, Events.GEOMETRY_CACHE_GEOMETRY_REMOVED, eventDetails);
+            this._decacheGeometry(geometryId);
+        };
+        this._decacheGeometry = (geometryId) => {
+            const cachedGeometry = this._geometryCache.get(geometryId);
+            if (!cachedGeometry) {
+                return;
+            }
+            const { geometryLoadObject } = cachedGeometry;
+            if (geometryLoadObject.cancelFn) {
+                geometryLoadObject.cancelFn();
+            }
+            if (geometryLoadObject.decache) {
+                geometryLoadObject.decache();
+            }
+            this._geometryCache.delete(geometryId);
+        };
+        this.incrementGeometryCacheSize = (increment) => {
+            this._geometryCacheSize += increment;
+        };
+        this.decrementGeometryCacheSize = (decrement) => {
+            this._geometryCacheSize -= decrement;
+        };
+        this.getImage = (imageId, minQuality = ImageQualityStatus.FAR_REPLICATE) => {
             if (imageId === undefined) {
                 throw new Error('getImage: imageId must not be undefined');
             }
             const cachedImage = this._imageCache.get(imageId);
-            if (cachedImage === undefined) {
+            if (!cachedImage) {
                 return;
             }
             cachedImage.timeStamp = Date.now();
+            if (cachedImage.image?.imageQualityStatus < minQuality) {
+                return;
+            }
             return cachedImage.image;
         };
-        this.getVolume = (volumeId) => {
+        this.getVolume = (volumeId, allowPartialMatch = false) => {
             if (volumeId === undefined) {
                 throw new Error('getVolume: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
-                return;
+            if (!cachedVolume) {
+                return allowPartialMatch
+                    ? [...this._volumeCache.values()].find((cv) => cv.volumeId.includes(volumeId))?.volume
+                    : undefined;
             }
             cachedVolume.timeStamp = Date.now();
             return cachedVolume.volume;
@@ -142,7 +240,7 @@ class Cache {
                 throw new Error('removeImageLoadObject: imageId must not be undefined');
             }
             const cachedImage = this._imageCache.get(imageId);
-            if (cachedImage === undefined) {
+            if (!cachedImage) {
                 throw new Error('removeImageLoadObject: imageId was not present in imageCache');
             }
             this.incrementImageCacheSize(-cachedImage.sizeInBytes);
@@ -158,10 +256,9 @@ class Cache {
                 throw new Error('removeVolumeLoadObject: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 throw new Error('removeVolumeLoadObject: volumeId was not present in volumeCache');
             }
-            this.incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
             const eventDetails = {
                 volume: cachedVolume,
                 volumeId,
@@ -169,58 +266,23 @@ class Cache {
             triggerEvent(eventTarget, Events.VOLUME_CACHE_VOLUME_REMOVED, eventDetails);
             this._decacheVolume(volumeId);
         };
-        this.putGeometryLoadObject = (geometryId, geometryLoadObject) => {
-            if (geometryId == undefined) {
-                throw new Error('putGeometryLoadObject: geometryId must not be undefined');
-            }
-            if (this._geometryCache.has(geometryId)) {
-                throw new Error('putGeometryLoadObject: geometryId already present in geometryCache');
-            }
-            const cachedGeometry = {
-                geometryId,
-                geometryLoadObject,
-                loaded: false,
-                timeStamp: Date.now(),
-                sizeInBytes: 0,
-            };
-            this._geometryCache.set(geometryId, cachedGeometry);
-            return geometryLoadObject.promise
-                .then((geometry) => {
-                if (!this._geometryCache.has(geometryId)) {
-                    console.warn('putGeometryLoadObject: geometryId was removed from geometryCache');
-                    return;
-                }
-                if (Number.isNaN(geometry.sizeInBytes)) {
-                    throw new Error('putGeometryLoadObject: geometry.sizeInBytes is not a number');
-                }
-                cachedGeometry.loaded = true;
-                cachedGeometry.geometry = geometry;
-                cachedGeometry.sizeInBytes = geometry.sizeInBytes;
-                const eventDetails = {
-                    geometry,
-                    geometryId,
-                };
-                triggerEvent(eventTarget, Events.GEOMETRY_CACHE_GEOMETRY_ADDED, eventDetails);
-                return;
-            })
-                .catch((error) => {
-                this._geometryCache.delete(geometryId);
-                throw error;
-            });
-        };
         this.incrementImageCacheSize = (increment) => {
             this._imageCacheSize += increment;
         };
-        this.incrementVolumeCacheSize = (increment) => {
-            this._volumeCacheSize += increment;
-        };
         this.decrementImageCacheSize = (decrement) => {
             this._imageCacheSize -= decrement;
         };
-        this.decrementVolumeCacheSize = (decrement) => {
-            this._volumeCacheSize -= decrement;
+        this.getGeometryLoadObject = (geometryId) => {
+            if (geometryId === undefined) {
+                throw new Error('getGeometryLoadObject: geometryId must not be undefined');
+            }
+            const cachedGeometry = this._geometryCache.get(geometryId);
+            if (!cachedGeometry) {
+                return;
+            }
+            cachedGeometry.timeStamp = Date.now();
+            return cachedGeometry.geometryLoadObject;
         };
-        this._geometryCache = new Map();
     }
     getBytesAvailable() {
         return this.getMaxCacheSize() - this.getCacheSize();
@@ -230,7 +292,7 @@ class Cache {
         if (bytesAvailable >= numBytes) {
             return bytesAvailable;
         }
-        let cachedImages = Array.from(this._imageCache.values());
+        const cachedImages = Array.from(this._imageCache.values()).filter((cachedImage) => !cachedImage.sharedCacheKey);
         function compare(a, b) {
             if (a.timeStamp > b.timeStamp) {
                 return 1;
@@ -241,7 +303,7 @@ class Cache {
             return 0;
         }
         cachedImages.sort(compare);
-        let cachedImageIds = cachedImages.map((im) => im.imageId);
+        const cachedImageIds = cachedImages.map((im) => im.imageId);
         let imageIdsToPurge = cachedImageIds;
         if (volumeImageIds) {
             imageIdsToPurge = cachedImageIds.filter((id) => !volumeImageIds.includes(id));
@@ -254,8 +316,6 @@ class Cache {
                 return bytesAvailable;
             }
         }
-        cachedImages = Array.from(this._imageCache.values());
-        cachedImageIds = cachedImages.map((im) => im.imageId);
         for (const imageId of cachedImageIds) {
             this.removeImageLoadObject(imageId);
             triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_REMOVED, { imageId });
@@ -265,21 +325,56 @@ class Cache {
             }
         }
     }
-    putImageLoadObject(imageId, imageLoadObject) {
+    _putImageCommon(imageId, image, cachedImage) {
+        if (!this._imageCache.has(imageId)) {
+            console.warn('The image was purged from the cache before it completed loading.');
+            return;
+        }
+        if (!image) {
+            console.warn('Image is undefined');
+            return;
+        }
+        if (image.sizeInBytes === undefined || Number.isNaN(image.sizeInBytes)) {
+            throw new Error('_putImageCommon: image.sizeInBytes must not be undefined');
+        }
+        if (image.sizeInBytes.toFixed === undefined) {
+            throw new Error('_putImageCommon: image.sizeInBytes is not a number');
+        }
+        if (!this.isCacheable(image.sizeInBytes)) {
+            throw new Error(Events.CACHE_SIZE_EXCEEDED);
+        }
+        this.decacheIfNecessaryUntilBytesAvailable(image.sizeInBytes);
+        cachedImage.loaded = true;
+        cachedImage.image = image;
+        cachedImage.sizeInBytes = image.sizeInBytes;
+        this.incrementImageCacheSize(cachedImage.sizeInBytes);
+        const eventDetails = {
+            image: cachedImage,
+        };
+        triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_ADDED, eventDetails);
+        cachedImage.sharedCacheKey = image.sharedCacheKey;
+    }
+    async putImageLoadObject(imageId, imageLoadObject) {
         if (imageId === undefined) {
+            console.error('putImageLoadObject: imageId must not be undefined');
             throw new Error('putImageLoadObject: imageId must not be undefined');
         }
         if (imageLoadObject.promise === undefined) {
+            console.error('putImageLoadObject: imageLoadObject.promise must not be undefined');
             throw new Error('putImageLoadObject: imageLoadObject.promise must not be undefined');
         }
-        if (this._imageCache.has(imageId)) {
+        const alreadyCached = this._imageCache.get(imageId);
+        if (alreadyCached?.imageLoadObject) {
+            console.warn(`putImageLoadObject: imageId ${imageId} already in cache`);
             throw new Error('putImageLoadObject: imageId already in cache');
         }
         if (imageLoadObject.cancelFn &&
             typeof imageLoadObject.cancelFn !== 'function') {
+            console.error('putImageLoadObject: imageLoadObject.cancel must be a function');
             throw new Error('putImageLoadObject: imageLoadObject.cancel must be a function');
         }
         const cachedImage = {
+            ...alreadyCached,
             loaded: false,
             imageId,
             sharedCacheKey: undefined,
@@ -288,44 +383,55 @@ class Cache {
             sizeInBytes: 0,
         };
         this._imageCache.set(imageId, cachedImage);
+        this._imageCache.set(imageId, cachedImage);
         return imageLoadObject.promise
             .then((image) => {
-            if (!this._imageCache.get(imageId)) {
-                console.warn('The image was purged from the cache before it completed loading.');
-                return;
+            try {
+                this._putImageCommon(imageId, image, cachedImage);
             }
-            if (image.sizeInBytes === undefined ||
-                Number.isNaN(image.sizeInBytes)) {
-                throw new Error('putImageLoadObject: image.sizeInBytes must not be undefined');
-            }
-            if (image.sizeInBytes.toFixed === undefined) {
-                throw new Error('putImageLoadObject: image.sizeInBytes is not a number');
-            }
-            if (!this.isCacheable(image.sizeInBytes)) {
-                throw new Error(Events.CACHE_SIZE_EXCEEDED);
+            catch (error) {
+                console.debug(`Error in _putImageCommon for image ${imageId}:`, error);
+                throw error;
             }
-            this.decacheIfNecessaryUntilBytesAvailable(image.sizeInBytes);
-            cachedImage.loaded = true;
-            cachedImage.image = image;
-            cachedImage.sizeInBytes = image.sizeInBytes;
-            this.incrementImageCacheSize(cachedImage.sizeInBytes);
-            const eventDetails = {
-                image: cachedImage,
-            };
-            triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_ADDED, eventDetails);
-            cachedImage.sharedCacheKey = image.sharedCacheKey;
         })
             .catch((error) => {
+            console.debug(`Error caching image ${imageId}:`, error);
             this._imageCache.delete(imageId);
             throw error;
         });
     }
+    putImageSync(imageId, image) {
+        if (imageId === undefined) {
+            throw new Error('putImageSync: imageId must not be undefined');
+        }
+        if (this._imageCache.has(imageId)) {
+            throw new Error('putImageSync: imageId already in cache');
+        }
+        const cachedImage = {
+            loaded: false,
+            imageId,
+            sharedCacheKey: undefined,
+            imageLoadObject: {
+                promise: Promise.resolve(image),
+            },
+            timeStamp: Date.now(),
+            sizeInBytes: 0,
+        };
+        this._imageCache.set(imageId, cachedImage);
+        try {
+            this._putImageCommon(imageId, image, cachedImage);
+        }
+        catch (error) {
+            this._imageCache.delete(imageId);
+            throw error;
+        }
+    }
     getImageLoadObject(imageId) {
         if (imageId === undefined) {
             throw new Error('getImageLoadObject: imageId must not be undefined');
         }
         const cachedImage = this._imageCache.get(imageId);
-        if (cachedImage === undefined) {
+        if (!cachedImage) {
             return;
         }
         cachedImage.timeStamp = Date.now();
@@ -343,8 +449,11 @@ class Cache {
         const imageIdToUse = imageIdToURI(imageId);
         for (const volumeId of volumeIds) {
             const cachedVolume = this._volumeCache.get(volumeId);
+            if (!cachedVolume) {
+                return;
+            }
             const { volume } = cachedVolume;
-            if (!volume?.imageIds?.length) {
+            if (!volume.imageIds.length) {
                 return;
             }
             const imageIdIndex = volume.getImageURIIndex(imageIdToUse);
@@ -364,7 +473,50 @@ class Cache {
         }
         return this._imageCache.get(foundImageId);
     }
-    putVolumeLoadObject(volumeId, volumeLoadObject) {
+    _putVolumeCommon(volumeId, volume, cachedVolume) {
+        if (!this._volumeCache.get(volumeId)) {
+            console.warn('The volume was purged from the cache before it completed loading.');
+            return;
+        }
+        cachedVolume.loaded = true;
+        cachedVolume.volume = volume;
+        volume.imageIds?.forEach((imageId) => {
+            const image = this._imageCache.get(imageId);
+            if (image) {
+                image.sharedCacheKey = volumeId;
+            }
+        });
+        const eventDetails = {
+            volume: cachedVolume,
+        };
+        triggerEvent(eventTarget, Events.VOLUME_CACHE_VOLUME_ADDED, eventDetails);
+    }
+    putVolumeSync(volumeId, volume) {
+        if (volumeId === undefined) {
+            throw new Error('putVolumeSync: volumeId must not be undefined');
+        }
+        if (this._volumeCache.has(volumeId)) {
+            throw new Error('putVolumeSync: volumeId already in cache');
+        }
+        const cachedVolume = {
+            loaded: false,
+            volumeId,
+            volumeLoadObject: {
+                promise: Promise.resolve(volume),
+            },
+            timeStamp: Date.now(),
+            sizeInBytes: 0,
+        };
+        this._volumeCache.set(volumeId, cachedVolume);
+        try {
+            this._putVolumeCommon(volumeId, volume, cachedVolume);
+        }
+        catch (error) {
+            this._volumeCache.delete(volumeId);
+            throw error;
+        }
+    }
+    async putVolumeLoadObject(volumeId, volumeLoadObject) {
         if (volumeId === undefined) {
             throw new Error('putVolumeLoadObject: volumeId must not be undefined');
         }
@@ -388,60 +540,106 @@ class Cache {
         this._volumeCache.set(volumeId, cachedVolume);
         return volumeLoadObject.promise
             .then((volume) => {
-            if (!this._volumeCache.get(volumeId)) {
-                console.warn('The image was purged from the cache before it completed loading.');
-                return;
-            }
-            if (Number.isNaN(volume.sizeInBytes)) {
-                throw new Error('putVolumeLoadObject: volume.sizeInBytes must not be undefined');
+            try {
+                this._putVolumeCommon(volumeId, volume, cachedVolume);
             }
-            if (volume.sizeInBytes.toFixed === undefined) {
-                throw new Error('putVolumeLoadObject: volume.sizeInBytes is not a number');
+            catch (error) {
+                console.error(`Error in _putVolumeCommon for volume ${volumeId}:`, error);
+                this._volumeCache.delete(volumeId);
+                throw error;
             }
-            this.decacheIfNecessaryUntilBytesAvailable(volume.sizeInBytes, volume.imageIds);
-            cachedVolume.volume = volume;
-            cachedVolume.sizeInBytes = volume.sizeInBytes;
-            this.incrementVolumeCacheSize(cachedVolume.sizeInBytes);
-            const eventDetails = {
-                volume: cachedVolume,
-            };
-            triggerEvent(eventTarget, Events.VOLUME_CACHE_VOLUME_ADDED, eventDetails);
         })
             .catch((error) => {
             this._volumeCache.delete(volumeId);
             throw error;
         });
     }
-    _restoreImagesFromBuffer(volume) {
-        if (!(volume instanceof ImageVolume)) {
-            console.warn('Volume is not an ImageVolume. Cannot restore images from buffer.');
+    _putGeometryCommon(geometryId, geometry, cachedGeometry) {
+        if (!this._geometryCache.get(geometryId)) {
+            console.warn('The geometry was purged from the cache before it completed loading.');
             return;
         }
-        const scalarData = volume.getScalarData();
-        const imageCacheOffsetMap = volume.imageCacheOffsetMap;
-        if (imageCacheOffsetMap.size === 0) {
+        if (!geometry) {
+            console.warn('Geometry is undefined');
             return;
         }
-        for (const [imageId, { offset }] of imageCacheOffsetMap) {
-            const image = this.getImage(imageId);
-            if (!image) {
-                console.warn(`Image with id ${imageId} not found in cache.`);
-                continue;
-            }
-            const viewPixelData = image.getPixelData();
-            const length = viewPixelData.length;
-            const pixelData = new viewPixelData.constructor(scalarData.buffer, offset, length);
-            image.getPixelData = () => pixelData;
-            if (image.imageFrame) {
-                image.imageFrame.pixelData = pixelData;
+        if (geometry.sizeInBytes === undefined ||
+            Number.isNaN(geometry.sizeInBytes)) {
+            throw new Error('_putGeometryCommon: geometry.sizeInBytes must not be undefined');
+        }
+        if (geometry.sizeInBytes.toFixed === undefined) {
+            throw new Error('_putGeometryCommon: geometry.sizeInBytes is not a number');
+        }
+        if (!this.isCacheable(geometry.sizeInBytes)) {
+            throw new Error(Events.CACHE_SIZE_EXCEEDED);
+        }
+        this.decacheIfNecessaryUntilBytesAvailable(geometry.sizeInBytes);
+        cachedGeometry.loaded = true;
+        cachedGeometry.geometry = geometry;
+        cachedGeometry.sizeInBytes = geometry.sizeInBytes;
+        this.incrementGeometryCacheSize(cachedGeometry.sizeInBytes);
+        const eventDetails = {
+            geometry: cachedGeometry,
+        };
+        triggerEvent(eventTarget, Events.GEOMETRY_CACHE_GEOMETRY_ADDED, eventDetails);
+    }
+    putGeometrySync(geometryId, geometry) {
+        if (geometryId === undefined) {
+            throw new Error('putGeometrySync: geometryId must not be undefined');
+        }
+        if (this._geometryCache.has(geometryId)) {
+            throw new Error('putGeometrySync: geometryId already in cache');
+        }
+        const cachedGeometry = {
+            loaded: false,
+            geometryId,
+            geometryLoadObject: {
+                promise: Promise.resolve(geometry),
+            },
+            timeStamp: Date.now(),
+            sizeInBytes: 0,
+        };
+        this._geometryCache.set(geometryId, cachedGeometry);
+        try {
+            this._putGeometryCommon(geometryId, geometry, cachedGeometry);
+        }
+        catch (error) {
+            this._geometryCache.delete(geometryId);
+            throw error;
+        }
+    }
+    setPartialImage(imageId, partialImage) {
+        const cachedImage = this._imageCache.get(imageId);
+        if (!cachedImage) {
+            if (partialImage) {
+                this._imageCache.set(imageId, {
+                    image: partialImage,
+                    imageId,
+                    loaded: false,
+                    timeStamp: Date.now(),
+                    sizeInBytes: 0,
+                });
             }
-            delete image.bufferView;
-            this.incrementImageCacheSize(image.sizeInBytes);
+            return;
+        }
+        if (cachedImage.loaded) {
+            cachedImage.loaded = false;
+            cachedImage.imageLoadObject = null;
+            this.incrementImageCacheSize(-cachedImage.sizeInBytes);
+            cachedImage.sizeInBytes = 0;
+            cachedImage.image = partialImage || cachedImage.image;
         }
-        console.log(`Images restored from buffer for volume ${volume.volumeId}.`);
+        else {
+            cachedImage.image = partialImage || cachedImage.image;
+        }
+    }
+    getImageQuality(imageId) {
+        const image = this._imageCache.get(imageId)?.image;
+        return image
+            ? image.imageQualityStatus || ImageQualityStatus.FULL_RESOLUTION
+            : undefined;
     }
 }
 const cache = new Cache();
 export default cache;
-export { Cache };
-//# sourceMappingURL=cache.js.map
+export { Cache, cache };