cod-dicomweb-server 1.2.3 → 1.2.4

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;

package/dist/esm/classes/CodDicomWebServer.js

@@ -0,0 +1,306 @@
+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 constants, { Enums } from '../constants';
+class CodDicomWebServer {
+    filePromises = {};
+    options = {
+        maxWorkerFetchSize: Infinity,
+        domain: constants.url.DOMAIN
+    };
+    fileManager;
+    metadataManager;
+    seriesUidFileUrls = {};
+    constructor(args = {}) {
+        const { maxWorkerFetchSize, domain } = 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 });
+        this.metadataManager = new MetadataManager();
+        registerWorkers({ fileStreamingWorkerName, filePartialWorkerName }, 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 Error('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 Error(`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 Error(`Thumbnail not found for ${wadorsUrl}`);
+                        }
+                        this.addFileUrl(seriesInstanceUID, thumbnailUrl);
+                        return this.fetchFile(thumbnailUrl, headers, {
+                            useSharedArrayBuffer
+                        });
+                    case Enums.RequestType.FRAME: {
+                        if (!fileUrl) {
+                            throw new Error('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 Error('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 Error(`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 Error(`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 webWorkerManager = getWebWorkerManager();
+        const { FILE_STREAMING_WORKER_NAME, FILE_PARTIAL_WORKER_NAME, THRESHOLD } = constants.worker;
+        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`);
+                }
+                const FetchTypeEnum = constants.Enums.FetchType;
+                if (fetchType === FetchTypeEnum.API_OPTIMIZED) {
+                    const handleFirstChunk = (evt) => {
+                        if (evt instanceof ErrorEvent) {
+                            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);
+                        }
+                    };
+                    webWorkerManager.addEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
+                    webWorkerManager
+                        .executeTask(FILE_STREAMING_WORKER_NAME, 'stream', {
+                        url: fileUrl,
+                        headers: headers,
+                        useSharedArrayBuffer
+                    })
+                        .then(() => {
+                        resolveFile();
+                    })
+                        .catch((error) => {
+                        webWorkerManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
+                        rejectFile(error);
+                    })
+                        .then(() => 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();
+                        }
+                        else {
+                            rejectFile(new Error(`File - ${url} not found`));
+                        }
+                    })
+                        .catch((error) => {
+                        rejectFile(error);
+                    })
+                        .then(() => delete this.filePromises[fileUrl]);
+                }
+                else {
+                    rejectFile(new Error('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 ErrorEvent) {
+                    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) {
+                webWorkerManager.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);
+                }
+            })
+                .catch((error) => {
+                rejectRequest(error);
+            })
+                .then(() => {
+                webWorkerManager.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/utils.js

@@ -0,0 +1,101 @@
+import constants, { Enums } from '../constants';
+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 Error('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 Error('Invalid seriesMetadata provided.');
+    }
+    if (frameIndex === null || frameIndex === undefined) {
+        throw new Error('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/enums.js

@@ -0,0 +1,19 @@
+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 = {}));

package/dist/esm/constants/index.js

@@ -0,0 +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 };
+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/constants/worker.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/esm/fileManager.js

@@ -0,0 +1,52 @@
+import { getWebWorkerManager } from './webWorker/workerManager';
+class FileManager {
+    files = {};
+    fileStreamingWorkerName;
+    constructor({ fileStreamingWorkerName }) {
+        this.fileStreamingWorkerName = fileStreamingWorkerName;
+    }
+    set(url, file) {
+        this.files[url] = file;
+    }
+    get(url, offsets) {
+        if (!this.files[url] || (offsets && this.files[url].position <= offsets.endByte)) {
+            return null;
+        }
+        return offsets ? this.files[url].data.slice(offsets.startByte, offsets.endByte) : this.files[url].data;
+    }
+    setPosition(url, position) {
+        if (this.files[url]) {
+            this.files[url].position = position;
+        }
+    }
+    getPosition(url) {
+        return this.files[url]?.position;
+    }
+    append(url, chunk, position) {
+        if (this.files[url] && position) {
+            this.files[url].data.set(chunk, position - chunk.length);
+            this.setPosition(url, position);
+        }
+    }
+    getTotalSize() {
+        return Object.entries(this.files).reduce((total, [url, { position }]) => {
+            return url.includes('?bytes=') ? total : total + position;
+        }, 0);
+    }
+    remove(url) {
+        const removedSize = this.getPosition(url);
+        delete this.files[url];
+        if (url.includes('?bytes=')) {
+            return;
+        }
+        const workerManager = getWebWorkerManager();
+        workerManager.executeTask(this.fileStreamingWorkerName, 'decreaseFetchedSize', removedSize);
+    }
+    purge() {
+        const totalSize = this.getTotalSize();
+        this.files = {};
+        const workerManager = getWebWorkerManager();
+        workerManager.executeTask(this.fileStreamingWorkerName, 'decreaseFetchedSize', totalSize);
+    }
+}
+export default FileManager;

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+import { FetchType } from './constants/enums';
+import CodDicomWebServer from './classes/CodDicomWebServer';
+export { FetchType, CodDicomWebServer };
+export default { FetchType, CodDicomWebServer };

package/dist/{types → esm}/metadataManager.d.ts

@@ -2,6 +2,7 @@ import type { JsonMetadata, MetadataUrlCreationParams } from './types';
 declare class MetadataManager {
     private metadata;
     constructor();
+    addDeidMetadata(jsonMetadata: JsonMetadata): void;
     getMetadataFromCache(url: string): JsonMetadata;
     getMetadata(params: MetadataUrlCreationParams, headers: Record<string, string>): Promise<JsonMetadata | null>;
 }

package/dist/esm/metadataManager.js

@@ -0,0 +1,46 @@
+import { createMetadataJsonUrl } from './classes/utils';
+class MetadataManager {
+    metadata = {};
+    constructor() { }
+    addDeidMetadata(jsonMetadata) {
+        const { deid_study_uid, deid_series_uid, cod } = jsonMetadata;
+        if (!cod || !deid_study_uid || !deid_series_uid) {
+            console.warn('Missing required metadata properties: cod, deid_study_uid, or deid_series_uid');
+            return;
+        }
+        for (const deid_sop_uid in cod.instances) {
+            const instance = cod.instances[deid_sop_uid];
+            instance.metadata.DeidStudyInstanceUID = { Value: [deid_study_uid] };
+            instance.metadata.DeidSeriesInstanceUID = { Value: [deid_series_uid] };
+            instance.metadata.DeidSopInstanceUID = { Value: [deid_sop_uid] };
+        }
+    }
+    getMetadataFromCache(url) {
+        return this.metadata[url];
+    }
+    async getMetadata(params, headers) {
+        const url = createMetadataJsonUrl(params);
+        if (!url) {
+            throw new Error('Error creating metadata json url');
+        }
+        const cachedMetadata = this.getMetadataFromCache(url);
+        if (cachedMetadata) {
+            return cachedMetadata;
+        }
+        try {
+            const response = await fetch(url, { headers });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch metadata: ${response.statusText}`);
+            }
+            const data = await response.json();
+            this.addDeidMetadata(data);
+            this.metadata[url] = data;
+            return data;
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+    }
+}
+export default MetadataManager;

package/dist/esm/types/index.js

@@ -0,0 +1,7 @@
+export * from './codDicomWebServerOptions';
+export * from './fileManagerOptions';
+export * from './metadata';
+export * from './metadataUrlCreationParams';
+export * from './parsedWadoRsUrlDetails';
+export * from './requestOptions';
+export * from './workerCustomMessageEvents';

package/dist/{types → esm}/types/metadata.d.ts

@@ -52,8 +52,8 @@ type JsonMetadata = {
     };
 };
 type InstanceMetadata = Record<string, {
-    vr: string;
-    Value?: unknown[];
+    vr?: string;
+    Value: unknown[];
     BulkDataURI?: string;
     InlineBinary?: string;
 }>;

