@cornerstonejs/core 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/utilities/sortImageIdsAndGetSpacing.js

@@ -0,0 +1,83 @@
+import { vec3 } from 'gl-matrix';
+import * as metaData from '../metaData';
+import { getConfiguration } from '../init';
+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/splitImageIdsBy4DTags.d.ts

@@ -0,0 +1,5 @@
+declare function splitImageIdsBy4DTags(imageIds: string[]): {
+    imageIdGroups: string[][];
+    splittingTag: string | null;
+};
+export default splitImageIdsBy4DTags;

package/dist/esm/utilities/splitImageIdsBy4DTags.js

@@ -0,0 +1,161 @@
+import * as metaData from '../metaData';
+const groupBy = (array, key) => {
+    return array.reduce((rv, x) => {
+        (rv[x[key]] = rv[x[key]] || []).push(x);
+        return rv;
+    }, {});
+};
+function getIPPGroups(imageIds) {
+    const ippMetadata = imageIds.map((imageId) => {
+        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId) || {};
+        return { imageId, imagePositionPatient };
+    });
+    if (!ippMetadata.every((item) => item.imagePositionPatient)) {
+        return null;
+    }
+    const positionGroups = groupBy(ippMetadata, 'imagePositionPatient');
+    const positions = Object.keys(positionGroups);
+    const frame_count = positionGroups[positions[0]].length;
+    if (frame_count === 1) {
+        return null;
+    }
+    const frame_count_equal = positions.every((k) => positionGroups[k].length === frame_count);
+    if (!frame_count_equal) {
+        return null;
+    }
+    return positionGroups;
+}
+function test4DTag(IPPGroups, value_getter) {
+    const frame_groups = {};
+    let first_frame_value_set = [];
+    const positions = Object.keys(IPPGroups);
+    for (let i = 0; i < positions.length; i++) {
+        const frame_value_set = new Set();
+        const frames = IPPGroups[positions[i]];
+        for (let j = 0; j < frames.length; j++) {
+            const frame_value = value_getter(frames[j].imageId) || 0;
+            frame_groups[frame_value] = frame_groups[frame_value] || [];
+            frame_groups[frame_value].push({ imageId: frames[j].imageId });
+            frame_value_set.add(frame_value);
+            if (frame_value_set.size - 1 < j) {
+                return undefined;
+            }
+        }
+        if (i == 0) {
+            first_frame_value_set = Array.from(frame_value_set);
+        }
+        else if (!setEquals(first_frame_value_set, frame_value_set)) {
+            return undefined;
+        }
+    }
+    return frame_groups;
+}
+function getTagValue(imageId, tag) {
+    const value = metaData.get(tag, imageId);
+    try {
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getPhilipsPrivateBValue(imageId) {
+    const value = metaData.get('20011003', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            const value_bytes = atob(InlineBinary);
+            const ary_buf = new ArrayBuffer(value_bytes.length);
+            const dv = new DataView(ary_buf);
+            for (let i = 0; i < value_bytes.length; i++) {
+                dv.setUint8(i, value_bytes.charCodeAt(i));
+            }
+            return new Float32Array(ary_buf)[0];
+        }
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getSiemensPrivateBValue(imageId) {
+    let value = metaData.get('0019100c', imageId) || metaData.get('0019100C', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            value = atob(InlineBinary);
+        }
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getGEPrivateBValue(imageId) {
+    let value = metaData.get('00431039', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            value = atob(InlineBinary).split('//');
+        }
+        return parseFloat(value[0]) % 100000;
+    }
+    catch {
+        return undefined;
+    }
+}
+function setEquals(set_a, set_b) {
+    if (set_a.length != set_b.size) {
+        return false;
+    }
+    for (let i = 0; i < set_a.length; i++) {
+        if (!set_b.has(set_a[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function getPetFrameReferenceTime(imageId) {
+    const moduleInfo = metaData.get('petImageModule', imageId);
+    return moduleInfo ? moduleInfo['frameReferenceTime'] : 0;
+}
+function splitImageIdsBy4DTags(imageIds) {
+    const positionGroups = getIPPGroups(imageIds);
+    if (!positionGroups) {
+        return { imageIdGroups: [imageIds], splittingTag: null };
+    }
+    const tags = [
+        'TemporalPositionIdentifier',
+        'DiffusionBValue',
+        'TriggerTime',
+        'EchoTime',
+        'EchoNumber',
+        'PhilipsPrivateBValue',
+        'SiemensPrivateBValue',
+        'GEPrivateBValue',
+        'PetFrameReferenceTime',
+    ];
+    const fncList2 = [
+        (imageId) => getTagValue(imageId, tags[0]),
+        (imageId) => getTagValue(imageId, tags[1]),
+        (imageId) => getTagValue(imageId, tags[2]),
+        (imageId) => getTagValue(imageId, tags[3]),
+        (imageId) => getTagValue(imageId, tags[4]),
+        getPhilipsPrivateBValue,
+        getSiemensPrivateBValue,
+        getGEPrivateBValue,
+        getPetFrameReferenceTime,
+    ];
+    for (let i = 0; i < fncList2.length; i++) {
+        const frame_groups = test4DTag(positionGroups, fncList2[i]);
+        if (frame_groups) {
+            const sortedKeys = Object.keys(frame_groups)
+                .map(Number.parseFloat)
+                .sort((a, b) => a - b);
+            const imageIdGroups = sortedKeys.map((key) => frame_groups[key].map((item) => item.imageId));
+            return { imageIdGroups, splittingTag: tags[i] };
+        }
+    }
+    return { imageIdGroups: [imageIds], splittingTag: null };
+}
+export default splitImageIdsBy4DTags;

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

@@ -1,7 +1,7 @@
 import { vec3 } from 'gl-matrix';
-import { metaData } from '..';
+import { get } from '../metaData';
 function worldToImageCoords(imageId, worldCoords) {
-    const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+    const imagePlaneModule = get('imagePlaneModule', imageId);
     if (!imagePlaneModule) {
         throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
     }
@@ -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,28 @@
+export default CentralizedWorkerManager;
+declare class CentralizedWorkerManager {
+    workerRegistry: {};
+    workerPoolManager: RequestPoolManager;
+    registerWorker(workerName: any, workerFn: any, options?: {
+        maxWorkerInstances?: number;
+        overwrite?: boolean;
+        autoTerminateOnIdle?: {
+            enabled?: boolean;
+            idleTimeThreshold?: number;
+        };
+    }): void;
+    getNextWorkerAPI(workerName: any): {
+        api: any;
+        index: number;
+    };
+    executeTask(workerName: string, methodName: string, args?: object, { requestType, priority, options, callbacks, }?: {
+        requestType?: RequestType;
+        priority?: number;
+        options?: object;
+        callbacks?: Function[];
+    }): 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;