cod-dicomweb-server 1.2.4 → 1.3.1

package/dist/esm/classes/CodDicomWebServer.d.ts

@@ -9,6 +9,7 @@ declare class CodDicomWebServer {
     constructor(args?: {
         maxWorkerFetchSize?: number;
         domain?: string;
+        disableWorker?: boolean;
     });
     setOptions: (newOptions: Partial<CodDicomWebServerOptions>) => void;
     getOptions: () => CodDicomWebServerOptions;

package/dist/esm/classes/CodDicomWebServer.js

@@ -2,9 +2,11 @@ import { parseDicom } from 'dicom-parser';
 import FileManager from '../fileManager';
 import MetadataManager from '../metadataManager';
 import { getFrameDetailsFromMetadata, parseWadorsURL } from './utils';
-import { getWebWorkerManager } from '../webWorker/workerManager';
-import { registerWorkers } from '../webWorker/registerWorkers';
+import { register } from '../dataRetrieval/register';
 import constants, { Enums } from '../constants';
+import { getDataRetrievalManager } from '../dataRetrieval/dataRetrievalManager';
+import { CustomError } from './customClasses';
+import { CustomErrorEvent } from './customClasses';
 class CodDicomWebServer {
     filePromises = {};
     options = {
@@ -15,14 +17,18 @@ class CodDicomWebServer {
     metadataManager;
     seriesUidFileUrls = {};
     constructor(args = {}) {
-        const { maxWorkerFetchSize, domain } = args;
+        const { maxWorkerFetchSize, domain, disableWorker } = args;
         this.options.maxWorkerFetchSize = maxWorkerFetchSize || this.options.maxWorkerFetchSize;
         this.options.domain = domain || this.options.domain;
-        const fileStreamingWorkerName = constants.worker.FILE_STREAMING_WORKER_NAME;
-        const filePartialWorkerName = constants.worker.FILE_PARTIAL_WORKER_NAME;
-        this.fileManager = new FileManager({ fileStreamingWorkerName });
+        const fileStreamingScriptName = constants.dataRetrieval.FILE_STREAMING_WORKER_NAME;
+        const filePartialScriptName = constants.dataRetrieval.FILE_PARTIAL_WORKER_NAME;
+        this.fileManager = new FileManager({ fileStreamingScriptName });
         this.metadataManager = new MetadataManager();
-        registerWorkers({ fileStreamingWorkerName, filePartialWorkerName }, this.options.maxWorkerFetchSize);
+        if (disableWorker) {
+            const dataRetrievalManager = getDataRetrievalManager();
+            dataRetrievalManager.setDataRetrieverMode(Enums.DataRetrieveMode.REQUEST);
+        }
+        register({ fileStreamingScriptName, filePartialScriptName }, this.options.maxWorkerFetchSize);
     }
     setOptions = (newOptions) => {
         Object.keys(newOptions).forEach((key) => {
@@ -45,7 +51,7 @@ class CodDicomWebServer {
     async fetchCod(wadorsUrl, headers = {}, { useSharedArrayBuffer = false, fetchType = constants.Enums.FetchType.API_OPTIMIZED } = {}) {
         try {
             if (!wadorsUrl) {
-                throw new Error('Url not provided');
+                throw new CustomError('Url not provided');
             }
             const parsedDetails = parseWadorsURL(wadorsUrl, this.options.domain);
             if (parsedDetails) {
@@ -58,7 +64,7 @@ class CodDicomWebServer {
                     seriesInstanceUID
                 }, headers);
                 if (!metadataJson) {
-                    throw new Error(`Metadata not found for ${wadorsUrl}`);
+                    throw new CustomError(`Metadata not found for ${wadorsUrl}`);
                 }
                 const { url: fileUrl, startByte, endByte, thumbnailUrl, isMultiframe } = getFrameDetailsFromMetadata(metadataJson, sopInstanceUID, frameNumber - 1, {
                     domain: this.options.domain,
@@ -68,7 +74,7 @@ class CodDicomWebServer {
                 switch (type) {
                     case Enums.RequestType.THUMBNAIL:
                         if (!thumbnailUrl) {
-                            throw new Error(`Thumbnail not found for ${wadorsUrl}`);
+                            throw new CustomError(`Thumbnail not found for ${wadorsUrl}`);
                         }
                         this.addFileUrl(seriesInstanceUID, thumbnailUrl);
                         return this.fetchFile(thumbnailUrl, headers, {
@@ -76,7 +82,7 @@ class CodDicomWebServer {
                         });
                     case Enums.RequestType.FRAME: {
                         if (!fileUrl) {
-                            throw new Error('Url not found for frame');
+                            throw new CustomError('Url not found for frame');
                         }
                         let urlWithBytes = fileUrl;
                         if (fetchType === Enums.FetchType.BYTES_OPTIMIZED) {
@@ -89,7 +95,7 @@ class CodDicomWebServer {
                             fetchType
                         }).then((arraybuffer) => {
                             if (!arraybuffer?.byteLength) {
-                                throw new Error('File Arraybuffer is not found');
+                                throw new CustomError('File Arraybuffer is not found');
                             }
                             if (isMultiframe) {
                                 return arraybuffer;
@@ -113,7 +119,7 @@ class CodDicomWebServer {
                     case Enums.RequestType.INSTANCE_METADATA:
                         return this.parseMetadata(metadataJson, type, sopInstanceUID);
                     default:
-                        throw new Error(`Unsupported request type: ${type}`);
+                        throw new CustomError(`Unsupported request type: ${type}`);
                 }
             }
             else {
@@ -139,7 +145,7 @@ class CodDicomWebServer {
             }
         }
         catch (error) {
-            const newError = new Error(`CodDicomWebServer.ts: ${error.message || 'An error occured when fetching the COD'}`);
+            const newError = new CustomError(`CodDicomWebServer.ts: ${error.message || 'An error occured when fetching the COD'}`);
             console.error(newError);
             throw newError;
         }
@@ -158,29 +164,29 @@ class CodDicomWebServer {
             });
         }
         const { maxWorkerFetchSize } = this.getOptions();
-        const webWorkerManager = getWebWorkerManager();
-        const { FILE_STREAMING_WORKER_NAME, FILE_PARTIAL_WORKER_NAME, THRESHOLD } = constants.worker;
+        const dataRetrievalManager = getDataRetrievalManager();
+        const { FILE_STREAMING_WORKER_NAME, FILE_PARTIAL_WORKER_NAME, THRESHOLD } = constants.dataRetrieval;
         let tarPromise;
         if (!this.filePromises[fileUrl]) {
             tarPromise = new Promise((resolveFile, rejectFile) => {
                 if (this.fileManager.getTotalSize() + THRESHOLD > maxWorkerFetchSize) {
-                    throw new Error(`CodDicomWebServer.ts: Maximum size(${maxWorkerFetchSize}) for fetching files reached`);
+                    throw new CustomError(`CodDicomWebServer.ts: Maximum size(${maxWorkerFetchSize}) for fetching files reached`);
                 }
                 const FetchTypeEnum = constants.Enums.FetchType;
                 if (fetchType === FetchTypeEnum.API_OPTIMIZED) {
                     const handleFirstChunk = (evt) => {
-                        if (evt instanceof ErrorEvent) {
+                        if (evt instanceof CustomErrorEvent) {
                             rejectFile(evt.error);
                             throw evt.error;
                         }
                         const { url, position, fileArraybuffer } = evt.data;
                         if (url === fileUrl && fileArraybuffer) {
                             this.fileManager.set(url, { data: fileArraybuffer, position });
-                            webWorkerManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
+                            dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
                         }
                     };
-                    webWorkerManager.addEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
-                    webWorkerManager
+                    dataRetrievalManager.addEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
+                    dataRetrievalManager
                         .executeTask(FILE_STREAMING_WORKER_NAME, 'stream', {
                         url: fileUrl,
                         headers: headers,
@@ -190,40 +196,46 @@ class CodDicomWebServer {
                         resolveFile();
                     })
                         .catch((error) => {
-                        webWorkerManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
                         rejectFile(error);
                     })
-                        .then(() => delete this.filePromises[fileUrl]);
+                        .then(() => {
+                        dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
+                        delete this.filePromises[fileUrl];
+                    });
                 }
                 else if (fetchType === FetchTypeEnum.BYTES_OPTIMIZED && offsets) {
                     const { startByte, endByte } = offsets;
-                    headers['Range'] = `bytes=${startByte}-${endByte - 1}`;
-                    const url = fileUrl.split('?bytes=')[0];
-                    webWorkerManager
-                        .executeTask(FILE_PARTIAL_WORKER_NAME, 'partial', {
-                        url: url,
-                        headers: headers,
-                        useSharedArrayBuffer
-                    })
-                        .then((data) => {
-                        if (data) {
-                            this.fileManager.set(fileUrl, {
-                                data: new Uint8Array(data),
-                                position: data.byteLength
-                            });
-                            resolveFile();
+                    const bytesRemovedUrl = fileUrl.split('?bytes=')[0];
+                    const handleSlice = (evt) => {
+                        if (evt instanceof CustomErrorEvent) {
+                            rejectFile(evt.error);
+                            throw evt.error;
                         }
-                        else {
-                            rejectFile(new Error(`File - ${url} not found`));
+                        const { url, fileArraybuffer, offsets } = evt.data;
+                        if (url === bytesRemovedUrl && offsets.startByte === startByte && offsets.endByte === endByte) {
+                            this.fileManager.set(fileUrl, { data: fileArraybuffer, position: fileArraybuffer.length });
+                            dataRetrievalManager.removeEventListener(FILE_PARTIAL_WORKER_NAME, 'message', handleSlice);
+                            resolveFile();
                         }
+                    };
+                    dataRetrievalManager.addEventListener(FILE_PARTIAL_WORKER_NAME, 'message', handleSlice);
+                    dataRetrievalManager
+                        .executeTask(FILE_PARTIAL_WORKER_NAME, 'partial', {
+                        url: bytesRemovedUrl,
+                        offsets: { startByte, endByte },
+                        headers,
+                        useSharedArrayBuffer
                     })
                         .catch((error) => {
                         rejectFile(error);
                     })
-                        .then(() => delete this.filePromises[fileUrl]);
+                        .then(() => {
+                        dataRetrievalManager.removeEventListener(FILE_PARTIAL_WORKER_NAME, 'message', handleSlice);
+                        delete this.filePromises[fileUrl];
+                    });
                 }
                 else {
-                    rejectFile(new Error('CodDicomWebServer.ts: Offsets is needed in bytes optimized fetching'));
+                    rejectFile(new CustomError('CodDicomWebServer.ts: Offsets is needed in bytes optimized fetching'));
                 }
             });
             this.filePromises[fileUrl] = tarPromise;
@@ -234,7 +246,7 @@ class CodDicomWebServer {
         return new Promise((resolveRequest, rejectRequest) => {
             let requestResolved = false;
             const handleChunkAppend = (evt) => {
-                if (evt instanceof ErrorEvent) {
+                if (evt instanceof CustomErrorEvent) {
                     rejectRequest(evt.message);
                     throw evt.error;
                 }
@@ -259,21 +271,26 @@ class CodDicomWebServer {
                 }
             };
             if (offsets && !isBytesOptimized) {
-                webWorkerManager.addEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleChunkAppend);
+                dataRetrievalManager.addEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleChunkAppend);
             }
             tarPromise
                 .then(() => {
                 if (!requestResolved) {
-                    const file = this.fileManager.get(fileUrl, isBytesOptimized ? undefined : offsets);
-                    requestResolved = true;
-                    resolveRequest(file?.buffer);
+                    if (this.fileManager.getPosition(fileUrl)) {
+                        const file = this.fileManager.get(fileUrl, isBytesOptimized ? undefined : offsets);
+                        requestResolved = true;
+                        resolveRequest(file?.buffer);
+                    }
+                    else {
+                        rejectRequest(new CustomError(`File - ${fileUrl} not found`));
+                    }
                 }
             })
                 .catch((error) => {
                 rejectRequest(error);
             })
                 .then(() => {
-                webWorkerManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleChunkAppend);
+                dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleChunkAppend);
             });
         });
     }

package/dist/esm/classes/customClasses.d.ts

@@ -0,0 +1,19 @@
+export declare class CustomError extends Error {
+}
+export declare class CustomErrorEvent extends Event {
+    error: CustomError;
+    message: string;
+    constructor(message: string, error: CustomError);
+}
+export declare class CustomMessageEvent extends MessageEvent<{
+    url: string;
+    position: number;
+    chunk?: Uint8Array;
+    isAppending?: boolean;
+    fileArraybuffer?: Uint8Array;
+    offsets?: {
+        startByte: number;
+        endByte: number;
+    };
+}> {
+}

package/dist/esm/classes/customClasses.js

@@ -0,0 +1,13 @@
+export class CustomError extends Error {
+}
+export class CustomErrorEvent extends Event {
+    error;
+    message;
+    constructor(message, error) {
+        super(message);
+        this.message = message;
+        this.error = error;
+    }
+}
+export class CustomMessageEvent extends MessageEvent {
+}

package/dist/esm/classes/index.d.ts

@@ -0,0 +1,2 @@
+import CodDicomWebServer from './CodDicomWebServer';
+export { CodDicomWebServer };

package/dist/esm/classes/index.js

@@ -0,0 +1,2 @@
+import CodDicomWebServer from './CodDicomWebServer';
+export { CodDicomWebServer };

package/dist/esm/classes/utils.js

@@ -1,4 +1,5 @@
 import constants, { Enums } from '../constants';
+import { CustomError } from './customClasses';
 export function parseWadorsURL(url, domain) {
     if (!url.includes(constants.url.URL_VALIDATION_STRING)) {
         return;
@@ -32,7 +33,7 @@ export function parseWadorsURL(url, domain) {
             type = Enums.RequestType.FRAME;
             break;
         default:
-            throw new Error('Invalid type of request');
+            throw new CustomError('Invalid type of request');
     }
     return {
         type,
@@ -46,10 +47,10 @@ export function parseWadorsURL(url, domain) {
 }
 export function getFrameDetailsFromMetadata(seriesMetadata, sopInstanceUID, frameIndex, bucketDetails) {
     if (!seriesMetadata || !seriesMetadata.cod?.instances) {
-        throw new Error('Invalid seriesMetadata provided.');
+        throw new CustomError('Invalid seriesMetadata provided.');
     }
     if (frameIndex === null || frameIndex === undefined) {
-        throw new Error('Frame index is required.');
+        throw new CustomError('Frame index is required.');
     }
     const { domain, bucketName, bucketPrefix } = bucketDetails;
     let thumbnailUrl;

package/dist/esm/constants/enums.d.ts

@@ -15,3 +15,7 @@ export declare enum RequestType {
     SERIES_METADATA = 2,
     INSTANCE_METADATA = 3
 }
+export declare enum DataRetrieveMode {
+    WORKER = 0,
+    REQUEST = 1
+}

package/dist/esm/constants/enums.js

@@ -17,3 +17,8 @@ export var RequestType;
     RequestType[RequestType["SERIES_METADATA"] = 2] = "SERIES_METADATA";
     RequestType[RequestType["INSTANCE_METADATA"] = 3] = "INSTANCE_METADATA";
 })(RequestType || (RequestType = {}));
+export var DataRetrieveMode;
+(function (DataRetrieveMode) {
+    DataRetrieveMode[DataRetrieveMode["WORKER"] = 0] = "WORKER";
+    DataRetrieveMode[DataRetrieveMode["REQUEST"] = 1] = "REQUEST";
+})(DataRetrieveMode || (DataRetrieveMode = {}));

package/dist/esm/constants/index.d.ts

@@ -1,10 +1,10 @@
 import * as Enums from './enums';
 import * as url from './url';
-import * as worker from './worker';
+import * as dataRetrieval from './dataRetrieval';
 declare const constants: {
     Enums: typeof Enums;
     url: typeof url;
-    worker: typeof worker;
+    dataRetrieval: typeof dataRetrieval;
 };
-export { Enums, url, worker };
+export { Enums, url, dataRetrieval };
 export default constants;

package/dist/esm/constants/index.js

@@ -1,6 +1,6 @@
 import * as Enums from './enums';
 import * as url from './url';
-import * as worker from './worker';
-const constants = { Enums, url, worker };
-export { Enums, url, worker };
+import * as dataRetrieval from './dataRetrieval';
+const constants = { Enums, url, dataRetrieval };
+export { Enums, url, dataRetrieval };
 export default constants;

package/dist/esm/dataRetrieval/dataRetrievalManager.d.ts

@@ -0,0 +1,17 @@
+import { CustomErrorEvent, CustomMessageEvent } from '../classes/customClasses';
+import { Enums } from '../constants';
+import { ScriptObject } from '../types';
+declare class DataRetrievalManager {
+    private dataRetriever;
+    private dataRetrieverMode;
+    constructor();
+    getDataRetrieverMode(): Enums.DataRetrieveMode;
+    setDataRetrieverMode(mode: Enums.DataRetrieveMode): void;
+    register(name: string, arg: (() => Worker) | ScriptObject): void;
+    executeTask(loaderName: string, taskName: string, options: Record<string, unknown> | unknown): Promise<void>;
+    addEventListener(workerName: string, eventType: keyof WorkerEventMap, listener: (evt: CustomMessageEvent | CustomErrorEvent) => unknown): void;
+    removeEventListener(workerName: string, eventType: keyof WorkerEventMap, listener: (evt: CustomMessageEvent | CustomErrorEvent) => unknown): void;
+    reset(): void;
+}
+export declare function getDataRetrievalManager(): DataRetrievalManager;
+export {};

package/dist/esm/dataRetrieval/dataRetrievalManager.js

@@ -0,0 +1,54 @@
+import { CustomError } from '../classes/customClasses';
+import { Enums } from '../constants';
+import RequestManager from './requestManager';
+import { isNodeEnvironment } from './utils/environment';
+import WebWorkerManager from './workerManager';
+class DataRetrievalManager {
+    dataRetriever;
+    dataRetrieverMode;
+    constructor() {
+        if (isNodeEnvironment()) {
+            this.dataRetriever = new RequestManager();
+            this.dataRetrieverMode = Enums.DataRetrieveMode.REQUEST;
+        }
+        else {
+            this.dataRetriever = new WebWorkerManager();
+            this.dataRetrieverMode = Enums.DataRetrieveMode.WORKER;
+        }
+    }
+    getDataRetrieverMode() {
+        return this.dataRetrieverMode;
+    }
+    setDataRetrieverMode(mode) {
+        const managers = {
+            [Enums.DataRetrieveMode.WORKER]: WebWorkerManager,
+            [Enums.DataRetrieveMode.REQUEST]: RequestManager
+        };
+        if (!(mode in managers)) {
+            throw new CustomError('Invalid mode');
+        }
+        this.dataRetriever.reset();
+        this.dataRetriever = new managers[mode]();
+        this.dataRetrieverMode = mode;
+    }
+    register(name, arg) {
+        // @ts-ignore
+        this.dataRetriever.register(name, arg);
+    }
+    async executeTask(loaderName, taskName, options) {
+        return await this.dataRetriever.executeTask(loaderName, taskName, options);
+    }
+    addEventListener(workerName, eventType, listener) {
+        this.dataRetriever.addEventListener(workerName, eventType, listener);
+    }
+    removeEventListener(workerName, eventType, listener) {
+        this.dataRetriever.removeEventListener(workerName, eventType, listener);
+    }
+    reset() {
+        this.dataRetriever.reset();
+    }
+}
+const dataRetrievalManager = new DataRetrievalManager();
+export function getDataRetrievalManager() {
+    return dataRetrievalManager;
+}

package/dist/esm/dataRetrieval/register.d.ts

@@ -0,0 +1,4 @@
+export declare function register(workerNames: {
+    fileStreamingScriptName: string;
+    filePartialScriptName: string;
+}, maxFetchSize: number): void;

package/dist/esm/dataRetrieval/register.js

@@ -0,0 +1,25 @@
+import { Enums } from '../constants';
+import { getDataRetrievalManager } from './dataRetrievalManager';
+import filePartial from './scripts/filePartial';
+import fileStreaming from './scripts/fileStreaming';
+export function register(workerNames, maxFetchSize) {
+    const { fileStreamingScriptName, filePartialScriptName } = workerNames;
+    const dataRetrievalManager = getDataRetrievalManager();
+    if (dataRetrievalManager.getDataRetrieverMode() === Enums.DataRetrieveMode.REQUEST) {
+        dataRetrievalManager.register(fileStreamingScriptName, fileStreaming);
+        dataRetrievalManager.register(filePartialScriptName, filePartial);
+    }
+    else {
+        // fileStreaming worker
+        const streamingWorkerFn = () => new Worker(new URL('./workers/fileStreamingWorker', import.meta.url), {
+            name: fileStreamingScriptName
+        });
+        dataRetrievalManager.register(fileStreamingScriptName, streamingWorkerFn);
+        // filePartial worker
+        const partialWorkerFn = () => new Worker(new URL('./workers/filePartialWorker', import.meta.url), {
+            name: filePartialScriptName
+        });
+        dataRetrievalManager.register(filePartialScriptName, partialWorkerFn);
+    }
+    dataRetrievalManager.executeTask(fileStreamingScriptName, 'setMaxFetchSize', maxFetchSize);
+}

package/dist/esm/dataRetrieval/requestManager.d.ts

@@ -0,0 +1,12 @@
+import { CustomMessageEvent, CustomErrorEvent } from '../classes/customClasses';
+import { ScriptObject } from '../types';
+declare class RequestManager {
+    private loaderRegistry;
+    register(loaderName: string, loaderObject: ScriptObject): void;
+    private listenerCallback;
+    executeTask(loaderName: string, taskName: string, options: Record<string, unknown> | unknown): Promise<void>;
+    addEventListener(workerName: string, eventType: keyof WorkerEventMap, listener: (evt: CustomMessageEvent | CustomErrorEvent) => unknown): void;
+    removeEventListener(workerName: string, eventType: keyof WorkerEventMap, listener: (evt: CustomMessageEvent | CustomErrorEvent) => unknown): void;
+    reset(): void;
+}
+export default RequestManager;

package/dist/esm/dataRetrieval/requestManager.js

@@ -0,0 +1,65 @@
+import { CustomError } from '../classes/customClasses';
+class RequestManager {
+    loaderRegistry = {};
+    register(loaderName, loaderObject) {
+        try {
+            if (!loaderObject) {
+                throw new CustomError(`Loader object for ${loaderName} is not provided`);
+            }
+            this.loaderRegistry[loaderName] = {
+                loaderObject,
+                listeners: {}
+            };
+        }
+        catch (error) {
+            console.warn(error);
+            throw new CustomError('throws');
+        }
+    }
+    listenerCallback = (loaderName, taskName, args) => {
+        const listeners = this.loaderRegistry[loaderName]?.listeners[taskName];
+        if (listeners) {
+            listeners.forEach((listener) => listener({ data: args }));
+        }
+    };
+    async executeTask(loaderName, taskName, options) {
+        const loaderObject = this.loaderRegistry[loaderName]?.loaderObject;
+        if (!loaderObject) {
+            throw new CustomError(`Loader ${loaderName} not registered`);
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            return await loaderObject[taskName](options, (args) => this.listenerCallback(loaderName, 'message', args));
+        }
+        catch (error) {
+            console.error(`Error executing task "${taskName}" on "${loaderName}":`, error);
+            throw new CustomError(`Task "${taskName}" failed: ${error.message}`);
+        }
+    }
+    addEventListener(workerName, eventType, listener) {
+        const loaderObject = this.loaderRegistry[workerName];
+        if (!loaderObject) {
+            console.error(`Loader '${workerName}' is not registered.`);
+            return;
+        }
+        if (!loaderObject.listeners[eventType]) {
+            loaderObject.listeners[eventType] = [listener];
+        }
+        else {
+            loaderObject.listeners[eventType].push(listener);
+        }
+    }
+    removeEventListener(workerName, eventType, listener) {
+        const loaderObject = this.loaderRegistry[workerName];
+        if (!loaderObject) {
+            console.error(`Loader '${workerName}' is not registered.`);
+            return;
+        }
+        loaderObject.listeners[eventType] = (loaderObject.listeners[eventType] || []).filter((existingListener) => existingListener !== listener);
+    }
+    reset() {
+        this.loaderRegistry = {};
+    }
+}
+export default RequestManager;

package/dist/esm/dataRetrieval/scripts/filePartial.d.ts

@@ -0,0 +1,18 @@
+declare const filePartial: {
+    partial(args: {
+        url: string;
+        offsets?: {
+            startByte: number;
+            endByte: number;
+        };
+        headers?: Record<string, string>;
+    }, callBack: (data: {
+        url: string;
+        fileArraybuffer: Uint8Array;
+        offsets: {
+            startByte: number;
+            endByte: number;
+        };
+    }) => void): Promise<void | Error>;
+};
+export default filePartial;

package/dist/esm/dataRetrieval/scripts/filePartial.js

@@ -0,0 +1,16 @@
+import { CustomError } from '../../classes/customClasses';
+const filePartial = {
+    async partial(args, callBack) {
+        const { url, offsets, headers } = args;
+        if (offsets?.startByte && offsets?.endByte) {
+            headers['Range'] = `bytes=${offsets.startByte}-${offsets.endByte - 1}`;
+        }
+        await fetch(url, { headers })
+            .then((response) => response.arrayBuffer())
+            .then((data) => callBack({ url, fileArraybuffer: new Uint8Array(data), offsets }))
+            .catch((error) => {
+            throw new CustomError('filePartial.ts: Error when fetching file: ' + error?.message);
+        });
+    }
+};
+export default filePartial;

package/dist/esm/{webWorker → dataRetrieval}/scripts/fileStreaming.d.ts

@@ -7,6 +7,12 @@ declare const fileStreaming: {
         url: string;
         headers?: Record<string, string>;
         useSharedArrayBuffer?: boolean;
-    }): Promise<void>;
+    }, callBack: (data: {
+        url: string;
+        position: number;
+        isAppending?: boolean;
+        fileArraybuffer?: Uint8Array;
+        chunk?: Uint8Array;
+    }) => void): Promise<Uint8Array | void>;
 };
 export default fileStreaming;