cod-dicomweb-server 1.2.3 → 1.3.0

package/dist/{types → esm}/classes/CodDicomWebServer.d.ts

@@ -1,5 +1,5 @@
 import { Enums } from '../constants';
-import type { CodDicomWebServerOptions, InstanceMetadata, JsonMetadata, SeriesMetadata, CODRequestOptions, FileRequestOptions } from '../types';
+import type { CodDicomWebServerOptions, CODRequestOptions, FileRequestOptions, InstanceMetadata, JsonMetadata, SeriesMetadata } from '../types';
 declare class CodDicomWebServer {
     private filePromises;
     private options;
@@ -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

@@ -0,0 +1,323 @@
+import { parseDicom } from 'dicom-parser';
+import FileManager from '../fileManager';
+import MetadataManager from '../metadataManager';
+import { getFrameDetailsFromMetadata, parseWadorsURL } from './utils';
+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 = {
+        maxWorkerFetchSize: Infinity,
+        domain: constants.url.DOMAIN
+    };
+    fileManager;
+    metadataManager;
+    seriesUidFileUrls = {};
+    constructor(args = {}) {
+        const { maxWorkerFetchSize, domain, disableWorker } = args;
+        this.options.maxWorkerFetchSize = maxWorkerFetchSize || this.options.maxWorkerFetchSize;
+        this.options.domain = domain || this.options.domain;
+        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();
+        if (disableWorker) {
+            const dataRetrievalManager = getDataRetrievalManager();
+            dataRetrievalManager.setDataRetrieverMode(Enums.DataRetrieveMode.REQUEST);
+        }
+        register({ fileStreamingScriptName, filePartialScriptName }, this.options.maxWorkerFetchSize);
+    }
+    setOptions = (newOptions) => {
+        Object.keys(newOptions).forEach((key) => {
+            if (newOptions[key] !== undefined) {
+                this.options[key] = newOptions[key];
+            }
+        });
+    };
+    getOptions = () => {
+        return this.options;
+    };
+    addFileUrl(seriesInstanceUID, url) {
+        if (this.seriesUidFileUrls[seriesInstanceUID]) {
+            this.seriesUidFileUrls[seriesInstanceUID].push(url);
+        }
+        else {
+            this.seriesUidFileUrls[seriesInstanceUID] = [url];
+        }
+    }
+    async fetchCod(wadorsUrl, headers = {}, { useSharedArrayBuffer = false, fetchType = constants.Enums.FetchType.API_OPTIMIZED } = {}) {
+        try {
+            if (!wadorsUrl) {
+                throw new CustomError('Url not provided');
+            }
+            const parsedDetails = parseWadorsURL(wadorsUrl, this.options.domain);
+            if (parsedDetails) {
+                const { type, bucketName, bucketPrefix, studyInstanceUID, seriesInstanceUID, sopInstanceUID, frameNumber } = parsedDetails;
+                const metadataJson = await this.metadataManager.getMetadata({
+                    domain: this.options.domain,
+                    bucketName,
+                    bucketPrefix,
+                    studyInstanceUID,
+                    seriesInstanceUID
+                }, headers);
+                if (!metadataJson) {
+                    throw new CustomError(`Metadata not found for ${wadorsUrl}`);
+                }
+                const { url: fileUrl, startByte, endByte, thumbnailUrl, isMultiframe } = getFrameDetailsFromMetadata(metadataJson, sopInstanceUID, frameNumber - 1, {
+                    domain: this.options.domain,
+                    bucketName,
+                    bucketPrefix
+                });
+                switch (type) {
+                    case Enums.RequestType.THUMBNAIL:
+                        if (!thumbnailUrl) {
+                            throw new CustomError(`Thumbnail not found for ${wadorsUrl}`);
+                        }
+                        this.addFileUrl(seriesInstanceUID, thumbnailUrl);
+                        return this.fetchFile(thumbnailUrl, headers, {
+                            useSharedArrayBuffer
+                        });
+                    case Enums.RequestType.FRAME: {
+                        if (!fileUrl) {
+                            throw new CustomError('Url not found for frame');
+                        }
+                        let urlWithBytes = fileUrl;
+                        if (fetchType === Enums.FetchType.BYTES_OPTIMIZED) {
+                            urlWithBytes = `${fileUrl}?bytes=${startByte}-${endByte}`;
+                        }
+                        this.addFileUrl(seriesInstanceUID, fileUrl);
+                        return this.fetchFile(urlWithBytes, headers, {
+                            offsets: { startByte, endByte },
+                            useSharedArrayBuffer,
+                            fetchType
+                        }).then((arraybuffer) => {
+                            if (!arraybuffer?.byteLength) {
+                                throw new CustomError('File Arraybuffer is not found');
+                            }
+                            if (isMultiframe) {
+                                return arraybuffer;
+                            }
+                            else {
+                                const dataSet = parseDicom(new Uint8Array(arraybuffer));
+                                const pixelDataElement = dataSet.elements.x7fe00010;
+                                let { dataOffset, length } = pixelDataElement;
+                                if (pixelDataElement.hadUndefinedLength && pixelDataElement.fragments) {
+                                    ({ position: dataOffset, length } = pixelDataElement.fragments[0]);
+                                }
+                                else {
+                                    // Adding 8 bytes for 4 bytes tag + 4 bytes length for uncomppressed pixelData
+                                    dataOffset += 8;
+                                }
+                                return arraybuffer.slice(dataOffset, dataOffset + length);
+                            }
+                        });
+                    }
+                    case Enums.RequestType.SERIES_METADATA:
+                    case Enums.RequestType.INSTANCE_METADATA:
+                        return this.parseMetadata(metadataJson, type, sopInstanceUID);
+                    default:
+                        throw new CustomError(`Unsupported request type: ${type}`);
+                }
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    return this.fetchFile(wadorsUrl, headers, { useSharedArrayBuffer })
+                        .then((result) => {
+                        if (result instanceof ArrayBuffer) {
+                            try {
+                                const dataSet = parseDicom(new Uint8Array(result));
+                                const seriesInstanceUID = dataSet.string('0020000e');
+                                if (seriesInstanceUID) {
+                                    this.addFileUrl(seriesInstanceUID, wadorsUrl);
+                                }
+                            }
+                            catch (error) {
+                                console.warn('CodDicomWebServer.ts: There is some issue parsing the file.', error);
+                            }
+                        }
+                        resolve(result);
+                    })
+                        .catch((error) => reject(error));
+                });
+            }
+        }
+        catch (error) {
+            const newError = new CustomError(`CodDicomWebServer.ts: ${error.message || 'An error occured when fetching the COD'}`);
+            console.error(newError);
+            throw newError;
+        }
+    }
+    async fetchFile(fileUrl, headers, { offsets, useSharedArrayBuffer = false, fetchType = constants.Enums.FetchType.API_OPTIMIZED } = {}) {
+        const isBytesOptimized = fetchType === Enums.FetchType.BYTES_OPTIMIZED;
+        const extractedFile = this.fileManager.get(fileUrl, isBytesOptimized ? undefined : offsets);
+        if (extractedFile) {
+            return new Promise((resolveRequest, rejectRequest) => {
+                try {
+                    resolveRequest(extractedFile.buffer);
+                }
+                catch (error) {
+                    rejectRequest(error);
+                }
+            });
+        }
+        const { maxWorkerFetchSize } = this.getOptions();
+        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 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 CustomErrorEvent) {
+                            rejectFile(evt.error);
+                            throw evt.error;
+                        }
+                        const { url, position, fileArraybuffer } = evt.data;
+                        if (url === fileUrl && fileArraybuffer) {
+                            this.fileManager.set(url, { data: fileArraybuffer, position });
+                            dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
+                        }
+                    };
+                    dataRetrievalManager.addEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
+                    dataRetrievalManager
+                        .executeTask(FILE_STREAMING_WORKER_NAME, 'stream', {
+                        url: fileUrl,
+                        headers: headers,
+                        useSharedArrayBuffer
+                    })
+                        .then(() => {
+                        resolveFile();
+                    })
+                        .catch((error) => {
+                        rejectFile(error);
+                    })
+                        .then(() => {
+                        dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
+                        delete this.filePromises[fileUrl];
+                    });
+                }
+                else if (fetchType === FetchTypeEnum.BYTES_OPTIMIZED && offsets) {
+                    const { startByte, endByte } = offsets;
+                    const bytesRemovedUrl = fileUrl.split('?bytes=')[0];
+                    const handleSlice = (evt) => {
+                        if (evt instanceof CustomErrorEvent) {
+                            rejectFile(evt.error);
+                            throw evt.error;
+                        }
+                        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(() => {
+                        dataRetrievalManager.removeEventListener(FILE_PARTIAL_WORKER_NAME, 'message', handleSlice);
+                        delete this.filePromises[fileUrl];
+                    });
+                }
+                else {
+                    rejectFile(new CustomError('CodDicomWebServer.ts: Offsets is needed in bytes optimized fetching'));
+                }
+            });
+            this.filePromises[fileUrl] = tarPromise;
+        }
+        else {
+            tarPromise = this.filePromises[fileUrl];
+        }
+        return new Promise((resolveRequest, rejectRequest) => {
+            let requestResolved = false;
+            const handleChunkAppend = (evt) => {
+                if (evt instanceof CustomErrorEvent) {
+                    rejectRequest(evt.message);
+                    throw evt.error;
+                }
+                const { url, position, chunk, isAppending } = evt.data;
+                if (isAppending) {
+                    if (chunk) {
+                        this.fileManager.append(url, chunk, position);
+                    }
+                    else {
+                        this.fileManager.setPosition(url, position);
+                    }
+                }
+                if (!requestResolved && url === fileUrl && offsets && position > offsets.endByte) {
+                    try {
+                        const file = this.fileManager.get(url, offsets);
+                        requestResolved = true;
+                        resolveRequest(file?.buffer);
+                    }
+                    catch (error) {
+                        rejectRequest(error);
+                    }
+                }
+            };
+            if (offsets && !isBytesOptimized) {
+                dataRetrievalManager.addEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleChunkAppend);
+            }
+            tarPromise
+                .then(() => {
+                if (!requestResolved) {
+                    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(() => {
+                dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleChunkAppend);
+            });
+        });
+    }
+    delete(seriesInstanceUID) {
+        const fileUrls = this.seriesUidFileUrls[seriesInstanceUID];
+        if (fileUrls) {
+            fileUrls.forEach((fileUrl) => {
+                this.fileManager.remove(fileUrl);
+            });
+        }
+        delete this.seriesUidFileUrls[seriesInstanceUID];
+    }
+    deleteAll() {
+        Object.values(this.seriesUidFileUrls).forEach((fileUrls) => {
+            fileUrls.forEach((fileUrl) => {
+                this.fileManager.remove(fileUrl);
+            });
+        });
+        this.seriesUidFileUrls = {};
+    }
+    parseMetadata(metadata, type, sopInstanceUID) {
+        if (type === Enums.RequestType.INSTANCE_METADATA) {
+            return Object.values(metadata.cod.instances).find((instance) => instance.metadata['00080018']?.Value?.[0] === sopInstanceUID)?.metadata;
+        }
+        else {
+            return Object.values(metadata.cod.instances).map((instance) => instance.metadata);
+        }
+    }
+}
+export default CodDicomWebServer;

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

