cod-dicomweb-server 1.3.10 → 1.3.12

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

@@ -7,7 +7,7 @@ declare class CodDicomWebServer {
     private metadataManager;
     private seriesUidFileUrls;
     constructor(args?: {
-        maxWorkerFetchSize?: number;
+        maxCacheSize?: number;
         domain?: string;
         disableWorker?: boolean;
         enableLocalCache?: boolean;

package/dist/esm/classes/CodDicomWebServer.js

@@ -11,7 +11,7 @@ import { download, getDirectoryHandle } from '../fileAccessSystemUtils';
 class CodDicomWebServer {
     filePromises = {};
     options = {
-        maxWorkerFetchSize: Infinity,
+        maxCacheSize: 4 * 1024 * 1024 * 1024,
         domain: constants.url.DOMAIN,
         enableLocalCache: false
     };
@@ -19,19 +19,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) => {
@@ -110,10 +110,6 @@ class CodDicomWebServer {
                                 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);
                             }
                         });
@@ -167,15 +163,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) => {
@@ -255,7 +247,7 @@ class CodDicomWebServer {
                     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);
@@ -264,6 +256,14 @@ class CodDicomWebServer {
                         this.fileManager.setPosition(url, position);
                     }
                 }
+                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 && offsets && position > offsets.endByte) {
                     try {
                         const file = this.fileManager.get(url, offsets);

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/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/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,7 +11,8 @@ const fileStreaming = {
             if (directoryHandle) {
                 const file = (await readFile(directoryHandle, fileName, { isJson: false }));
                 if (file) {
-                    callBack({ url, position: file.byteLength, fileArraybuffer: new Uint8Array(file) });
+                    const totalLength = file.byteLength;
+                    callBack({ url, position: totalLength, fileArraybuffer: new Uint8Array(file), totalLength });
                     return;
                 }
             }
@@ -48,11 +37,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 +45,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,20 +53,14 @@ 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) {

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';

package/dist/umd/563.js

@@ -1,6 +1,6 @@
 /*!
  * 
- * cod-dicomweb-server v1.3.10
+ * cod-dicomweb-server v1.3.12
  * git+https://github.com/gradienthealth/cod-dicomweb-server.git
  *
  *   Copyright (c) Adithyan Dinesh and project contributors.