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

package/dist/esm/loaders/utils/surface/createSurface.d.ts

@@ -1,2 +1,2 @@
-import { IGeometry, PublicSurfaceData } from '../../../types';
+import type { IGeometry, PublicSurfaceData } from '../../../types';
 export declare function createSurface(geometryId: string, SurfaceData: PublicSurfaceData): IGeometry;

package/dist/esm/loaders/utils/surface/validateSurface.d.ts

@@ -1,2 +1,2 @@
-import { PublicSurfaceData } from '../../../types';
+import type { PublicSurfaceData } from '../../../types';
 export declare function validateSurface(contourSetData: PublicSurfaceData): void;

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

@@ -1,42 +1,34 @@
 import '@kitware/vtk.js/Rendering/Profiles/Volume';
-import { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
+import type { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
 interface VolumeLoaderOptions {
-    imageIds: Array<string>;
+    imageIds: string[];
 }
 interface DerivedVolumeOptions {
     volumeId: string;
-    targetBuffer?: {
-        type: PixelDataTypedArrayString;
-        sharedArrayBuffer?: boolean;
-    };
+    targetBufferType?: PixelDataTypedArrayString;
 }
-interface LocalVolumeOptions {
+export interface LocalVolumeOptions {
     metadata: Metadata;
     dimensions: Point3;
     spacing: Point3;
     origin: Point3;
     direction: Mat3;
     scalarData?: PixelDataTypedArray;
-    imageIds?: Array<string>;
-    referencedImageIds?: Array<string>;
+    imageIds?: string[];
+    referencedImageIds?: string[];
     referencedVolumeId?: string;
-    targetBuffer?: {
-        type: PixelDataTypedArrayString;
-        sharedArrayBuffer?: boolean;
-    };
+    preventCache?: boolean;
+    targetBufferType?: PixelDataTypedArrayString;
 }
 export declare function loadVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<IImageVolume>;
-export declare function createAndCacheEmptyVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<Record<string, any>>;
-export declare function createAndCacheDerivedVolume(referencedVolumeId: string, options: DerivedVolumeOptions): Promise<IImageVolume>;
-export declare function createLocalVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): IImageVolume;
-export declare function createAndCacheVolumeFromImages(volumeId: string, imageIds: string[], options?: {
-    preventCache?: boolean;
-    additionalDetails?: Record<string, any>;
-}): Promise<IImageVolume>;
+export declare function createAndCacheVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<IImageVolume>;
+export declare function createAndCacheDerivedVolume(referencedVolumeId: string, options: DerivedVolumeOptions): IImageVolume;
+export declare function createAndCacheVolumeFromImages(volumeId: string, imageIds: string[]): Promise<IImageVolume>;
+export declare function createLocalVolume(volumeId: string, options?: LocalVolumeOptions): IImageVolume;
 export declare function registerVolumeLoader(scheme: string, volumeLoader: VolumeLoaderFn): void;
 export declare function getVolumeLoaderSchemes(): string[];
 export declare function registerUnknownVolumeLoader(volumeLoader: VolumeLoaderFn): VolumeLoaderFn | undefined;
 export declare function getUnknownVolumeLoaderSchema(): string;
-export declare function createAndCacheDerivedSegmentationVolume(referencedVolumeId: string, options?: DerivedVolumeOptions): Promise<IImageVolume>;
-export declare function createLocalSegmentationVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): Promise<IImageVolume>;
+export declare function createAndCacheDerivedSegmentationVolume(referencedVolumeId: string, options?: DerivedVolumeOptions): IImageVolume;
+export declare function createLocalSegmentationVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): IImageVolume;
 export {};

package/dist/esm/loaders/volumeLoader.js

@@ -1,56 +1,12 @@
 import '@kitware/vtk.js/Rendering/Profiles/Volume';
-import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import { ImageVolume } from '../cache/classes/ImageVolume';
 import cache from '../cache/cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