@@ -0,0 +1,102 @@
+import constants, { Enums } from '../constants';
+import { CustomError } from './customClasses';
+export function parseWadorsURL(url, domain) {
+    if (!url.includes(constants.url.URL_VALIDATION_STRING)) {
+        return;
+    }
+    const filePath = url.split(domain + '/')[1];
+    const prefix = filePath.split('/studies')[0];
+    const prefixParts = prefix.split('/');
+    const bucketName = prefixParts[0];
+    const bucketPrefix = prefixParts.slice(1).join('/');
+    const imagePath = filePath.split(prefix + '/')[1];
+    const imageParts = imagePath.split('/');
+    const studyInstanceUID = imageParts[1];
+    const seriesInstanceUID = imageParts[3];
+    let sopInstanceUID = '', frameNumber = 1, type;
+    switch (true) {
+        case imageParts.includes('thumbnail'):
+            type = Enums.RequestType.THUMBNAIL;
+            break;
+        case imageParts.includes('metadata'):
+            if (imageParts.includes('instances')) {
+                sopInstanceUID = imageParts[5];
+                type = Enums.RequestType.INSTANCE_METADATA;
+            }
+            else {
+                type = Enums.RequestType.SERIES_METADATA;
+            }
+            break;
+        case imageParts.includes('frames'):
+            sopInstanceUID = imageParts[5];
+            frameNumber = +imageParts[7];
+            type = Enums.RequestType.FRAME;
+            break;
+        default:
+            throw new CustomError('Invalid type of request');
+    }
+    return {
+        type,
+        bucketName,
+        bucketPrefix,
+        studyInstanceUID,
+        seriesInstanceUID,
+        sopInstanceUID,
+        frameNumber
+    };
+}
+export function getFrameDetailsFromMetadata(seriesMetadata, sopInstanceUID, frameIndex, bucketDetails) {
+    if (!seriesMetadata || !seriesMetadata.cod?.instances) {
+        throw new CustomError('Invalid seriesMetadata provided.');
+    }
+    if (frameIndex === null || frameIndex === undefined) {
+        throw new CustomError('Frame index is required.');
+    }
+    const { domain, bucketName, bucketPrefix } = bucketDetails;
+    let thumbnailUrl;
+    if (seriesMetadata.thumbnail) {
+        const thumbnailGsUtilUri = seriesMetadata.thumbnail.uri;
+        thumbnailUrl = `${domain}/${thumbnailGsUtilUri.split('gs://')[1]}`;
+    }
+    const instanceFound = Object.values(seriesMetadata.cod.instances).find((instance) => instance.metadata['00080018']?.Value?.[0] === sopInstanceUID);
+    if (!instanceFound) {
+        return { thumbnailUrl };
+    }
+    const { url, uri, headers: offsetHeaders, offset_tables } = instanceFound;
+    const modifiedUrl = handleUrl(url || uri, domain, bucketName, bucketPrefix);
+    const { CustomOffsetTable, CustomOffsetTableLengths } = offset_tables;
+    let sliceStart, sliceEnd, isMultiframe = false;
+    if (CustomOffsetTable?.length && CustomOffsetTableLengths?.length) {
+        sliceStart = CustomOffsetTable[frameIndex];
+        sliceEnd = sliceStart + CustomOffsetTableLengths[frameIndex];
+        isMultiframe = true;
+    }
+    const { start_byte: fileStartByte, end_byte: fileEndByte } = offsetHeaders;
+    const startByte = sliceStart !== undefined ? fileStartByte + sliceStart : fileStartByte;
+    const endByte = sliceEnd !== undefined ? fileStartByte + sliceEnd : fileEndByte;
+    return {
+        url: modifiedUrl,
+        startByte,
+        endByte,
+        thumbnailUrl,
+        isMultiframe
+    };
+}
+export function handleUrl(url, domain, bucketName, bucketPrefix) {
+    let modifiedUrl = url;
+    const matchingExtension = constants.url.FILE_EXTENSIONS.find((extension) => url.includes(extension));
+    if (matchingExtension) {
+        const fileParts = url.split(matchingExtension);
+        modifiedUrl = fileParts[0] + matchingExtension;
+    }
+    const filePath = modifiedUrl.split('studies/')[1];
+    modifiedUrl = `${domain}/${bucketName}/${bucketPrefix ? bucketPrefix + '/' : ''}studies/${filePath}`;
+    return modifiedUrl;
+}
+export function createMetadataJsonUrl(params) {
+    const { domain = constants.url.DOMAIN, bucketName, bucketPrefix, studyInstanceUID, seriesInstanceUID } = params;
+    if (!bucketName || !bucketPrefix || !studyInstanceUID || !seriesInstanceUID) {
+        return;
+    }
+    return `${domain}/${bucketName}/${bucketPrefix}/studies/${studyInstanceUID}/series/${seriesInstanceUID}/metadata.json`;
+}