package/dist/esm/types/metadata.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/metadataUrlCreationParams.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/parsedWadoRsUrlDetails.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/requestOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/workerCustomMessageEvents.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/webWorker/registerWorkers.js

@@ -0,0 +1,16 @@
+import { getWebWorkerManager } from './workerManager';
+export function registerWorkers(workerNames, maxFetchSize) {
+    const { fileStreamingWorkerName, filePartialWorkerName } = workerNames;
+    const workerManager = getWebWorkerManager();
+    // fileStreaming worker
+    const streamingWorkerFn = () => new Worker(new URL('./workers/fileStreamingWorker', import.meta.url), {
+        name: fileStreamingWorkerName
+    });
+    workerManager.registerWorker(fileStreamingWorkerName, streamingWorkerFn);
+    workerManager.executeTask(fileStreamingWorkerName, 'setMaxFetchSize', maxFetchSize);
+    // filePartial worker
+    const partialWorkerFn = () => new Worker(new URL('./workers/filePartialWorker', import.meta.url), {
+        name: filePartialWorkerName
+    });
+    workerManager.registerWorker(filePartialWorkerName, partialWorkerFn);
+}

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

@@ -0,0 +1,11 @@
+const filePartial = {
+    async partial(args) {
+        const { url, headers } = args;
+        return fetch(url, { headers })
+            .then((response) => response.arrayBuffer())
+            .catch((error) => {
+            throw new Error('filePartial.ts: Error when fetching file: ' + error?.message);
+        });
+    }
+};
+export default filePartial;