cod-dicomweb-server 1.3.11 → 1.3.13

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

@@ -2,12 +2,13 @@ import { Enums } from '../constants';
 import type { CodDicomWebServerOptions, CODRequestOptions, FileRequestOptions, InstanceMetadata, JsonMetadata, SeriesMetadata } from '../types';
 declare class CodDicomWebServer {
     private filePromises;
+    private files;
     private options;
     private fileManager;
     private metadataManager;
     private seriesUidFileUrls;
     constructor(args?: {
-        maxWorkerFetchSize?: number;
+        maxCacheSize?: number;
         domain?: string;
         disableWorker?: boolean;
         enableLocalCache?: boolean;

package/dist/esm/classes/CodDicomWebServer.js

@@ -10,8 +10,9 @@ import { CustomErrorEvent } from './customClasses';
 import { download, getDirectoryHandle } from '../fileAccessSystemUtils';
 class CodDicomWebServer {
     filePromises = {};
+    files = {};
     options = {
-        maxWorkerFetchSize: Infinity,
+        maxCacheSize: 4 * 1024 * 1024 * 1024,
         domain: constants.url.DOMAIN,
         enableLocalCache: false
     };
@@ -19,19 +20,19 @@ class CodDicomWebServer {
     metadataManager;
     seriesUidFileUrls = {};
     constructor(args = {}) {
-        const { maxWorkerFetchSize, domain, disableWorker, enableLocalCache } = args;
-        this.options.maxWorkerFetchSize = maxWorkerFetchSize || this.options.maxWorkerFetchSize;
+        const { maxCacheSize, domain, disableWorker, enableLocalCache } = args;
+        this.options.maxCacheSize = maxCacheSize || this.options.maxCacheSize;
         this.options.domain = domain || this.options.domain;
         this.options.enableLocalCache = !!enableLocalCache;
         const fileStreamingScriptName = constants.dataRetrieval.FILE_STREAMING_WORKER_NAME;
         const filePartialScriptName = constants.dataRetrieval.FILE_PARTIAL_WORKER_NAME;
-        this.fileManager = new FileManager({ fileStreamingScriptName });
+        this.fileManager = new FileManager();
         this.metadataManager = new MetadataManager();
         if (disableWorker) {
             const dataRetrievalManager = getDataRetrievalManager();
             dataRetrievalManager.setDataRetrieverMode(Enums.DataRetrieveMode.REQUEST);
         }
-        register({ fileStreamingScriptName, filePartialScriptName }, this.options.maxWorkerFetchSize);
+        register({ fileStreamingScriptName, filePartialScriptName });
     }
     setOptions = (newOptions) => {
         Object.keys(newOptions).forEach((key) => {
@@ -163,15 +164,11 @@ class CodDicomWebServer {
             });
         }
         const directoryHandle = this.options.enableLocalCache && (await getDirectoryHandle());
-        const { maxWorkerFetchSize } = this.getOptions();
         const dataRetrievalManager = getDataRetrievalManager();
-        const { FILE_STREAMING_WORKER_NAME, FILE_PARTIAL_WORKER_NAME, THRESHOLD } = constants.dataRetrieval;
+        const { FILE_STREAMING_WORKER_NAME, FILE_PARTIAL_WORKER_NAME } = 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) => {
@@ -181,7 +178,12 @@ class CodDicomWebServer {
                         }
                         const { url, position, fileArraybuffer } = evt.data;
                         if (url === fileUrl && fileArraybuffer) {
-                            this.fileManager.set(url, { data: fileArraybuffer, position });
+                            if (this.options.enableLocalCache) {
+                                this.files[fileUrl] = fileArraybuffer;
+                            }
+                            else {
+                                this.fileManager.set(url, { data: fileArraybuffer, position });
+                            }
                             dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
                         }
                     };
@@ -201,7 +203,6 @@ class CodDicomWebServer {
                     })
                         .then(() => {
                         dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleFirstChunk);
-                        delete this.filePromises[fileUrl];
                     });
                 }
                 else if (fetchType === FetchTypeEnum.BYTES_OPTIMIZED && offsets) {
@@ -214,7 +215,12 @@ class CodDicomWebServer {
                         }
                         const { url, fileArraybuffer, offsets } = evt.data;
                         if (url === bytesRemovedUrl && offsets.startByte === startByte && offsets.endByte === endByte) {
-                            this.fileManager.set(fileUrl, { data: fileArraybuffer, position: fileArraybuffer.length });
+                            if (this.options.enableLocalCache) {
+                                this.files[fileUrl] = fileArraybuffer;
+                            }
+                            else {
+                                this.fileManager.set(fileUrl, { data: fileArraybuffer, position: fileArraybuffer.length });
+                            }
                             dataRetrievalManager.removeEventListener(FILE_PARTIAL_WORKER_NAME, 'message', handleSlice);
                             resolveFile();
                         }
@@ -232,43 +238,69 @@ class CodDicomWebServer {
                     })
                         .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;
+            this.filePromises[fileUrl] = { promise: tarPromise, requestCount: 1 };
         }
         else {
-            tarPromise = this.filePromises[fileUrl];
+            tarPromise = this.filePromises[fileUrl].promise;
+            this.filePromises[fileUrl].requestCount++;
         }
         return new Promise((resolveRequest, rejectRequest) => {
-            let requestResolved = false;
+            let requestResolved = false, fileFetchingCompleted = false;
             const handleChunkAppend = (evt) => {
                 if (evt instanceof CustomErrorEvent) {
                     rejectRequest(evt.message);
                     throw evt.error;
                 }
-                const { url, position, chunk, isAppending } = evt.data;
+                const { url, position, chunk, totalLength, isAppending } = evt.data;
                 if (isAppending) {
                     if (chunk) {
-                        this.fileManager.append(url, chunk, position);
+                        if (this.options.enableLocalCache) {
+                            this.files[url].set(chunk, position - chunk.length);
+                        }
+                        else {
+                            this.fileManager.append(url, chunk, position);
+                        }
                     }
                     else {
                         this.fileManager.setPosition(url, position);
                     }
                 }
-                if (!requestResolved && url === fileUrl && offsets && position > offsets.endByte) {
+                else {
+                    // The full empty file including with first chunk have been stored to fileManager
+                    // by the worker listener in the file promise.
+                    // So, we check whether the cache exceeded the limit here.
+                    if (this.fileManager.getTotalSize() > this.options.maxCacheSize) {
+                        this.fileManager.decacheNecessaryBytes(url, totalLength);
+                    }
+                }
+                if (!requestResolved && url === fileUrl && position > offsets.endByte) {
                     try {
-                        const file = this.fileManager.get(url, offsets);
-                        requestResolved = true;
+                        const file = this.options.enableLocalCache
+                            ? this.files[url].slice(offsets.startByte, offsets.endByte)
+                            : this.fileManager.get(url, offsets);
                         resolveRequest(file?.buffer);
                     }
                     catch (error) {
                         rejectRequest(error);
                     }
+                    finally {
+                        completeRequest(url);
+                    }
+                }
+            };
+            const completeRequest = (url) => {
+                requestResolved = true;
+                this.filePromises[url].requestCount--;
+                dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleChunkAppend);
+                if (fileFetchingCompleted && this.filePromises[url] && !this.filePromises[url]?.requestCount) {
+                    delete this.filePromises[url];
+                    delete this.files[url];
                 }
             };
             if (offsets && !isBytesOptimized) {
@@ -276,10 +308,19 @@ class CodDicomWebServer {
             }
             tarPromise
                 .then(() => {
+                fileFetchingCompleted = true;
                 if (!requestResolved) {
-                    if (this.fileManager.getPosition(fileUrl)) {
-                        const file = this.fileManager.get(fileUrl, isBytesOptimized ? undefined : offsets);
-                        requestResolved = true;
+                    if (this.fileManager.getPosition(fileUrl) || this.files[fileUrl]) {
+                        let file;
+                        if (this.options.enableLocalCache) {
+                            file =
+                                isBytesOptimized || !offsets
+                                    ? this.files[fileUrl]
+                                    : this.files[fileUrl].slice(offsets.startByte, offsets.endByte);
+                        }
+                        else {
+                            file = this.fileManager.get(fileUrl, isBytesOptimized ? undefined : offsets);
+                        }
                         resolveRequest(file?.buffer);
                     }
                     else {
@@ -288,10 +329,11 @@ class CodDicomWebServer {
                 }
             })
                 .catch((error) => {
+                fileFetchingCompleted = true;
                 rejectRequest(error);
             })
-                .then(() => {
-                dataRetrievalManager.removeEventListener(FILE_STREAMING_WORKER_NAME, 'message', handleChunkAppend);
+                .finally(() => {
+                completeRequest(fileUrl);
             });
         });
     }

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

@@ -11,6 +11,7 @@ export declare class CustomMessageEvent extends MessageEvent<{
     chunk?: Uint8Array;
     isAppending?: boolean;
     fileArraybuffer?: Uint8Array;
+    totalLength: number;
     offsets?: {
         startByte: number;
         endByte: number;

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

@@ -8,7 +8,7 @@ declare class DataRetrievalManager {
     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>;
+    executeTask(loaderName: string, taskName: string, options: Record<string, unknown> | unknown): Promise<any>;
     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;

package/dist/esm/dataRetrieval/dataRetrievalManager.js

@@ -49,6 +49,7 @@ class DataRetrievalManager {
     }
 }
 const dataRetrievalManager = new DataRetrievalManager();
+Object.freeze(dataRetrievalManager);
 export function getDataRetrievalManager() {
     return dataRetrievalManager;
 }

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

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

package/dist/esm/dataRetrieval/register.js

@@ -2,7 +2,7 @@ import { Enums } from '../constants';
 import { getDataRetrievalManager } from './dataRetrievalManager';
 import filePartial from './scripts/filePartial';
 import fileStreaming from './scripts/fileStreaming';
-export function register(workerNames, maxFetchSize) {
+export function register(workerNames) {
     const { fileStreamingScriptName, filePartialScriptName } = workerNames;
     const dataRetrievalManager = getDataRetrievalManager();
     if (dataRetrievalManager.getDataRetrieverMode() === Enums.DataRetrieveMode.REQUEST) {
@@ -21,5 +21,4 @@ export function register(workerNames, maxFetchSize) {
         });
         dataRetrievalManager.register(filePartialScriptName, partialWorkerFn);
     }
-    dataRetrievalManager.executeTask(fileStreamingScriptName, 'setMaxFetchSize', maxFetchSize);
 }

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

@@ -4,7 +4,7 @@ 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>;
+    executeTask(loaderName: string, taskName: string, options: Record<string, unknown> | unknown): Promise<any>;
     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;

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

@@ -14,6 +14,6 @@ declare const filePartial: {
             startByte: number;
             endByte: number;
         };
-    }) => void): Promise<void | Error>;
+    }) => void): Promise<Uint8Array | Error>;
 };
 export default filePartial;

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

@@ -10,17 +10,20 @@ const filePartial = {
         if (directoryHandle) {
             const file = (await readFile(directoryHandle, storageName, { offsets, isJson: false }));
             if (file) {
-                callBack({ url, fileArraybuffer: new Uint8Array(file), offsets });
-                return;
+                const fileBuffer = new Uint8Array(file);
+                callBack({ url, fileArraybuffer: fileBuffer, offsets });
+                return fileBuffer;
             }
         }
-        await fetch(url, { headers })
+        return await fetch(url, { headers })
             .then((response) => response.arrayBuffer())
             .then((data) => {
-            callBack({ url, fileArraybuffer: new Uint8Array(data), offsets });
+            const fileBuffer = new Uint8Array(data);
+            callBack({ url, fileArraybuffer: fileBuffer, offsets });
             if (directoryHandle) {
                 writeFile(directoryHandle, storageName, data);
             }
+            return fileBuffer;
         })
             .catch((error) => {
             throw new CustomError('filePartial.ts: Error when fetching file: ' + error?.message);

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

@@ -1,8 +1,4 @@
 declare const fileStreaming: {
-    maxFetchSize: number;
-    fetchedSize: number;
-    setMaxFetchSize(size: number): void;
-    decreaseFetchedSize(size: number): void;
     stream(args: {
         url: string;
         headers?: Record<string, string>;
@@ -14,6 +10,7 @@ declare const fileStreaming: {
         isAppending?: boolean;
         fileArraybuffer?: Uint8Array;
         chunk?: Uint8Array;
+        totalLength: number;
     }) => void): Promise<Uint8Array | void>;
 };
 export default fileStreaming;

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

@@ -1,18 +1,6 @@
 import { CustomError } from '../../classes/customClasses';
 import { createStreamingFileName, readFile, writeFile } from '../../fileAccessSystemUtils';
 const fileStreaming = {
-    maxFetchSize: 4 * 1024 * 1024 * 1024,
-    fetchedSize: 0,
-    setMaxFetchSize(size) {
-        if (size > 0) {
-            this.maxFetchSize = size;
-        }
-    },
-    decreaseFetchedSize(size) {
-        if (size > 0 && size <= this.fetchedSize) {
-            this.fetchedSize -= size;
-        }
-    },
     async stream(args, callBack) {
         const { url, headers, useSharedArrayBuffer, directoryHandle } = args;
         const controller = new AbortController();
@@ -23,8 +11,10 @@ const fileStreaming = {
             if (directoryHandle) {
                 const file = (await readFile(directoryHandle, fileName, { isJson: false }));
                 if (file) {
-                    callBack({ url, position: file.byteLength, fileArraybuffer: new Uint8Array(file) });
-                    return;
+                    const totalLength = file.byteLength;
+                    const fileBuffer = new Uint8Array(file);
+                    callBack({ url, position: totalLength, fileArraybuffer: fileBuffer, totalLength });
+                    return fileBuffer;
                 }
             }
             const response = await fetch(url, {
@@ -48,11 +38,6 @@ const fileStreaming = {
             }
             if (!completed) {
                 let position = firstChunk.value.length;
-                if (this.fetchedSize + position > this.maxFetchSize) {
-                    controller.abort();
-                    throw new CustomError(`Maximum size(${this.maxFetchSize}) for fetching files reached`);
-                }
-                this.fetchedSize += position;
                 if (useSharedArrayBuffer) {
                     sharedArraybuffer = new SharedArrayBuffer(totalLength);
                     fileArraybuffer = new Uint8Array(sharedArraybuffer);
@@ -61,7 +46,7 @@ const fileStreaming = {
                     fileArraybuffer = new Uint8Array(totalLength);
                 }
                 fileArraybuffer.set(firstChunk.value);
-                callBack({ url, position, fileArraybuffer });
+                callBack({ url, position, fileArraybuffer, totalLength });
                 while (!completed) {
                     result = await reader.read();
                     if (result.done) {
@@ -69,26 +54,21 @@ const fileStreaming = {
                         continue;
                     }
                     const chunk = result.value;
-                    if (this.fetchedSize + chunk.length > this.maxFetchSize) {
-                        sharedArraybuffer = null;
-                        fileArraybuffer = null;
-                        controller.abort();
-                        throw new CustomError(`Maximum size(${this.maxFetchSize}) for fetching files reached`);
-                    }
-                    this.fetchedSize += chunk.length;
                     fileArraybuffer.set(chunk, position);
                     position += chunk.length;
                     callBack({
                         isAppending: true,
                         url,
                         position: position,
-                        chunk: !useSharedArrayBuffer ? chunk : undefined
+                        chunk: !useSharedArrayBuffer ? chunk : undefined,
+                        totalLength
                     });
                 }
                 if (directoryHandle) {
                     writeFile(directoryHandle, fileName, fileArraybuffer.slice().buffer);
                 }
             }
+            return fileArraybuffer;
         }
         catch (error) {
             const streamingError = new CustomError('fileStreaming.ts: ' + error.message || 'An error occured when streaming');

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

@@ -2,7 +2,7 @@ import { CustomErrorEvent, CustomMessageEvent } from '../classes/customClasses';
 declare class WebWorkerManager {
     private workerRegistry;
     register(name: string, workerFn: () => Worker): void;
-    executeTask(workerName: string, taskName: string, options: Record<string, unknown> | unknown): Promise<void>;
+    executeTask(workerName: string, taskName: string, options: Record<string, unknown> | unknown): Promise<any>;
     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;

package/dist/esm/fileManager.d.ts

@@ -1,12 +1,7 @@
-import type { FileManagerOptions } from './types';
+import type { FileManagerFile } from './types';
 declare class FileManager {
     private files;
-    private fileStreamingScriptName;
-    constructor({ fileStreamingScriptName }: FileManagerOptions);
-    set(url: string, file: {
-        data: Uint8Array;
-        position: number;
-    }): void;
+    set(url: string, file: Omit<FileManagerFile, 'lastModified'>): void;
     get(url: string, offsets?: {
         startByte: number;
         endByte: number;
@@ -17,5 +12,6 @@ declare class FileManager {
     getTotalSize(): number;
     remove(url: string): void;
     purge(): void;
+    decacheNecessaryBytes(url: string, bytesNeeded: number): number;
 }
 export default FileManager;

package/dist/esm/fileManager.js

@@ -1,12 +1,7 @@
-import { getDataRetrievalManager } from './dataRetrieval/dataRetrievalManager';
 class FileManager {
     files = {};
-    fileStreamingScriptName;
-    constructor({ fileStreamingScriptName }) {
-        this.fileStreamingScriptName = fileStreamingScriptName;
-    }
     set(url, file) {
-        this.files[url] = file;
+        this.files[url] = { ...file, lastModified: Date.now() };
     }
     get(url, offsets) {
         if (!this.files[url] || (offsets && this.files[url].position <= offsets.endByte)) {
@@ -17,6 +12,7 @@ class FileManager {
     setPosition(url, position) {
         if (this.files[url]) {
             this.files[url].position = position;
+            this.files[url].lastModified = Date.now();
         }
     }
     getPosition(url) {
@@ -29,24 +25,40 @@ class FileManager {
         }
     }
     getTotalSize() {
-        return Object.entries(this.files).reduce((total, [url, { position }]) => {
-            return url.includes('?bytes=') ? total : total + position;
+        return Object.values(this.files).reduce((total, { data }) => {
+            return total + data.byteLength;
         }, 0);
     }
     remove(url) {
-        const removedSize = this.getPosition(url);
-        delete this.files[url];
-        if (url.includes('?bytes=')) {
-            return;
+        try {
+            delete this.files[url];
+            console.log(`Removed ${url} from CodDicomwebServer cache`);
+        }
+        catch (error) {
+            console.warn(`Error removing ${url} from CodDicomwebServer cache:`, error);
         }
-        const retrievalManager = getDataRetrievalManager();
-        retrievalManager.executeTask(this.fileStreamingScriptName, 'decreaseFetchedSize', removedSize);
     }
     purge() {
+        const fileURLs = Object.keys(this.files);
+        const totalSize = this.getTotalSize();
+        fileURLs.forEach((url) => this.remove(url));
+        console.log(`Purged ${totalSize - this.getTotalSize()} bytes from CodDicomwebServer cache`);
+    }
+    decacheNecessaryBytes(url, bytesNeeded) {
         const totalSize = this.getTotalSize();
-        this.files = {};
-        const retrievalManager = getDataRetrievalManager();
-        retrievalManager.executeTask(this.fileStreamingScriptName, 'decreaseFetchedSize', totalSize);
+        const filesToDelete = [];
+        let collectiveSize = 0;
+        Object.entries(this.files)
+            .sort(([, a], [, b]) => a.lastModified - b.lastModified)
+            .forEach(([key, file]) => {
+            if (collectiveSize < bytesNeeded && key !== url) {
+                filesToDelete.push(key);
+                collectiveSize += file.data.byteLength;
+            }
+        });
+        filesToDelete.forEach((key) => this.remove(key));
+        console.log(`Decached ${totalSize - this.getTotalSize()} bytes`);
+        return collectiveSize;
     }
 }
 export default FileManager;

package/dist/esm/types/codDicomWebServerOptions.d.ts

@@ -1,6 +1,6 @@
 type CodDicomWebServerOptions = {
     [key: string]: number | string | boolean;
-    maxWorkerFetchSize: number;
+    maxCacheSize: number;
     domain: string;
     enableLocalCache: boolean;
 };

package/dist/esm/types/fileManagerFile.d.ts

@@ -0,0 +1,6 @@
+type FileManagerFile = {
+    data: Uint8Array;
+    position: number;
+    lastModified: number;
+};
+export type { FileManagerFile };

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

@@ -1,5 +1,5 @@
 export * from './codDicomWebServerOptions';
-export * from './fileManagerOptions';
+export * from './fileManagerFile';
 export * from './metadata';
 export * from './metadataUrlCreationParams';
 export * from './parsedWadoRsUrlDetails';

package/dist/esm/types/index.js

@@ -1,5 +1,5 @@
 export * from './codDicomWebServerOptions';
-export * from './fileManagerOptions';
+export * from './fileManagerFile';
 export * from './metadata';
 export * from './metadataUrlCreationParams';
 export * from './parsedWadoRsUrlDetails';