-import { createUint16SharedArray, createUint8SharedArray, createFloat32SharedArray, generateVolumePropsFromImageIds, getBufferConfiguration, uuidv4, } from '../utilities';
-import { getConfiguration, getShouldUseSharedArrayBuffer } from '../init';
-import { performCacheOptimizationForVolume, setupCacheOptimizationEventListener, } from '../utilities/cacheUtils';
-function addScalarDataToImageData(imageData, scalarData, dataArrayAttrs) {
-    const scalarArray = vtkDataArray.newInstance({
-        name: `Pixels`,
-        values: scalarData,
-        ...dataArrayAttrs,
-    });
-    imageData.getPointData().setScalars(scalarArray);
-}
-function addScalarDataArraysToImageData(imageData, scalarDataArrays, dataArrayAttrs) {
-    scalarDataArrays.forEach((scalarData, i) => {
-        const vtkScalarArray = vtkDataArray.newInstance({
-            name: `timePoint-${i}`,
-            values: scalarData,
-            ...dataArrayAttrs,
-        });
-        imageData.getPointData().addArray(vtkScalarArray);
-    });
-    imageData.getPointData().setActiveScalars('timePoint-0');
-}
-function createInternalVTKRepresentation(volume) {
-    const { dimensions, metadata, spacing, direction, origin } = volume;
-    const { PhotometricInterpretation } = metadata;
-    let numComponents = 1;
-    if (PhotometricInterpretation === 'RGB') {
-        numComponents = 3;
-    }
-    const imageData = vtkImageData.newInstance();
-    const dataArrayAttrs = { numberOfComponents: numComponents };
-    imageData.setDimensions(dimensions);
-    imageData.setSpacing(spacing);
-    imageData.setDirection(direction);
-    imageData.setOrigin(origin);
-    if (volume.isDynamicVolume()) {
-        const scalarDataArrays = (volume).getScalarDataArrays();
-        addScalarDataArraysToImageData(imageData, scalarDataArrays, dataArrayAttrs);
-    }
-    else {
-        const scalarData = volume.getScalarData();
-        addScalarDataToImageData(imageData, scalarData, dataArrayAttrs);
-    }
-    return imageData;
-}
+import { getBufferConfiguration, uuidv4, VoxelManager } from '../utilities';
+import { imageLoader } from '..';
+import { createAndCacheLocalImage } from './imageLoader';
 const volumeLoaders = {};
 let unknownVolumeLoader;
 function loadVolumeFromVolumeLoader(volumeId, options) {
@@ -65,7 +21,6 @@ function loadVolumeFromVolumeLoader(volumeId, options) {
         loader = unknownVolumeLoader;
     }
     const volumeLoadObject = loader(volumeId, options);
-    setupCacheOptimizationEventListener(volumeId);
     volumeLoadObject.promise.then(function (volume) {
         triggerEvent(eventTarget, Events.VOLUME_LOADED, { volume });
     }, function (error) {
@@ -87,179 +42,112 @@ export function loadVolume(volumeId, options = { imageIds: [] }) {
     }
     volumeLoadObject = loadVolumeFromVolumeLoader(volumeId, options);
     return volumeLoadObject.promise.then((volume) => {
-        volume.imageData = createInternalVTKRepresentation(volume);
         return volume;
     });
 }
-export async function createAndCacheEmptyVolume(volumeId, options) {
+export async function createAndCacheVolume(volumeId, options) {
     if (volumeId === undefined) {
-        throw new Error('createAndCacheEmptyVolume: parameter volumeId must not be undefined');
+        throw new Error('createAndCacheVolume: parameter volumeId must not be undefined');
     }
     let volumeLoadObject = cache.getVolumeLoadObject(volumeId);
     if (volumeLoadObject !== undefined) {
         return volumeLoadObject.promise;
     }
     volumeLoadObject = loadVolumeFromVolumeLoader(volumeId, options);
-    volumeLoadObject.promise.then((volume) => {
-        volume.imageData = createInternalVTKRepresentation(volume);
-    });
-    cache.putVolumeLoadObject(volumeId, volumeLoadObject).catch((err) => {
-        throw err;
-    });
+    cache.putVolumeLoadObject(volumeId, volumeLoadObject);
     return volumeLoadObject.promise;
 }
-export async function createAndCacheDerivedVolume(referencedVolumeId, options) {
+export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     const referencedVolume = cache.getVolume(referencedVolumeId);
     if (!referencedVolume) {
         throw new Error(`Cannot created derived volume: Referenced volume with id ${referencedVolumeId} does not exist.`);
     }
     let { volumeId } = options;
-    const { targetBuffer } = options;
     if (volumeId === undefined) {
         volumeId = uuidv4();
     }
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
-    const scalarData = referencedVolume.getScalarData();
-    const scalarLength = scalarData.length;
-    const { volumeScalarData, numBytes } = generateVolumeScalarData(targetBuffer, scalarLength);
-    const scalarArray = vtkDataArray.newInstance({
-        name: 'Pixels',
-        numberOfComponents: 1,
-        values: volumeScalarData,
-    });
-    const derivedImageData = vtkImageData.newInstance();
-    derivedImageData.setDimensions(dimensions);
-    derivedImageData.setSpacing(spacing);
-    derivedImageData.setDirection(direction);
-    derivedImageData.setOrigin(origin);
-    derivedImageData.getPointData().setScalars(scalarArray);
     const referencedImageIds = referencedVolume.imageIds ?? [];
-    let derivedVolumeImageIds = [];
-    if (referencedImageIds.length) {
-        derivedVolumeImageIds = referencedImageIds.map((imageId) => {
-            return `derived:${imageId}`;
-        });
-    }
+    const derivedImages = imageLoader.createAndCacheDerivedImages(referencedImageIds, {
+        targetBufferType: options.targetBufferType,
+    });
+    const dataType = derivedImages[0].dataType;
+    const derivedVolumeImageIds = derivedImages.map((image) => image.imageId);
     const derivedVolume = new ImageVolume({
         volumeId,
+        dataType,
         metadata: structuredClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
         direction,
-        imageData: derivedImageData,
-        scalarData: volumeScalarData,
-        sizeInBytes: numBytes,
         referencedVolumeId,
         imageIds: derivedVolumeImageIds,
         referencedImageIds: referencedVolume.imageIds ?? [],
     });
-    const volumeLoadObject = {
-        promise: Promise.resolve(derivedVolume),
-    };
-    await cache.putVolumeLoadObject(volumeId, volumeLoadObject);
-    performCacheOptimizationForVolume(derivedVolume);
+    cache.putVolumeSync(volumeId, derivedVolume);
     return derivedVolume;
 }
-export function createLocalVolume(options, volumeId, preventCache = false) {
-    const { metadata, dimensions, spacing, origin, direction, targetBuffer } = options;
-    let { scalarData } = options;
-    const validDataTypes = [
-        'Uint8Array',
-        'Float32Array',
-        'Uint16Array',
-        'Int16Array',
-    ];
-    const scalarLength = dimensions[0] * dimensions[1] * dimensions[2];
-    if (!scalarData || !validDataTypes.includes(scalarData.constructor.name)) {
-        if (!targetBuffer?.type || !validDataTypes.includes(targetBuffer.type)) {
-            throw new Error('createLocalVolume: parameter scalarData must be provided and must be either Uint8Array, Float32Array, Uint16Array or Int16Array');
-        }
-        ({ volumeScalarData: scalarData } = generateVolumeScalarData(targetBuffer, scalarLength));
+export async function createAndCacheVolumeFromImages(volumeId, imageIds) {
+    if (imageIds === undefined) {
+        throw new Error('createAndCacheVolumeFromImages: parameter imageIds must not be undefined');
     }
     if (volumeId === undefined) {
-        volumeId = uuidv4();
+        throw new Error('createAndCacheVolumeFromImages: parameter volumeId must not be undefined');
     }
     const cachedVolume = cache.getVolume(volumeId);
     if (cachedVolume) {
         return cachedVolume;
     }
-    const numBytes = scalarData ? scalarData.buffer.byteLength : scalarLength * 4;
-    const isCacheable = cache.isCacheable(numBytes);
-    if (!isCacheable) {
-        throw new Error(Events.CACHE_SIZE_EXCEEDED);
+    const volume = (await createAndCacheVolume(volumeId, {
+        imageIds,
+    }));
+    return volume;
+}
+export function createLocalVolume(volumeId, options = {}) {
+    const { metadata, dimensions, spacing, origin, direction, scalarData, targetBufferType, preventCache = false, } = options;
+    const cachedVolume = cache.getVolume(volumeId);
+    if (cachedVolume) {
+        return cachedVolume;
     }
-    const scalarArray = vtkDataArray.newInstance({
-        name: 'Pixels',
-        numberOfComponents: 1,
-        values: scalarData,
-    });
-    const imageData = vtkImageData.newInstance();
-    imageData.setDimensions(dimensions);
-    imageData.setSpacing(spacing);
-    imageData.setDirection(direction);
-    imageData.setOrigin(origin);
-    imageData.getPointData().setScalars(scalarArray);
-    const derivedVolume = new ImageVolume({
+    const sliceLength = dimensions[0] * dimensions[1];
+    const dataType = scalarData
+        ? scalarData.constructor.name
+        : targetBufferType;
+    const imageIds = [];
+    const derivedImages = [];
+    for (let i = 0; i < dimensions[2]; i++) {
+        const imageId = `${volumeId}_slice_${i}`;
+        imageIds.push(imageId);
+        const sliceData = scalarData.subarray(i * sliceLength, (i + 1) * sliceLength);
+        const derivedImage = createAndCacheLocalImage(imageId, {
+            scalarData: sliceData,
+            dimensions: [dimensions[0], dimensions[1]],
+            spacing: [spacing[0], spacing[1]],
+            origin,
+            direction,
+            targetBufferType: dataType,
+        });
+        derivedImages.push(derivedImage);
+    }
+    const imageVolume = new ImageVolume({
         volumeId,
         metadata: structuredClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
         direction,
-        imageData: imageData,
-        scalarData,
-        sizeInBytes: numBytes,
-        referencedImageIds: options.referencedImageIds || [],
-        referencedVolumeId: options.referencedVolumeId,
-        imageIds: options.imageIds || [],
+        imageIds,
+        dataType,
     });
-    if (preventCache) {
-        return derivedVolume;
-    }
-    const volumeLoadObject = {
-        promise: Promise.resolve(derivedVolume),
-    };
-    cache.putVolumeLoadObject(volumeId, volumeLoadObject);
-    performCacheOptimizationForVolume(derivedVolume);
-    return derivedVolume;
-}
-export async function createAndCacheVolumeFromImages(volumeId, imageIds, options = {}) {
-    const { preventCache = false } = options;
-    if (imageIds === undefined) {
-        throw new Error('createAndCacheVolumeFromImages: parameter imageIds must not be undefined');
-    }
-    if (volumeId === undefined) {
-        throw new Error('createAndCacheVolumeFromImages: parameter volumeId must not be undefined');
-    }
-    const cachedVolume = cache.getVolume(volumeId);
-    if (cachedVolume) {
-        return Promise.resolve(cachedVolume);
-    }
-    const volumeProps = generateVolumePropsFromImageIds(imageIds, volumeId);
-    const imagePromises = volumeProps.imageIds.map((imageId, imageIdIndex) => {
-        const imageLoadObject = cache.getImageLoadObject(imageId);
-        return imageLoadObject.promise.then((image) => {
-            const pixelData = image.getPixelData();
-            const offset = imageIdIndex * image.rows * image.columns;
-            volumeProps.scalarData.set(pixelData, offset);
-        });
-    });
-    await Promise.all(imagePromises);
-    const volume = new ImageVolume({
-        ...volumeProps,
-        referencedImageIds: imageIds,
-        ...options,
+    const voxelManager = VoxelManager.createImageVolumeVoxelManager({
+        imageIds,
+        dimensions,
+        numberOfComponents: 1,
     });
-    performCacheOptimizationForVolume(volume);
-    const volumeLoadObject = {
-        promise: Promise.resolve(volume),
-    };
-    if (preventCache) {
-        return volumeLoadObject.promise;
-    }
-    cache.putVolumeLoadObject(volumeId, volumeLoadObject);
-    return volumeLoadObject.promise;
+    imageVolume.voxelManager = voxelManager;
+    cache.putVolumeSync(volumeId, imageVolume);
+    return imageVolume;
 }
 export function registerVolumeLoader(scheme, volumeLoader) {
     volumeLoaders[scheme] = volumeLoader;
@@ -275,51 +163,15 @@ export function registerUnknownVolumeLoader(volumeLoader) {
 export function getUnknownVolumeLoaderSchema() {
     return unknownVolumeLoader.name;
 }
-export async function createAndCacheDerivedSegmentationVolume(referencedVolumeId, options = {}) {
+export function createAndCacheDerivedSegmentationVolume(referencedVolumeId, options = {}) {
     return createAndCacheDerivedVolume(referencedVolumeId, {
         ...options,
-        targetBuffer: {
-            type: 'Uint8Array',
-        },
+        targetBufferType: 'Uint8Array',
     });
 }
-export async function createLocalSegmentationVolume(options, volumeId, preventCache = false) {
+export function createLocalSegmentationVolume(options, volumeId, preventCache = false) {
     if (!options.scalarData) {
         options.scalarData = new Uint8Array(options.dimensions[0] * options.dimensions[1] * options.dimensions[2]);
     }
-    return createLocalVolume(options, volumeId, preventCache);
-}
-function generateVolumeScalarData(targetBuffer, scalarLength) {
-    const { useNorm16Texture } = getConfiguration().rendering;
-    const { TypedArrayConstructor, numBytes } = getBufferConfiguration(targetBuffer?.type, scalarLength, {
-        use16BitTexture: useNorm16Texture,
-        isVolumeBuffer: true,
-    });
-    const isCacheable = cache.isCacheable(numBytes);
-    if (!isCacheable) {
-        throw new Error(Events.CACHE_SIZE_EXCEEDED);
-    }
-    let volumeScalarData;
-    if (targetBuffer?.sharedArrayBuffer ?? getShouldUseSharedArrayBuffer()) {
-        switch (targetBuffer.type) {
-            case 'Float32Array':
-                volumeScalarData = createFloat32SharedArray(scalarLength);
-                break;
-            case 'Uint8Array':
-                volumeScalarData = createUint8SharedArray(scalarLength);
-                break;
-            case 'Uint16Array':
-                volumeScalarData = createUint16SharedArray(scalarLength);
-                break;
-            case 'Int16Array':
-                volumeScalarData = createUint16SharedArray(scalarLength);
-                break;
-            default:
-                throw new Error('generateVolumeScalarData: SharedArrayBuffer is not supported for the specified target buffer type');
-        }
-    }
-    else {
-        volumeScalarData = new TypedArrayConstructor(scalarLength);
-    }
-    return { volumeScalarData, numBytes };
+    return createLocalVolume(volumeId, { ...options, preventCache });
 }

package/dist/esm/metaData.d.ts

@@ -1,7 +1,5 @@
-export declare function addProvider(provider: (type: string, ...query: string[]) => any, priority?: number): void;
-export declare function removeProvider(provider: (type: string, query: any) => {
-    any: any;
-}): void;
+export declare function addProvider(provider: (type: string, ...query: string[]) => unknown, priority?: number): void;
+export declare function removeProvider(provider: (type: string, query: unknown) => unknown): void;
 export declare function removeAllProviders(): void;
 declare function getMetaData(type: string, ...queries: any[]): any;
 export { getMetaData as get };

package/dist/esm/requestPool/requestPoolManager.d.ts

@@ -1,18 +1,16 @@
 import RequestType from '../enums/RequestType';
-import { IImage } from '../types';
-type AdditionalDetails = {
+import type { IImage } from '../types';
+interface AdditionalDetails {
     imageId?: string;
     volumeId?: string;
-};
-type RequestDetailsInterface = {
+}
+interface RequestDetailsInterface {
     requestFn: () => Promise<IImage | void>;
     type: RequestType;
     additionalDetails: AdditionalDetails;
-};
+}
 type RequestPool = {
-    [name in RequestType]: {
-        [key: number]: RequestDetailsInterface[];
-    };
+    [name in RequestType]: Record<number, RequestDetailsInterface[]>;
 };
 declare class RequestPoolManager {
     private id;
@@ -38,7 +36,7 @@ declare class RequestPoolManager {
     private getNextRequest;
     protected startGrabbing(): void;
     protected startAgain(): void;
-    protected getSortedPriorityGroups(type: string): Array<number>;
+    protected getSortedPriorityGroups(type: string): number[];
     getRequestPool(): RequestPool;
 }
 export { RequestPoolManager };

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

@@ -1,7 +1,7 @@
-type AABB2 = {
+interface AABB2 {
     minX: number;
     maxX: number;
     minY: number;
     maxY: number;
-};
+}
 export type { AABB2 as default };

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

@@ -1,9 +1,9 @@
-type AABB3 = {
+interface AABB3 {
     minX: number;
     maxX: number;
     minY: number;
     maxY: number;
     minZ: number;
     maxZ: number;
-};
+}
 export type { AABB3 as default };

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

@@ -1,11 +1,11 @@
-import { VolumeActor } from './IActor';
-import Point3 from './Point3';
-type ActorSliceRange = {
+import type { VolumeActor } from './IActor';
+import type Point3 from './Point3';
+interface ActorSliceRange {
     actor: VolumeActor;
     viewPlaneNormal: Point3;
     focalPoint: Point3;
     min: number;
     max: number;
     current: number;
-};
-export default ActorSliceRange;
+}
+export type { ActorSliceRange as default };

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

@@ -1,3 +1,3 @@
 import type Point2 from './Point2';
 type BoundsIJK = [Point2, Point2, Point2];
-export default BoundsIJK;
+export type { BoundsIJK as default };

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

@@ -1,3 +1,3 @@
 import type Point2 from './Point3';
 type BoundsLPS = [Point2, Point2, Point2];
-export default BoundsLPS;
+export type { BoundsLPS };

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

@@ -1,5 +1,5 @@
-import Point4 from './Point4';
-import CPUFallbackLookupTable from './CPUFallbackLookupTable';
+import type Point4 from './Point4';
+import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
 interface CPUFallbackColormap {
     getId: () => string;
     getColorSchemeName: () => string;
@@ -17,4 +17,4 @@ interface CPUFallbackColormap {
     createLookupTable: () => CPUFallbackLookupTable;
     isValidIndex: (index: number) => boolean;
 }
-export default CPUFallbackColormap;
+export type { CPUFallbackColormap as default };

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

@@ -1,10 +1,10 @@
-import Point4 from './Point4';
-type CPUFallbackColormapData = {
+import type Point4 from './Point4';
+interface CPUFallbackColormapData {
     name: string;
     numOfColors?: number;
     colors?: Point4[];
     segmentedData?: unknown;
     numColors?: number;
     gamma?: number;
-};
-export default CPUFallbackColormapData;
+}
+export type { CPUFallbackColormapData as default };

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

@@ -1,5 +1,3 @@
-import CPUFallbackColormapData from './CPUFallbackColormapData';
-type CPUFallbackColormapsData = {
-    [key: string]: CPUFallbackColormapData;
-};
-export default CPUFallbackColormapsData;
+import type CPUFallbackColormapData from './CPUFallbackColormapData';
+type CPUFallbackColormapsData = Record<string, CPUFallbackColormapData>;
+export type { CPUFallbackColormapsData };

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

@@ -1,13 +1,15 @@
-import Point2 from './Point2';
-import Point3 from './Point3';
-import Mat3 from './Mat3';
-import IImage from './IImage';
-import CPUFallbackViewport from './CPUFallbackViewport';
-import CPUFallbackTransform from './CPUFallbackTransform';
-import CPUFallbackColormap from './CPUFallbackColormap';
-import CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
-import { ImagePlaneModule } from './ImagePlaneModule';
-import { ImagePixelModule } from './ImagePixelModule';
+import type Point2 from './Point2';
+import type Point3 from './Point3';
+import type Mat3 from './Mat3';
+import type IImage from './IImage';
+import type CPUFallbackViewport from './CPUFallbackViewport';
+import type CPUFallbackTransform from './CPUFallbackTransform';
+import type CPUFallbackColormap from './CPUFallbackColormap';
+import type CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
+import type { ImagePlaneModule } from './ImagePlaneModule';
+import type { ImagePixelModule } from './ImagePixelModule';
+import type RGB from './RGB';
+import type { IVoxelManager } from './IVoxelManager';
 interface CPUFallbackEnabledElement {
     scale?: number;
     pan?: Point2;
@@ -33,5 +35,6 @@ interface CPUFallbackEnabledElement {
         imagePlaneModule?: ImagePlaneModule;
         imagePixelModule?: ImagePixelModule;
     };
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
 }
-export default CPUFallbackEnabledElement;
+export type { CPUFallbackEnabledElement as default };

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

@@ -1,4 +1,5 @@
-type CPUFallbackLUT = {
+interface CPUFallbackLUT {
     lut: number[];
-};
-export default CPUFallbackLUT;
+    id?: string;
+}
+export type { CPUFallbackLUT as default };

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

@@ -1,4 +1,4 @@
-import Point4 from './Point4';
+import type Point4 from './Point4';
 interface CPUFallbackLookupTable {
     setNumberOfTableValues: (number: number) => void;
     setRamp: (ramp: string) => void;
@@ -12,4 +12,4 @@ interface CPUFallbackLookupTable {
     build: (force: boolean) => void;
     setTableValue(index: number, rgba: Point4): any;
 }
-export default CPUFallbackLookupTable;
+export type { CPUFallbackLookupTable as default };

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

@@ -1,6 +1,6 @@
-import CPUFallbackLookupTable from './CPUFallbackLookupTable';
-import CPUFallbackLUT from './CPUFallbackLUT';
-type CPUFallbackRenderingTools = {
+import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
+import type CPUFallbackLUT from './CPUFallbackLUT';
+interface CPUFallbackRenderingTools {
     renderCanvas?: HTMLCanvasElement;
     lastRenderedIsColor?: boolean;
     lastRenderedImageId?: string;
@@ -19,5 +19,5 @@ type CPUFallbackRenderingTools = {
     colormapId?: string;
     colorLUT?: CPUFallbackLookupTable;
     renderCanvasData?: ImageData;
-};
-export default CPUFallbackRenderingTools;
+}
+export type { CPUFallbackRenderingTools as default };

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

@@ -1,5 +1,5 @@
-import Point2 from './Point2';
-import TransformMatrix2D from './TransformMatrix2D';
+import type Point2 from './Point2';
+import type TransformMatrix2D from './TransformMatrix2D';
 interface CPUFallbackTransform {
     reset: () => void;
     clone: () => CPUFallbackTransform;
@@ -11,4 +11,4 @@ interface CPUFallbackTransform {
     scale: (sx: number, sy: number) => void;
     transformPoint: (point: Point2) => Point2;
 }
-export default CPUFallbackTransform;
+export type { CPUFallbackTransform as default };