cod-dicomweb-server 1.0.0 → 1.0.2

package/dist/classes/CodDicomWebServer.ts

@@ -1,423 +0,0 @@
-import { parseDicom } from 'dicom-parser';
-
-import FileManager from '../fileManager';
-import { getMetadata } from '../metadataManager';
-import { getFrameDetailsFromMetadata, parseWadorsURL } from './utils';
-import { getWebWorkerManager } from '../webWorker/workerManager';
-import { registerWorkers } from '../webWorker/registerWorker';
-import constants, { Enums } from '../constants';
-import type {
-  CodDicomWebServerOptions,
-  InstanceMetadata,
-  JsonMetadata,
-  SeriesMetadata,
-  CODRequestOptions,
-  FileRequestOptions,
-  FileStreamingMessageEvent,
-} from '../types';
-
-class CodDicomWebServer {
-  private filePromises: Record<string, Promise<void>> = {};
-  private options: CodDicomWebServerOptions = {
-    maxWorkerFetchSize: Infinity,
-    domain: constants.url.DOMAIN,
-  };
-  private fileManager;
-  private seriesUidFileUrls: Record<string, string[]> = {};
-
-  constructor(args: { maxWorkerFetchSize?: number; domain?: string }) {
-    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 });
-
-    registerWorkers(
-      { fileStreamingWorkerName, filePartialWorkerName },
-      this.options.maxWorkerFetchSize,
-    );
-  }
-
-  public setOptions = (newOptions: CodDicomWebServerOptions): void => {
-    Object.keys(newOptions).forEach((key) => {
-      if (!newOptions[key] === undefined) {
-        this.options[key] = newOptions[key];
-      }
-    });
-  };
-
-  public getOptions = (): CodDicomWebServerOptions => {
-    return this.options;
-  };
-
-  private addFileUrl(seriesInstanceUID: string, url: string): void {
-    if (this.seriesUidFileUrls[seriesInstanceUID]) {
-      this.seriesUidFileUrls[seriesInstanceUID].push(url);
-    } else {
-      this.seriesUidFileUrls[seriesInstanceUID] = [url];
-    }
-  }
-
-  public async fetchCod(
-    wadorsUrl: string,
-    imageId: string,
-    headers: Record<string, string> | undefined = {},
-    { useSharedArrayBuffer, fetchType }: CODRequestOptions = {},
-  ): Promise<ArrayBufferLike | InstanceMetadata | SeriesMetadata | undefined> {
-    try {
-      const parsedDetails = parseWadorsURL(wadorsUrl, this.options.domain);
-
-      if (parsedDetails) {
-        const {
-          type,
-          bucketName,
-          bucketPrefix,
-          studyInstanceUID,
-          seriesInstanceUID,
-          sopInstanceUID,
-          frameNumber,
-        } = parsedDetails;
-
-        const metadataJson = await 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:
-            this.addFileUrl(seriesInstanceUID, thumbnailUrl);
-
-            return this.fetchFile(thumbnailUrl, headers, {
-              useSharedArrayBuffer,
-            });
-
-          case Enums.RequestType.FRAME: {
-            let urlWithBytes: string = 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');
-
-                  !!seriesInstanceUID &&
-                    this.addFileUrl(seriesInstanceUID, wadorsUrl);
-                } catch (error) {
-                  console.warn('There is some issue parsing the file.', error);
-                }
-              }
-              resolve(result);
-            })
-            .catch((error) => reject(error));
-        });
-      }
-    } catch (error) {
-      console.error(error);
-      throw error;
-    }
-  }
-
-  public async fetchFile(
-    fileUrl: string,
-    headers: Record<string, string>,
-    {
-      offsets,
-      useSharedArrayBuffer = false,
-      fetchType = constants.Enums.FetchType.API_OPTIMIZED,
-    }: FileRequestOptions = {},
-  ): Promise<ArrayBufferLike | undefined> {
-    const isBytesOptimized = fetchType === Enums.FetchType.BYTES_OPTIMIZED;
-    const extractedFile = this.fileManager.get(
-      fileUrl,
-      isBytesOptimized ? undefined : offsets,
-    );
-
-    if (extractedFile) {
-      return new Promise<ArrayBufferLike>((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: Promise<void>;
-
-    if (!this.filePromises[fileUrl]) {
-      tarPromise = new Promise<void>((resolveFile, rejectFile) => {
-        if (this.fileManager.getTotalSize() + THRESHOLD > maxWorkerFetchSize) {
-          throw new Error(
-            `fileStreaming.ts: Maximum size(${maxWorkerFetchSize}) for fetching files reached`,
-          );
-        }
-
-        const FetchTypeEnum = constants.Enums.FetchType;
-
-        if (fetchType === FetchTypeEnum.API_OPTIMIZED) {
-          const handleFirstChunk = (
-            evt: FileStreamingMessageEvent | ErrorEvent,
-          ): void => {
-            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('Offsets is needed in bytes optimized fetching');
-        }
-      });
-
-      this.filePromises[fileUrl] = tarPromise;
-    } else {
-      tarPromise = this.filePromises[fileUrl];
-    }
-
-    return new Promise<ArrayBufferLike | undefined>(
-      (resolveRequest, rejectRequest) => {
-        let requestResolved = false;
-
-        const handleChunkAppend = (
-          evt: FileStreamingMessageEvent | ErrorEvent,
-        ): void => {
-          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,
-            );
-          });
-      },
-    );
-  }
-
-  public delete(seriesInstanceUID: string): void {
-    const fileUrls = this.seriesUidFileUrls[seriesInstanceUID];
-    if (fileUrls) {
-      fileUrls.forEach((fileUrl) => {
-        this.fileManager.remove(fileUrl);
-      });
-    }
-    delete this.seriesUidFileUrls[seriesInstanceUID];
-  }
-
-  public deleteAll(): void {
-    Object.values(this.seriesUidFileUrls).forEach((fileUrls) => {
-      fileUrls.forEach((fileUrl) => {
-        this.fileManager.remove(fileUrl);
-      });
-    });
-    this.seriesUidFileUrls = {};
-  }
-
-  public parseMetadata(
-    metadata: JsonMetadata,
-    type: Enums.RequestType,
-    sopInstanceUID: string,
-  ): InstanceMetadata | SeriesMetadata {
-    if (type === Enums.RequestType.INSTANCE_METADATA) {
-      return metadata.cod.instances[sopInstanceUID].metadata;
-    } else {
-      return Object.values(metadata.cod.instances).map(
-        (instance) => instance.metadata,
-      );
-    }
-  }
-}
-
-export default CodDicomWebServer;

package/dist/classes/utils.ts

@@ -1,176 +0,0 @@
-import constants, { Enums } from '../constants';
-import type {
-  JsonMetadata,
-  MetadataUrlCreationParams,
-  ParsedWadoRsUrlDetails,
-} from '../types';
-
-export function parseWadorsURL(
-  url: string,
-  domain: string,
-): ParsedWadoRsUrlDetails | undefined {
-  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: Enums.RequestType;
-
-  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] || frameNumber);
-      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: JsonMetadata,
-  sopInstanceUID: string,
-  frameIndex: number,
-  bucketDetails: { domain: string; bucketName: string; bucketPrefix: string },
-): {
-  url: string;
-  startByte: number;
-  endByte: number;
-  thumbnailUrl: string;
-  isMultiframe: boolean;
-} {
-  if (
-    !seriesMetadata ||
-    !seriesMetadata.cod?.instances ||
-    !seriesMetadata.thumbnail
-  ) {
-    throw new Error('Invalid seriesMetadata provided.');
-  }
-
-  if (!sopInstanceUID) {
-    throw new Error('SOP Instance UID is required.');
-  }
-
-  if (frameIndex === null || frameIndex === undefined) {
-    throw new Error('Frame index is required.');
-  }
-
-  const instanceFound = Object.values(seriesMetadata.cod.instances).find(
-    (instance) => instance.metadata['00080018']?.Value?.[0] === sopInstanceUID,
-  );
-
-  if (!instanceFound) {
-    throw new Error(
-      `Instance with SOPInstanceUID ${sopInstanceUID} not found.`,
-    );
-  }
-
-  const { domain, bucketName, bucketPrefix } = bucketDetails;
-  const { url, uri, headers: offsetHeaders, offset_tables } = instanceFound;
-  const modifiedUrl = handleUrl(url || uri, domain, bucketName, bucketPrefix);
-
-  const { CustomOffsetTable, CustomOffsetTableLengths } = offset_tables || {};
-
-  let sliceStart: number | undefined,
-    sliceEnd: number | undefined,
-    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;
-
-  const thumbnailGsUtilUri = seriesMetadata.thumbnail.uri;
-  const thumbnailUrl = `${domain}/${thumbnailGsUtilUri.split('gs://')[1]}`;
-
-  return {
-    url: modifiedUrl,
-    startByte,
-    endByte,
-    thumbnailUrl,
-    isMultiframe,
-  };
-}
-
-export function handleUrl(
-  url: string,
-  domain: string,
-  bucketName: string,
-  bucketPrefix: string,
-): string {
-  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: MetadataUrlCreationParams,
-): string | undefined {
-  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/constants/enums.ts

@@ -1,18 +0,0 @@
-export enum FetchType {
-  /**
-   * Fetch only the part of the file according to the offsets provided.
-   */
-  BYTES_OPTIMIZED,
-  /**
-   * Stream the file and returns the part of the file if offsets are provided.
-   * Or returns the whole file.
-   */
-  API_OPTIMIZED,
-}
-
-export enum RequestType {
-  FRAME,
-  THUMBNAIL,
-  SERIES_METADATA,
-  INSTANCE_METADATA,
-}

package/dist/constants/index.ts

@@ -1,8 +0,0 @@
-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/constants/url.ts

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

package/dist/constants/worker.ts

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