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

package/dist/esm/utilities/renderToCanvasGPU.d.ts

@@ -1,2 +1,5 @@
-import { IImage } from '../types';
-export default function renderToCanvasGPU(canvas: HTMLCanvasElement, image: IImage, modality?: any, renderingEngineId?: string): Promise<string>;
+import type { IImage, IVolume, ViewportInputOptions, ViewReference } from '../types';
+import type { CanvasLoadPosition } from './loadImageToCanvas';
+export default function renderToCanvasGPU(canvas: HTMLCanvasElement, imageOrVolume: IImage | IVolume, modality?: any, renderingEngineId?: string, viewportOptions?: ViewportInputOptions & {
+    viewReference?: ViewReference;
+}): Promise<CanvasLoadPosition>;

package/dist/esm/utilities/renderToCanvasGPU.js

@@ -1,54 +1,76 @@
-import getOrCreateCanvas from '../RenderingEngine/helpers/getOrCreateCanvas';
+import getOrCreateCanvas, { EPSILON, } from '../RenderingEngine/helpers/getOrCreateCanvas';
 import { ViewportType, Events } from '../enums';
 import { getRenderingEngine } from '../RenderingEngine/getRenderingEngine';
 import RenderingEngine from '../RenderingEngine';
 import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
-export default function renderToCanvasGPU(canvas, image, modality = undefined, renderingEngineId = '_thumbnails') {
+export default function renderToCanvasGPU(canvas, imageOrVolume, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = {
+    displayArea: { imageArea: [1, 1] },
+}) {
     if (!canvas || !(canvas instanceof HTMLCanvasElement)) {
         throw new Error('canvas element is required');
     }
-    const imageIdToPrint = image.imageId;
+    const isVolume = !imageOrVolume.imageId;
+    const image = !isVolume && imageOrVolume;
+    const volume = isVolume && imageOrVolume;
+    const imageIdToPrint = image.imageId || volume.volumeId;
     const viewportId = `renderGPUViewport-${imageIdToPrint}`;
-    const imageId = image.imageId;
     const element = document.createElement('div');
-    element.style.width = `${canvas.width}px`;
-    element.style.height = `${canvas.height}px`;
-    element.style.visibility = 'hidden';
-    element.style.position = 'absolute';
     const devicePixelRatio = window.devicePixelRatio || 1;
+    if (!viewportOptions.displayArea) {
+        viewportOptions.displayArea = { imageArea: [1, 1] };
+    }
     const originalWidth = canvas.width;
     const originalHeight = canvas.height;
-    canvas.width = originalWidth * devicePixelRatio;
-    canvas.height = originalHeight * devicePixelRatio;
-    canvas.style.width = `${originalWidth}px`;
-    canvas.style.height = `${originalHeight}px`;
+    element.style.width = `${originalWidth / devicePixelRatio + EPSILON}px`;
+    element.style.height = `${originalHeight / devicePixelRatio + EPSILON}px`;
+    element.style.visibility = 'hidden';
+    element.style.position = 'absolute';
     document.body.appendChild(element);
     const uniqueId = viewportId.split(':').join('-');
     element.setAttribute('viewport-id-for-remove', uniqueId);
+    const temporaryCanvas = getOrCreateCanvas(element);
     const renderingEngine = getRenderingEngine(renderingEngineId) ||
         new RenderingEngine(renderingEngineId);
     let viewport = renderingEngine.getViewport(viewportId);
     if (!viewport) {
-        const stackViewportInput = {
+        const viewportInput = {
             viewportId,
-            type: ViewportType.STACK,
+            type: isVolume ? ViewportType.ORTHOGRAPHIC : ViewportType.STACK,
             element,
             defaultOptions: {
+                ...viewportOptions,
                 suppressEvents: true,
             },
         };
-        renderingEngine.enableElement(stackViewportInput);
+        renderingEngine.enableElement(viewportInput);
         viewport = renderingEngine.getViewport(viewportId);
     }
     return new Promise((resolve) => {
         let elementRendered = false;
+        let { viewReference } = viewportOptions;
         const onImageRendered = (eventDetail) => {
             if (elementRendered) {
                 return;
             }
-            const temporaryCanvas = getOrCreateCanvas(element);
+            if (viewReference) {
+                const useViewRef = viewReference;
+                viewReference = null;
+                viewport.setViewReference(useViewRef);
+                viewport.render();
+                return;
+            }
             const context = canvas.getContext('2d');
             context.drawImage(temporaryCanvas, 0, 0, temporaryCanvas.width, temporaryCanvas.height, 0, 0, canvas.width, canvas.height);
+            const origin = viewport.canvasToWorld([0, 0]);
+            const topRight = viewport.canvasToWorld([
+                temporaryCanvas.width / devicePixelRatio,
+                0,
+            ]);
+            const bottomLeft = viewport.canvasToWorld([
+                0,
+                temporaryCanvas.height / devicePixelRatio,
+            ]);
+            const thicknessMm = 1;
             elementRendered = true;
             element.removeEventListener(Events.IMAGE_RENDERED, onImageRendered);
             setTimeout(() => {
@@ -58,10 +80,20 @@ export default function renderToCanvasGPU(canvas, image, modality = undefined, r
                     element.remove();
                 });
             }, 0);
-            resolve(imageId);
+            resolve({
+                origin,
+                bottomLeft,
+                topRight,
+                thicknessMm,
+            });
         };
         element.addEventListener(Events.IMAGE_RENDERED, onImageRendered);
-        viewport.renderImageObject(image);
+        if (isVolume) {
+            viewport.setVolumes([volume], false, true);
+        }
+        else {
+            viewport.renderImageObject(imageOrVolume);
+        }
         viewport.resetCamera();
         if (modality === 'PT' && !isPTPrescaledWithSUV(image)) {
             viewport.setProperties({
@@ -74,4 +106,3 @@ export default function renderToCanvasGPU(canvas, image, modality = undefined, r
         viewport.render();
     });
 }
-//# sourceMappingURL=renderToCanvasGPU.js.map

package/dist/esm/utilities/roundNumber.d.ts

@@ -0,0 +1,4 @@
+declare function roundNumber(value: string | number | (string | number)[], precision?: number): string;
+declare function roundToPrecision(value: any): number;
+export { roundToPrecision };
+export default roundNumber;

package/dist/esm/utilities/roundNumber.js

@@ -0,0 +1,33 @@
+import { EPSILON } from '../constants';
+function roundNumber(value, precision = 2) {
+    if (Array.isArray(value)) {
+        return value.map((v) => roundNumber(v, precision)).join(', ');
+    }
+    if (value === undefined || value === null || value === '') {
+        return 'NaN';
+    }
+    value = Number(value);
+    const absValue = Math.abs(value);
+    if (absValue < 0.0001) {
+        return `${value}`;
+    }
+    const fixedPrecision = absValue >= 100
+        ? precision - 2
+        : absValue >= 10
+            ? precision - 1
+            : absValue >= 1
+                ? precision
+                : absValue >= 0.1
+                    ? precision + 1
+                    : absValue >= 0.01
+                        ? precision + 2
+                        : absValue >= 0.001
+                            ? precision + 3
+                            : precision + 4;
+    return value.toFixed(fixedPrecision);
+}
+function roundToPrecision(value) {
+    return Math.round(value / EPSILON) * EPSILON;
+}
+export { roundToPrecision };
+export default roundNumber;

package/dist/esm/utilities/scaleRgbTransferFunction.d.ts

@@ -1 +1,2 @@
-export default function scaleRGBTransferFunction(rgbTransferFunction: any, scalingFactor: number): void;
+import type ColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+export default function scaleRGBTransferFunction(rgbTransferFunction: ColorTransferFunction, scalingFactor: number): void;

package/dist/esm/utilities/scaleRgbTransferFunction.js

@@ -9,4 +9,3 @@ export default function scaleRGBTransferFunction(rgbTransferFunction, scalingFac
         rgbTransferFunction.setNodeValue(index, nodeValue1);
     }
 }
-//# sourceMappingURL=scaleRgbTransferFunction.js.map

package/dist/esm/utilities/snapFocalPointToSlice.d.ts

@@ -1,4 +1,4 @@
-import { ActorSliceRange, Point3 } from '../types';
+import type { ActorSliceRange, Point3 } from '../types';
 export default function snapFocalPointToSlice(focalPoint: Point3, position: Point3, sliceRange: ActorSliceRange, viewPlaneNormal: Point3, spacingInNormalDirection: number, deltaFrames: number): {
     newFocalPoint: Point3;
     newPosition: Point3;

package/dist/esm/utilities/snapFocalPointToSlice.js

@@ -35,4 +35,3 @@ export default function snapFocalPointToSlice(focalPoint, position, sliceRange,
     ];
     return { newFocalPoint, newPosition };
 }
-//# sourceMappingURL=snapFocalPointToSlice.js.map

package/dist/esm/utilities/sortImageIdsAndGetSpacing.d.ts

@@ -0,0 +1,9 @@
+import { vec3 } from 'gl-matrix';
+import type { Point3 } from '../types';
+interface SortedImageIdsItem {
+    zSpacing: number;
+    origin: Point3;
+    sortedImageIds: string[];
+}
+export default function sortImageIdsAndGetSpacing(imageIds: string[], scanAxisNormal?: vec3): SortedImageIdsItem;
+export {};

package/dist/esm/utilities/sortImageIdsAndGetSpacing.js

@@ -0,0 +1,82 @@
+import { vec3 } from 'gl-matrix';
+import { metaData, getConfiguration } from '../';
+export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
+    const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = metaData.get('imagePlaneModule', imageIds[0]);
+    if (!scanAxisNormal) {
+        const rowCosineVec = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+        const colCosineVec = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+        scanAxisNormal = vec3.create();
+        vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+    }
+    const refIppVec = vec3.create();
+    const usingWadoUri = imageIds[0].split(':')[0] === 'wadouri';
+    vec3.set(refIppVec, referenceImagePositionPatient[0], referenceImagePositionPatient[1], referenceImagePositionPatient[2]);
+    let sortedImageIds;
+    let zSpacing;
+    function getDistance(imageId) {
+        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
+        const positionVector = vec3.create();
+        vec3.sub(positionVector, referenceImagePositionPatient, imagePositionPatient);
+        return vec3.dot(positionVector, scanAxisNormal);
+    }
+    if (!usingWadoUri) {
+        const distanceImagePairs = imageIds.map((imageId) => {
+            const distance = getDistance(imageId);
+            return {
+                distance,
+                imageId,
+            };
+        });
+        distanceImagePairs.sort((a, b) => b.distance - a.distance);
+        sortedImageIds = distanceImagePairs.map((a) => a.imageId);
+        const numImages = distanceImagePairs.length;
+        zSpacing =
+            Math.abs(distanceImagePairs[numImages - 1].distance -
+                distanceImagePairs[0].distance) /
+                (numImages - 1);
+    }
+    else {
+        const prefetchedImageIds = [
+            imageIds[0],
+            imageIds[Math.floor(imageIds.length / 2)],
+        ];
+        sortedImageIds = imageIds;
+        const firstImageDistance = getDistance(prefetchedImageIds[0]);
+        const middleImageDistance = getDistance(prefetchedImageIds[1]);
+        if (firstImageDistance - middleImageDistance < 0) {
+            sortedImageIds.reverse();
+        }
+        const metadataForMiddleImage = metaData.get('imagePlaneModule', prefetchedImageIds[1]);
+        if (!metadataForMiddleImage) {
+            throw new Error('Incomplete metadata required for volume construction.');
+        }
+        const positionVector = vec3.create();
+        vec3.sub(positionVector, referenceImagePositionPatient, metadataForMiddleImage.imagePositionPatient);
+        const distanceBetweenFirstAndMiddleImages = vec3.dot(positionVector, scanAxisNormal);
+        zSpacing =
+            Math.abs(distanceBetweenFirstAndMiddleImages) /
+                Math.floor(imageIds.length / 2);
+    }
+    const { imagePositionPatient: origin, sliceThickness, spacingBetweenSlices, } = metaData.get('imagePlaneModule', sortedImageIds[0]);
+    const { strictZSpacingForVolumeViewport } = getConfiguration().rendering;
+    if (zSpacing === 0 && !strictZSpacingForVolumeViewport) {
+        if (sliceThickness && spacingBetweenSlices) {
+            console.log('Could not calculate zSpacing. Using spacingBetweenSlices');
+            zSpacing = spacingBetweenSlices;
+        }
+        else if (sliceThickness) {
+            console.log('Could not calculate zSpacing and no spacingBetweenSlices. Using sliceThickness');
+            zSpacing = sliceThickness;
+        }
+        else {
+            console.log('Could not calculate zSpacing. The VolumeViewport visualization is compromised. Setting zSpacing to 1 to render');
+            zSpacing = 1;
+        }
+    }
+    const result = {
+        zSpacing,
+        origin,
+        sortedImageIds,
+    };
+    return result;
+}

package/dist/esm/utilities/spatialRegistrationMetadataProvider.d.ts

@@ -1,6 +1,6 @@
 import { mat4 } from 'gl-matrix';
 declare const spatialRegistrationMetadataProvider: {
     add: (query: string[], payload: mat4) => void;
-    get: (type: string, query: string[]) => mat4;
+    get: (type: string, viewportId1: string, viewportId2: string) => mat4;
 };
 export default spatialRegistrationMetadataProvider;

package/dist/esm/utilities/spatialRegistrationMetadataProvider.js

@@ -10,11 +10,10 @@ const spatialRegistrationMetadataProvider = {
         }
         state[entryId] = payload;
     },
-    get: (type, query) => {
+    get: (type, viewportId1, viewportId2) => {
         if (type !== 'spatialRegistrationModule') {
             return;
         }
-        const [viewportId1, viewportId2] = query;
         const entryId = `${viewportId1}_${viewportId2}`;
         if (state[entryId]) {
             return state[entryId];
@@ -27,4 +26,3 @@ const spatialRegistrationMetadataProvider = {
 };
 addProvider(spatialRegistrationMetadataProvider.get.bind(spatialRegistrationMetadataProvider));
 export default spatialRegistrationMetadataProvider;
-//# sourceMappingURL=spatialRegistrationMetadataProvider.js.map

package/dist/esm/utilities/transferFunctionUtils.d.ts

@@ -0,0 +1,3 @@
+declare function getTransferFunctionNodes(transferFunction: any): any[];
+declare function setTransferFunctionNodes(transferFunction: any, nodes: any): void;
+export { getTransferFunctionNodes, setTransferFunctionNodes };

package/dist/esm/utilities/transferFunctionUtils.js

@@ -0,0 +1,20 @@
+function getTransferFunctionNodes(transferFunction) {
+    const size = transferFunction.getSize();
+    const values = [];
+    for (let index = 0; index < size; index++) {
+        const nodeValue1 = [];
+        transferFunction.getNodeValue(index, nodeValue1);
+        values.push(nodeValue1);
+    }
+    return values;
+}
+function setTransferFunctionNodes(transferFunction, nodes) {
+    if (!nodes?.length) {
+        return;
+    }
+    transferFunction.removeAllPoints();
+    nodes.forEach((node) => {
+        transferFunction.addRGBPoint(...node);
+    });
+}
+export { getTransferFunctionNodes, setTransferFunctionNodes };

package/dist/esm/utilities/transformCanvasToIJK.d.ts

@@ -0,0 +1,2 @@
+import type { IViewport, Point2 } from '../types';
+export declare function transformCanvasToIJK(viewport: IViewport, canvasPoint: Point2): any;

package/dist/esm/utilities/transformCanvasToIJK.js

@@ -0,0 +1,6 @@
+import transformWorldToIndex from './transformWorldToIndex';
+export function transformCanvasToIJK(viewport, canvasPoint) {
+    const { imageData: vtkImageData } = viewport.getImageData();
+    const worldPoint = viewport.canvasToWorld(canvasPoint);
+    return transformWorldToIndex(vtkImageData, worldPoint);
+}

package/dist/esm/utilities/transformIJKToCanvas.d.ts

@@ -0,0 +1,2 @@
+import type { IStackViewport, IVolumeViewport, Point3 } from '../types';
+export declare function transformIJKToCanvas(viewport: IVolumeViewport | IStackViewport, ijkPoint: Point3): import("../types").Point2;

package/dist/esm/utilities/transformIJKToCanvas.js

@@ -0,0 +1,6 @@
+import transformIndexToWorld from './transformIndexToWorld';
+export function transformIJKToCanvas(viewport, ijkPoint) {
+    const { imageData: vtkImageData } = viewport.getImageData();
+    const worldPoint = transformIndexToWorld(vtkImageData, ijkPoint);
+    return viewport.worldToCanvas(worldPoint);
+}

package/dist/esm/utilities/transformIndexToWorld.d.ts

@@ -0,0 +1,2 @@
+import type Point3 from '../types/Point3';
+export default function transformIndexToWorld(imageData: any, voxelPos: Point3): any;

package/dist/esm/utilities/transformIndexToWorld.js

@@ -0,0 +1,3 @@
+export default function transformIndexToWorld(imageData, voxelPos) {
+    return imageData.indexToWorld(voxelPos);
+}

package/dist/esm/utilities/transformWorldToIndex.js

@@ -3,4 +3,3 @@ export default function transformWorldToIndex(imageData, worldPos) {
     const index = continuousIndex.map(Math.round);
     return index;
 }
-//# sourceMappingURL=transformWorldToIndex.js.map

package/dist/esm/utilities/triggerEvent.js

@@ -7,6 +7,5 @@ export default function triggerEvent(el = eventTarget, type, detail = null) {
         detail,
         cancelable: true,
     });
-    return el.dispatchEvent(event);
+    return el?.dispatchEvent(event);
 }
-//# sourceMappingURL=triggerEvent.js.map

package/dist/esm/utilities/updateVTKImageDataWithCornerstoneImage.d.ts

@@ -0,0 +1,4 @@
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { IImage } from '../types';
+declare function updateVTKImageDataWithCornerstoneImage(sourceImageData: vtkImageData, image: IImage): void;
+export { updateVTKImageDataWithCornerstoneImage };

package/dist/esm/utilities/updateVTKImageDataWithCornerstoneImage.js

@@ -0,0 +1,26 @@
+function updateVTKImageDataWithCornerstoneImage(sourceImageData, image) {
+    const pixelData = image.voxelManager.getScalarData();
+    if (!sourceImageData.getPointData) {
+        return;
+    }
+    const scalarData = sourceImageData
+        .getPointData()
+        .getScalars()
+        .getData();
+    if (image.color && image.rgba) {
+        const newPixelData = new Uint8Array(image.columns * image.rows * 3);
+        for (let i = 0; i < image.columns * image.rows; i++) {
+            newPixelData[i * 3] = pixelData[i * 4];
+            newPixelData[i * 3 + 1] = pixelData[i * 4 + 1];
+            newPixelData[i * 3 + 2] = pixelData[i * 4 + 2];
+        }
+        image.rgba = false;
+        image.getPixelData = () => newPixelData;
+        scalarData.set(newPixelData);
+    }
+    else {
+        scalarData.set(pixelData);
+    }
+    sourceImageData.modified();
+}
+export { updateVTKImageDataWithCornerstoneImage };

package/dist/esm/utilities/uuidv4.js

@@ -1,4 +1,5 @@
 export default function uuidv4() {
-    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
+    return (crypto.randomUUID() ||
+        ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) => (c ^
+            (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16)));
 }
-//# sourceMappingURL=uuidv4.js.map

package/dist/esm/utilities/windowLevel.js

@@ -9,4 +9,3 @@ function toLowHighRange(windowWidth, windowCenter) {
     return { lower, upper };
 }
 export { toWindowLevel, toLowHighRange };
-//# sourceMappingURL=windowLevel.js.map

package/dist/esm/utilities/worldToImageCoords.d.ts

@@ -1,3 +1,3 @@
-import { Point2, Point3 } from '../types';
+import type { Point2, Point3 } from '../types';
 declare function worldToImageCoords(imageId: string, worldCoords: Point3): Point2 | undefined;
 export default worldToImageCoords;

package/dist/esm/utilities/worldToImageCoords.js

@@ -23,4 +23,3 @@ function worldToImageCoords(imageId, worldCoords) {
     return imageCoords;
 }
 export default worldToImageCoords;
-//# sourceMappingURL=worldToImageCoords.js.map

package/dist/esm/webWorkerManager/webWorkerManager.d.ts

@@ -0,0 +1,21 @@
+export default CentralizedWorkerManager;
+declare class CentralizedWorkerManager {
+    workerRegistry: {};
+    workerPoolManager: RequestPoolManager;
+    registerWorker(workerName: any, workerFn: any, options?: {}): void;
+    getNextWorkerAPI(workerName: any): {
+        api: any;
+        index: number;
+    };
+    executeTask(workerName: any, methodName: any, args?: {}, { requestType, priority, options, callbacks, }?: {
+        requestType?: RequestType;
+        priority?: number;
+        options?: {};
+        callbacks?: any[];
+    }): Promise<any>;
+    terminateIdleWorkers(workerName: any, idleTimeThreshold: any): void;
+    terminate(workerName: any): void;
+    terminateWorkerInstance(workerName: any, index: any): void;
+}
+import { RequestPoolManager } from '../requestPool/requestPoolManager';
+import { RequestType } from '../enums/';

package/dist/esm/webWorkerManager/webWorkerManager.js

@@ -0,0 +1,146 @@
+import * as Comlink from 'comlink';
+import { RequestType } from '../enums/';
+import { RequestPoolManager } from '../requestPool/requestPoolManager';
+class CentralizedWorkerManager {
+    constructor() {
+        this.workerRegistry = {};
+        this.workerPoolManager = new RequestPoolManager('webworker');
+    }
+    registerWorker(workerName, workerFn, options = {}) {
+        const { maxWorkerInstances = 1, overwrite = false, autoTerminateOnIdle = {
+            enabled: false,
+            idleTimeThreshold: 3000,
+        }, } = options;
+        if (this.workerRegistry[workerName] && !overwrite) {
+            console.warn(`Worker type '${workerName}' is already registered...`);
+            return;
+        }
+        if (overwrite && this.workerRegistry[workerName]?.idleCheckIntervalId) {
+            clearInterval(this.workerRegistry[workerName].idleCheckIntervalId);
+        }
+        const workerProperties = {
+            workerFn: null,
+            instances: [],
+            loadCounters: [],
+            lastActiveTime: [],
+            nativeWorkers: [],
+            autoTerminateOnIdle: autoTerminateOnIdle.enabled,
+            idleCheckIntervalId: null,
+            idleTimeThreshold: autoTerminateOnIdle.idleTimeThreshold,
+        };
+        workerProperties.loadCounters = Array(maxWorkerInstances).fill(0);
+        workerProperties.lastActiveTime = Array(maxWorkerInstances).fill(null);
+        for (let i = 0; i < maxWorkerInstances; i++) {
+            const worker = workerFn();
+            workerProperties.instances.push(Comlink.wrap(worker));
+            workerProperties.nativeWorkers.push(worker);
+            workerProperties.workerFn = workerFn;
+        }
+        this.workerRegistry[workerName] = workerProperties;
+    }
+    getNextWorkerAPI(workerName) {
+        const workerProperties = this.workerRegistry[workerName];
+        if (!workerProperties) {
+            console.error(`Worker type '${workerName}' is not registered.`);
+            return null;
+        }
+        const workerInstances = workerProperties.instances.filter((instance) => instance !== null);
+        let minLoadIndex = 0;
+        let minLoadValue = workerProperties.loadCounters[0] || 0;
+        for (let i = 1; i < workerInstances.length; i++) {
+            const currentLoadValue = workerProperties.loadCounters[i] || 0;
+            if (currentLoadValue < minLoadValue) {
+                minLoadIndex = i;
+                minLoadValue = currentLoadValue;
+            }
+        }
+        if (workerProperties.instances[minLoadIndex] === null) {
+            const worker = workerProperties.workerFn();
+            workerProperties.instances[minLoadIndex] = Comlink.wrap(worker);
+            workerProperties.nativeWorkers[minLoadIndex] = worker;
+        }
+        workerProperties.loadCounters[minLoadIndex] += 1;
+        return {
+            api: workerProperties.instances[minLoadIndex],
+            index: minLoadIndex,
+        };
+    }
+    executeTask(workerName, methodName, args = {}, { requestType = RequestType.Compute, priority = 0, options = {}, callbacks = [], } = {}) {
+        return new Promise((resolve, reject) => {
+            const requestFn = async () => {
+                const { api, index } = this.getNextWorkerAPI(workerName);
+                if (!api) {
+                    const error = new Error(`No available worker instance for '${workerName}'`);
+                    console.error(error);
+                    reject(error);
+                    return;
+                }
+                try {
+                    let finalCallbacks = [];
+                    if (callbacks.length) {
+                        finalCallbacks = callbacks.map((cb) => {
+                            return Comlink.proxy(cb);
+                        });
+                    }
+                    const workerProperties = this.workerRegistry[workerName];
+                    workerProperties.processing = true;
+                    const results = await api[methodName](args, ...finalCallbacks);
+                    workerProperties.processing = false;
+                    workerProperties.lastActiveTime[index] = Date.now();
+                    if (workerProperties.autoTerminateOnIdle &&
+                        !workerProperties.idleCheckIntervalId &&
+                        workerProperties.idleTimeThreshold) {
+                        workerProperties.idleCheckIntervalId = setInterval(() => {
+                            this.terminateIdleWorkers(workerName, workerProperties.idleTimeThreshold);
+                        }, workerProperties.idleTimeThreshold);
+                    }
+                    resolve(results);
+                }
+                catch (err) {
+                    console.error(`Error executing method '${methodName}' on worker '${workerName}':`, err);
+                    reject(err);
+                }
+                finally {
+                    this.workerRegistry[workerName].loadCounters[index]--;
+                }
+            };
+            this.workerPoolManager.addRequest(requestFn, requestType, options, priority);
+        });
+    }
+    terminateIdleWorkers(workerName, idleTimeThreshold) {
+        const workerProperties = this.workerRegistry[workerName];
+        if (workerProperties.processing) {
+            return;
+        }
+        const now = Date.now();
+        workerProperties.instances.forEach((_, index) => {
+            const lastActiveTime = workerProperties.lastActiveTime[index];
+            const isWorkerActive = lastActiveTime !== null && workerProperties.loadCounters[index] > 0;
+            const idleTime = now - lastActiveTime;
+            if (!isWorkerActive && idleTime > idleTimeThreshold) {
+                this.terminateWorkerInstance(workerName, index);
+            }
+        });
+    }
+    terminate(workerName) {
+        const workerProperties = this.workerRegistry[workerName];
+        if (!workerProperties) {
+            console.error(`Worker type '${workerName}' is not registered.`);
+            return;
+        }
+        workerProperties.instances.forEach((_, index) => {
+            this.terminateWorkerInstance(workerName, index);
+        });
+    }
+    terminateWorkerInstance(workerName, index) {
+        const workerProperties = this.workerRegistry[workerName];
+        const workerInstance = workerProperties.instances[index];
+        if (workerInstance !== null) {
+            workerInstance[Comlink.releaseProxy]();
+            workerProperties.nativeWorkers[index].terminate();
+            workerProperties.instances[index] = null;
+            workerProperties.lastActiveTime[index] = null;
+        }
+    }
+}
+export default CentralizedWorkerManager;