package/dist/esm/constants/dataRetrieval.js

@@ -0,0 +1,3 @@
+export const FILE_PARTIAL_WORKER_NAME = 'filePartial';
+export const FILE_STREAMING_WORKER_NAME = 'fileStreaming';
+export const THRESHOLD = 10000;

package/dist/{types → 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

@@ -0,0 +1,24 @@
+export var FetchType;
+(function (FetchType) {
+    /**
+     * Fetch only the part of the file according to the offsets provided.
+     */
+    FetchType[FetchType["BYTES_OPTIMIZED"] = 0] = "BYTES_OPTIMIZED";
+    /**
+     * Stream the file and returns the part of the file if offsets are provided.
+     * Or returns the whole file.
+     */
+    FetchType[FetchType["API_OPTIMIZED"] = 1] = "API_OPTIMIZED";
+})(FetchType || (FetchType = {}));
+export var RequestType;
+(function (RequestType) {
+    RequestType[RequestType["FRAME"] = 0] = "FRAME";
+    RequestType[RequestType["THUMBNAIL"] = 1] = "THUMBNAIL";
+    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/{types → 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

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

package/dist/esm/constants/url.js

@@ -0,0 +1,3 @@
+export const DOMAIN = 'https://storage.googleapis.com';
+export const FILE_EXTENSIONS = ['.tar', '.zip'];
+export const URL_VALIDATION_STRING = '/dicomweb/';

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;