@ohif/app 3.8.0-beta.5 → 3.8.0-beta.51

package/dist/{342.bundle.22d2df5cf6d83b24acee.js → 738.bundle.bf1d2c76e385a091999d.js}

@@ -1,7 +1,7 @@
 "use strict";
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[342],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[738],{
 
-/***/ 56342:
+/***/ 78738:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -179,8 +179,7 @@ function searchStudies(server, filter) {
  * @param serverSupportsQIDOIncludeField
  * @returns {string} The URL with encoded filter query data
  */
-function mapParams(params) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function mapParams(params, options = {}) {
   if (!params) {
     return;
   }
@@ -354,13 +353,12 @@ function buildInstanceWadoUrl(config, instance) {
  * @param thumbnail
  * @returns {string} The imageId to be used by Cornerstone
  */
-function getImageId(_ref) {
-  let {
-    instance,
-    frame,
-    config,
-    thumbnail = false
-  } = _ref;
+function getImageId({
+  instance,
+  frame,
+  config,
+  thumbnail = false
+}) {
   if (!instance) {
     return;
   }
@@ -395,13 +393,11 @@ class RetrieveMetadataLoader {
    * @param {Object} client The dicomweb-client.
    * @param {Array} studyInstanceUID Study instance ui to be retrieved
    * @param {Object} [filters] - Object containing filters to be applied on retrieve metadata process
-   * @param {string} [filter.seriesInstanceUID] - series instance uid to filter results against
-   * @param {Function} [sortSeries] - Custom sort function for series
+   * @param {string} [filters.seriesInstanceUID] - series instance uid to filter results against
+   * @param {Object} [sortCriteria] - Custom sort criteria used for series
+   * @param {Function} [sortFunction] - Custom sort function for series
    */
-  constructor(client, studyInstanceUID) {
-    let filters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    let sortCriteria = arguments.length > 3 ? arguments[3] : undefined;
-    let sortFunction = arguments.length > 4 ? arguments[4] : undefined;
+  constructor(client, studyInstanceUID, filters = {}, sortCriteria = undefined, sortFunction = undefined) {
     this.client = client;
     this.studyInstanceUID = studyInstanceUID;
     this.filters = filters;
@@ -422,13 +418,9 @@ class RetrieveMetadataLoader {
   async runLoaders(loaders) {
     let result;
     for (const loader of loaders) {
-      try {
-        result = await loader();
-        if (result && result.length) {
-          break; // closes iterator in case data is retrieved successfully
-        }
-      } catch (e) {
-        throw e;
+      result = await loader();
+      if (result && result.length) {
+        break; // closes iterator in case data is retrieved successfully
       }
     }
     if (loaders.next().done && !result) {
@@ -511,11 +503,64 @@ class RetrieveMetadataLoaderSync extends RetrieveMetadataLoader {
 
 
 
+// Series Date, Series Time, Series Description and Series Number to be included
+// in the series metadata query result
+const includeField = ['00080021', '00080031', '0008103E', '00200011'].join(',');
+class DeferredPromise {
+  constructor() {
+    this.metadata = undefined;
+    this.processFunction = undefined;
+    this.internalPromise = undefined;
+    this.thenFunction = undefined;
+    this.rejectFunction = undefined;
+  }
+  setMetadata(metadata) {
+    this.metadata = metadata;
+  }
+  setProcessFunction(func) {
+    this.processFunction = func;
+  }
+  getPromise() {
+    return this.start();
+  }
+  start() {
+    if (this.internalPromise) {
+      return this.internalPromise;
+    }
+    this.internalPromise = this.processFunction();
+    // in case then and reject functions called before start
+    if (this.thenFunction) {
+      this.then(this.thenFunction);
+      this.thenFunction = undefined;
+    }
+    if (this.rejectFunction) {
+      this.reject(this.rejectFunction);
+      this.rejectFunction = undefined;
+    }
+    return this.internalPromise;
+  }
+  then(func) {
+    if (this.internalPromise) {
+      return this.internalPromise.then(func);
+    } else {
+      this.thenFunction = func;
+    }
+  }
+  reject(func) {
+    if (this.internalPromise) {
+      return this.internalPromise.reject(func);
+    } else {
+      this.rejectFunction = func;
+    }
+  }
+}
 /**
- * Creates an immutable series loader object which loads each series sequentially using the iterator interface
+ * Creates an immutable series loader object which loads each series sequentially using the iterator interface.
+ *
  * @param {DICOMWebClient} dicomWebClient The DICOMWebClient instance to be used for series load
  * @param {string} studyInstanceUID The Study Instance UID from which series will be loaded
  * @param {Array} seriesInstanceUIDList A list of Series Instance UIDs
+ *
  * @returns {Object} Returns an object which supports loading of instances from each of given Series Instance UID
  */
 function makeSeriesAsyncLoader(client, studyInstanceUID, seriesInstanceUIDList) {
@@ -523,12 +568,20 @@ function makeSeriesAsyncLoader(client, studyInstanceUID, seriesInstanceUIDList)
     hasNext() {
       return seriesInstanceUIDList.length > 0;
     },
-    async next() {
-      const seriesInstanceUID = seriesInstanceUIDList.shift();
-      return client.retrieveSeriesMetadata({
-        studyInstanceUID,
-        seriesInstanceUID
+    next() {
+      const {
+        seriesInstanceUID,
+        metadata
+      } = seriesInstanceUIDList.shift();
+      const promise = new DeferredPromise();
+      promise.setMetadata(metadata);
+      promise.setProcessFunction(() => {
+        return client.retrieveSeriesMetadata({
+          studyInstanceUID,
+          seriesInstanceUID
+        });
       });
+      return promise;
     }
   });
 }
@@ -552,19 +605,22 @@ class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader {
       } = {},
       client
     } = this;
+
+    // asking to include Series Date, Series Time, Series Description
+    // and Series Number in the series metadata returned to better sort series
+    // in preLoad function
+    let options = {
+      studyInstanceUID,
+      queryParams: {
+        includefield: includeField
+      }
+    };
     if (seriesInstanceUID) {
-      const options = {
-        studyInstanceUID,
-        queryParams: {
-          SeriesInstanceUID: seriesInstanceUID
-        }
-      };
+      options.queryParams.SeriesInstanceUID = seriesInstanceUID;
       preLoaders.push(client.searchForSeries.bind(client, options));
     }
     // Fallback preloader
-    preLoaders.push(client.searchForSeries.bind(client, {
-      studyInstanceUID
-    }));
+    preLoaders.push(client.searchForSeries.bind(client, options));
     yield* preLoaders;
   }
   async preLoad() {
@@ -576,29 +632,34 @@ class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader {
       naturalizeDataset
     } = dcmjs_es["default"].data.DicomMetaDictionary;
     const naturalized = result.map(naturalizeDataset);
-    return (0,sortStudy/* sortStudySeries */.IO)(naturalized, sortCriteria || sortStudy/* sortingCriteria */.S1.seriesSortCriteria.seriesInfoSortingCriteria, sortFunction);
+    return (0,sortStudy/* sortStudySeries */.IO)(naturalized, sortCriteria, sortFunction);
   }
   async load(preLoadData) {
     const {
       client,
       studyInstanceUID
     } = this;
-    const seriesInstanceUIDs = preLoadData.map(s => s.SeriesInstanceUID);
+    const seriesInstanceUIDs = preLoadData.map(seriesMetadata => {
+      return {
+        seriesInstanceUID: seriesMetadata.SeriesInstanceUID,
+        metadata: seriesMetadata
+      };
+    });
     const seriesAsyncLoader = makeSeriesAsyncLoader(client, studyInstanceUID, seriesInstanceUIDs);
     const promises = [];
     while (seriesAsyncLoader.hasNext()) {
-      promises.push(seriesAsyncLoader.next());
+      const promise = seriesAsyncLoader.next();
+      promises.push(promise);
     }
     return {
       preLoadData,
       promises
     };
   }
-  async posLoad(_ref) {
-    let {
-      preLoadData,
-      promises
-    } = _ref;
+  async posLoad({
+    preLoadData,
+    promises
+  }) {
     return {
       preLoadData,
       promises
@@ -613,40 +674,91 @@ class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader {
  * Retrieve Study metadata from a DICOM server. If the server is configured to use lazy load, only the first series
  * will be loaded and the property "studyLoader" will be set to let consumer load remaining series as needed.
  *
- * @param {Object} dicomWebClient The dicomweb-client.
- * @param {string} studyInstanceUid The Study Instance UID of the study which needs to be loaded
- * @param {Object} [filters] - Object containing filters to be applied on retrieve metadata process
- * @param {string} [filter.seriesInstanceUID] - series instance uid to filter results against
- * @returns {Object} A study descriptor object
+ * @param {*} dicomWebClient The DICOMWebClient instance to be used for series load
+ * @param {*} StudyInstanceUID The UID of the Study to be retrieved
+ * @param {*} enableStudyLazyLoad Whether the study metadata should be loaded asynchronously
+ * @param {object} filters Object containing filters to be applied on retrieve metadata process
+ * @param {string} [filters.seriesInstanceUID] Series instance uid to filter results against
+ * @param {array} [filters.SeriesInstanceUIDs] Series instance uids to filter results against
+ * @param {function} [sortCriteria] Sort criteria function
+ * @param {function} [sortFunction] Sort function
+ *
+ * @returns {Promise} A promises that resolves the study descriptor object
  */
-async function RetrieveMetadata(dicomWebClient, studyInstanceUid, enableStudyLazyLoad) {
-  let filters = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  let sortCriteria = arguments.length > 4 ? arguments[4] : undefined;
-  let sortFunction = arguments.length > 5 ? arguments[5] : undefined;
+async function RetrieveMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters = {}, sortCriteria, sortFunction) {
   const RetrieveMetadataLoader = enableStudyLazyLoad !== false ? RetrieveMetadataLoaderAsync : RetrieveMetadataLoaderSync;
-  const retrieveMetadataLoader = new RetrieveMetadataLoader(dicomWebClient, studyInstanceUid, filters, sortCriteria, sortFunction);
+  const retrieveMetadataLoader = new RetrieveMetadataLoader(dicomWebClient, StudyInstanceUID, filters, sortCriteria, sortFunction);
   const data = await retrieveMetadataLoader.execLoad();
   return data;
 }
 /* harmony default export */ const retrieveMetadata = (RetrieveMetadata);
+;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/utils/retrieveMetadataFiltered.js
+
+
+/**
+ * Retrieve metadata filtered.
+ *
+ * @param {*} dicomWebClient The DICOMWebClient instance to be used for series load
+ * @param {*} StudyInstanceUID The UID of the Study to be retrieved
+ * @param {*} enableStudyLazyLoad Whether the study metadata should be loaded asynchronously
+ * @param {object} filters Object containing filters to be applied on retrieve metadata process
+ * @param {string} [filters.seriesInstanceUID] Series instance uid to filter results against
+ * @param {array} [filters.SeriesInstanceUIDs] Series instance uids to filter results against
+ * @param {function} [sortCriteria] Sort criteria function
+ * @param {function} [sortFunction] Sort function
+ *
+ * @returns
+ */
+function retrieveMetadataFiltered(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction) {
+  const {
+    SeriesInstanceUIDs
+  } = filters;
+  return new Promise((resolve, reject) => {
+    const promises = SeriesInstanceUIDs.map(uid => {
+      const seriesSpecificFilters = Object.assign({}, filters, {
+        seriesInstanceUID: uid
+      });
+      return retrieveMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, seriesSpecificFilters, sortCriteria, sortFunction);
+    });
+    Promise.all(promises).then(results => {
+      const aggregatedResult = {
+        preLoadData: [],
+        promises: []
+      };
+      results.forEach(({
+        preLoadData,
+        promises
+      }) => {
+        aggregatedResult.preLoadData = aggregatedResult.preLoadData.concat(preLoadData);
+        aggregatedResult.promises = aggregatedResult.promises.concat(promises);
+      });
+      resolve(aggregatedResult);
+    }, reject);
+  });
+}
+/* harmony default export */ const utils_retrieveMetadataFiltered = (retrieveMetadataFiltered);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/retrieveStudyMetadata.js
 
+
 const moduleName = 'RetrieveStudyMetadata';
 // Cache for promises. Prevents unnecessary subsequent calls to the server
 const StudyMetaDataPromises = new Map();
 
 /**
- * Retrieves study metadata
+ * Retrieves study metadata.
  *
- * @param {Object} server Object with server configuration parameters
+ * @param {Object} dicomWebClient The DICOMWebClient instance to be used for series load
  * @param {string} StudyInstanceUID The UID of the Study to be retrieved
- * @param {boolean} enabledStudyLazyLoad Whether the study metadata should be loaded asynchronously.
- * @param {function} storeInstancesCallback A callback used to store the retrieved instance metadata.
- * @param {Object} [filters] - Object containing filters to be applied on retrieve metadata process
- * @param {string} [filter.seriesInstanceUID] - series instance uid to filter results against
+ * @param {boolean} enableStudyLazyLoad Whether the study metadata should be loaded asynchronously.
+ * @param {Object} [filters] Object containing filters to be applied on retrieve metadata process
+ * @param {string} [filters.seriesInstanceUID] Series instance uid to filter results against
+ * @param {array} [filters.SeriesInstanceUIDs] Series instance uids to filter results against
+ * @param {function} [sortCriteria] Sort criteria function
+ * @param {function} [sortFunction] Sort function
+ *
  * @returns {Promise} that will be resolved with the metadata or rejected with the error
  */
-function retrieveStudyMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction) {
+function retrieveStudyMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction, dicomWebConfig = {}) {
   // @TODO: Whenever a study metadata request has failed, its related promise will be rejected once and for all
   // and further requests for that metadata will always fail. On failure, we probably need to remove the
   // corresponding promise from the "StudyMetaDataPromises" map...
@@ -657,30 +769,34 @@ function retrieveStudyMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazy
   if (!StudyInstanceUID) {
     throw new Error(`${moduleName}: Required 'StudyInstanceUID' parameter not provided.`);
   }
+  const promiseId = `${dicomWebConfig.name}:${StudyInstanceUID}`;
 
   // Already waiting on result? Return cached promise
-  if (StudyMetaDataPromises.has(StudyInstanceUID)) {
-    return StudyMetaDataPromises.get(StudyInstanceUID);
+  if (StudyMetaDataPromises.has(promiseId)) {
+    return StudyMetaDataPromises.get(promiseId);
+  }
+  let promise;
+  if (filters && filters.SeriesInstanceUIDs) {
+    promise = utils_retrieveMetadataFiltered(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction);
+  } else {
+    // Create a promise to handle the data retrieval
+    promise = new Promise((resolve, reject) => {
+      retrieveMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction).then(function (data) {
+        resolve(data);
+      }, reject);
+    });
   }
-
-  // Create a promise to handle the data retrieval
-  const promise = new Promise((resolve, reject) => {
-    retrieveMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction).then(function (data) {
-      resolve(data);
-    }, reject);
-  });
 
   // Store the promise in cache
-  StudyMetaDataPromises.set(StudyInstanceUID, promise);
+  StudyMetaDataPromises.set(promiseId, promise);
   return promise;
 }
 
 /**
  * Delete the cached study metadata retrieval promise to ensure that the browser will
- * re-retrieve the study metadata when it is next requested
+ * re-retrieve the study metadata when it is next requested.
  *
  * @param {String} StudyInstanceUID The UID of the Study to be removed from cache
- *
  */
 function deleteStudyMetadataPromise(StudyInstanceUID) {
   if (StudyMetaDataPromises.has(StudyInstanceUID)) {
@@ -697,6 +813,7 @@ function deleteStudyMetadataPromise(StudyInstanceUID) {
  * performing searches doesn't work.  This version fixes the query issue
  * by manually implementing a query option.
  */
+
 class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
   constructor(qidoConfig) {
     super(qidoConfig);
@@ -841,8 +958,7 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
   /** Converts the query parameters to lower case query parameters */
   toLowerParams(queryParams) {
     const lowerParams = {};
-    Object.entries(queryParams).forEach(_ref => {
-      let [key, value] = _ref;
+    Object.entries(queryParams).forEach(([key, value]) => {
       lowerParams[key.toLowerCase()] = value;
     });
     return lowerParams;
@@ -904,7 +1020,11 @@ const getDirectURL = (config, params) => {
   }
   if (!singlepart || singlepart !== true && singlepart.indexOf(fetchPart) === -1) {
     if (value.retrieveBulkData) {
-      return value.retrieveBulkData().then(arr => {
+      // Try the specified retrieve type.
+      const options = {
+        mediaType: defaultType
+      };
+      return value.retrieveBulkData(options).then(arr => {
         value.DirectRetrieveURL = URL.createObjectURL(new Blob([arr], {
           type: defaultType
         }));
@@ -1006,26 +1126,47 @@ const EXPLICIT_VR_LITTLE_ENDIAN = '1.2.840.10008.1.2.1';
 const metadataProvider = src.classes.MetadataProvider;
 
 /**
+ * Creates a DICOM Web API based on the provided configuration.
  *
- * @param {string} name - Data source name
- * @param {string} wadoUriRoot - Legacy? (potentially unused/replaced)
- * @param {string} qidoRoot - Base URL to use for QIDO requests
- * @param {string} wadoRoot - Base URL to use for WADO requests
- * @param {boolean} qidoSupportsIncludeField - Whether QIDO supports the "Include" option to request additional fields in response
- * @param {string} imageRengering - wadors | ? (unsure of where/how this is used)
- * @param {string} thumbnailRendering - wadors | ? (unsure of where/how this is used)
- * @param {bool} supportsReject - Whether the server supports reject calls (i.e. DCM4CHEE)
- * @param {bool} lazyLoadStudy - "enableStudyLazyLoad"; Request series meta async instead of blocking
- * @param {string|bool} singlepart - indicates of the retrieves can fetch singlepart.  Options are bulkdata, video, image or boolean true
+ * @param {object} dicomWebConfig - Configuration for the DICOM Web API
+ * @param {string} dicomWebConfig.name - Data source name
+ * @param {string} dicomWebConfig.wadoUriRoot - Legacy? (potentially unused/replaced)
+ * @param {string} dicomWebConfig.qidoRoot - Base URL to use for QIDO requests
+ * @param {string} dicomWebConfig.wadoRoot - Base URL to use for WADO requests
+ * @param {string} dicomWebConfig.wadoUri - Base URL to use for WADO URI requests
+ * @param {boolean} dicomWebConfig.qidoSupportsIncludeField - Whether QIDO supports the "Include" option to request additional fields in response
+ * @param {string} dicomWebConfig.imageRendering - wadors | ? (unsure of where/how this is used)
+ * @param {string} dicomWebConfig.thumbnailRendering - wadors | ? (unsure of where/how this is used)
+ * @param {boolean} dicomWebConfig.supportsReject - Whether the server supports reject calls (i.e. DCM4CHEE)
+ * @param {boolean} dicomWebConfig.lazyLoadStudy - "enableStudyLazyLoad"; Request series meta async instead of blocking
+ * @param {string|boolean} dicomWebConfig.singlepart - indicates if the retrieves can fetch singlepart. Options are bulkdata, video, image, or boolean true
+ * @param {string} dicomWebConfig.requestTransferSyntaxUID - Transfer syntax to request from the server
+ * @param {object} dicomWebConfig.acceptHeader - Accept header to use for requests
+ * @param {boolean} dicomWebConfig.omitQuotationForMultipartRequest - Whether to omit quotation marks for multipart requests
+ * @param {boolean} dicomWebConfig.supportsFuzzyMatching - Whether the server supports fuzzy matching
+ * @param {boolean} dicomWebConfig.supportsWildcard - Whether the server supports wildcard matching
+ * @param {boolean} dicomWebConfig.supportsNativeDICOMModel - Whether the server supports the native DICOM model
+ * @param {boolean} dicomWebConfig.enableStudyLazyLoad - Whether to enable study lazy loading
+ * @param {boolean} dicomWebConfig.enableRequestTag - Whether to enable request tag
+ * @param {boolean} dicomWebConfig.enableStudyLazyLoad - Whether to enable study lazy loading
+ * @param {boolean} dicomWebConfig.bulkDataURI - Whether to enable bulkDataURI
+ * @param {function} dicomWebConfig.onConfiguration - Function that is called after the configuration is initialized
+ * @param {boolean} dicomWebConfig.staticWado - Whether to use the static WADO client
+ * @param {object} userAuthenticationService - User authentication service
+ * @param {object} userAuthenticationService.getAuthorizationHeader - Function that returns the authorization header
+ * @returns {object} - DICOM Web API object
  */
-function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
+function createDicomWebApi(dicomWebConfig, servicesManager) {
+  const {
+    userAuthenticationService,
+    customizationService
+  } = servicesManager.services;
   let dicomWebConfigCopy, qidoConfig, wadoConfig, qidoDicomWebClient, wadoDicomWebClient, getAuthrorizationHeader, generateWadoHeader;
   const implementation = {
-    initialize: _ref => {
-      let {
-        params,
-        query
-      } = _ref;
+    initialize: ({
+      params,
+      query
+    }) => {
       if (dicomWebConfig.onConfiguration && typeof dicomWebConfig.onConfiguration === 'function') {
         dicomWebConfig = dicomWebConfig.onConfiguration(dicomWebConfig, {
           params,
@@ -1097,11 +1238,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         }
         // processResults: processResults.bind(),
       },
-
       instances: {
         search: (studyInstanceUid, queryParameters) => {
           qidoDicomWebClient.headers = getAuthrorizationHeader();
-          search.call(undefined, qidoDicomWebClient, studyInstanceUid, null, queryParameters);
+          return search.call(undefined, qidoDicomWebClient, studyInstanceUid, null, queryParameters);
         }
       }
     },
@@ -1123,11 +1263,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
           singlepart: dicomWebConfig.singlepart
         }, params);
       },
-      bulkDataURI: async _ref2 => {
-        let {
-          StudyInstanceUID,
-          BulkDataURI
-        } = _ref2;
+      bulkDataURI: async ({
+        StudyInstanceUID,
+        BulkDataURI
+      }) => {
         qidoDicomWebClient.headers = getAuthrorizationHeader();
         const options = {
           multipart: false,
@@ -1140,26 +1279,26 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         });
       },
       series: {
-        metadata: async function () {
-          let {
-            StudyInstanceUID,
-            filters,
-            sortCriteria,
-            sortFunction,
-            madeInClient = false
-          } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        metadata: async ({
+          StudyInstanceUID,
+          filters,
+          sortCriteria,
+          sortFunction,
+          madeInClient = false,
+          returnPromises = false
+        } = {}) => {
           if (!StudyInstanceUID) {
             throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
           }
           if (dicomWebConfig.enableStudyLazyLoad) {
-            return implementation._retrieveSeriesMetadataAsync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient);
+            return implementation._retrieveSeriesMetadataAsync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient, returnPromises);
           }
           return implementation._retrieveSeriesMetadataSync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient);
         }
       }
     },
     store: {
-      dicom: async (dataset, request) => {
+      dicom: async (dataset, request, dicomDict) => {
         wadoDicomWebClient.headers = getAuthrorizationHeader();
         if (dataset instanceof ArrayBuffer) {
           const options = {
@@ -1168,18 +1307,22 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
           };
           await wadoDicomWebClient.storeInstances(options);
         } else {
-          const meta = {
-            FileMetaInformationVersion: dataset._meta?.FileMetaInformationVersion?.Value,
-            MediaStorageSOPClassUID: dataset.SOPClassUID,
-            MediaStorageSOPInstanceUID: dataset.SOPInstanceUID,
-            TransferSyntaxUID: EXPLICIT_VR_LITTLE_ENDIAN,
-            ImplementationClassUID,
-            ImplementationVersionName
-          };
-          const denaturalized = denaturalizeDataset(meta);
-          const dicomDict = new DicomDict(denaturalized);
-          dicomDict.dict = denaturalizeDataset(dataset);
-          const part10Buffer = dicomDict.write();
+          let effectiveDicomDict = dicomDict;
+          if (!dicomDict) {
+            const meta = {
+              FileMetaInformationVersion: dataset._meta?.FileMetaInformationVersion?.Value,
+              MediaStorageSOPClassUID: dataset.SOPClassUID,
+              MediaStorageSOPInstanceUID: dataset.SOPInstanceUID,
+              TransferSyntaxUID: EXPLICIT_VR_LITTLE_ENDIAN,
+              ImplementationClassUID,
+              ImplementationVersionName
+            };
+            const denaturalized = denaturalizeDataset(meta);
+            const defaultDicomDict = new DicomDict(denaturalized);
+            defaultDicomDict.dict = denaturalizeDataset(dataset);
+            effectiveDicomDict = defaultDicomDict;
+          }
+          const part10Buffer = effectiveDicomDict.write();
           const options = {
             datasets: [part10Buffer],
             request
@@ -1192,7 +1335,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
       const enableStudyLazyLoad = false;
       wadoDicomWebClient.headers = generateWadoHeader();
       // data is all SOPInstanceUIDs
-      const data = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction);
+      const data = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction, dicomWebConfig);
 
       // first naturalize the data
       const naturalizedInstancesMetadata = data.map(naturalizeDataset);
@@ -1233,16 +1376,16 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
       const seriesMetadata = Object.values(seriesSummaryMetadata);
       src.DicomMetadataStore.addSeriesMetadata(seriesMetadata, madeInClient);
       Object.keys(instancesPerSeries).forEach(seriesInstanceUID => src.DicomMetadataStore.addInstances(instancesPerSeries[seriesInstanceUID], madeInClient));
+      return seriesSummaryMetadata;
     },
-    _retrieveSeriesMetadataAsync: async function (StudyInstanceUID, filters, sortCriteria, sortFunction) {
-      let madeInClient = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+    _retrieveSeriesMetadataAsync: async (StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient = false, returnPromises = false) => {
       const enableStudyLazyLoad = true;
       wadoDicomWebClient.headers = generateWadoHeader();
       // Get Series
       const {
         preLoadData: seriesSummaryMetadata,
         promises: seriesPromises
-      } = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction);
+      } = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction, dicomWebConfig);
 
       /**
        * naturalizes the dataset, and adds a retrieve bulkdata method
@@ -1264,10 +1407,13 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
           // in which case it isn't necessary to re-read this.
           if (value && value.BulkDataURI && !value.Value) {
             // Provide a method to fetch bulkdata
-            value.retrieveBulkData = () => {
+            value.retrieveBulkData = (options = {}) => {
               // handle the scenarios where bulkDataURI is relative path
               fixBulkDataURI(value, naturalized, dicomWebConfig);
-              const options = {
+              const {
+                mediaType
+              } = options;
+              const useOptions = {
                 // The bulkdata fetches work with either multipart or
                 // singlepart, so set multipart to false to let the server
                 // decide which type to respond with.
@@ -1277,10 +1423,16 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
                 // is relative - that isn't disallowed by DICOMweb, but
                 // isn't well specified in the standard, but is needed in
                 // any implementation that stores static copies of the metadata
-                StudyInstanceUID: naturalized.StudyInstanceUID
+                StudyInstanceUID: naturalized.StudyInstanceUID,
+                mediaTypes: mediaType ? [{
+                  mediaType
+                }, {
+                  mediaType: 'application/octet-stream'
+                }] : undefined,
+                ...options
               };
               // Todo: this needs to be from wado dicom web client
-              return qidoDicomWebClient.retrieveBulkData(options).then(val => {
+              return qidoDicomWebClient.retrieveBulkData(useOptions).then(val => {
                 // There are DICOM PDF cases where the first ArrayBuffer in the array is
                 // the bulk data and DICOM video cases where the second ArrayBuffer is
                 // the bulk data. Here we play it safe and do a find.
@@ -1299,7 +1451,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         const naturalizedInstances = instances.map(addRetrieveBulkData);
 
         // Adding instanceMetadata to OHIF MetadataProvider
-        naturalizedInstances.forEach((instance, index) => {
+        naturalizedInstances.forEach(instance => {
           instance.wadoRoot = dicomWebConfig.wadoRoot;
           instance.wadoUri = dicomWebConfig.wadoUri;
           const imageId = implementation.getImageIdsForInstance({
@@ -1323,7 +1475,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         src.DicomMetadataStore.addInstances(naturalizedInstances, madeInClient);
       }
       function setSuccessFlag() {
-        const study = src.DicomMetadataStore.getStudy(StudyInstanceUID, madeInClient);
+        const study = src.DicomMetadataStore.getStudy(StudyInstanceUID);
+        if (!study) {
+          return;
+        }
         study.isLoaded = true;
       }
 
@@ -1333,11 +1488,22 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         aSeries.StudyInstanceUID = StudyInstanceUID;
       });
       src.DicomMetadataStore.addSeriesMetadata(seriesSummaryMetadata, madeInClient);
-      const seriesDeliveredPromises = seriesPromises.map(promise => promise.then(instances => {
-        storeInstances(instances);
-      }));
-      await Promise.all(seriesDeliveredPromises);
-      setSuccessFlag();
+      const seriesDeliveredPromises = seriesPromises.map(promise => {
+        if (!returnPromises) {
+          promise?.start();
+        }
+        return promise.then(instances => {
+          storeInstances(instances);
+        });
+      });
+      if (returnPromises) {
+        Promise.all(seriesDeliveredPromises).then(() => setSuccessFlag());
+        return seriesPromises;
+      } else {
+        await Promise.all(seriesDeliveredPromises);
+        setSuccessFlag();
+      }
+      return seriesSummaryMetadata;
     },
     deleteStudyMetadataPromise: deleteStudyMetadataPromise,
     getImageIdsForDisplaySet(displaySet) {
@@ -1365,11 +1531,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
       });
       return imageIds;
     },
-    getImageIdsForInstance(_ref3) {
-      let {
-        instance,
-        frame
-      } = _ref3;
+    getImageIdsForInstance({
+      instance,
+      frame = undefined
+    }) {
       const imageIds = getImageId({
         instance,
         frame,
@@ -1380,11 +1545,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     getConfig() {
       return dicomWebConfigCopy;
     },
-    getStudyInstanceUIDs(_ref4) {
-      let {
-        params,
-        query
-      } = _ref4;
+    getStudyInstanceUIDs({
+      params,
+      query
+    }) {
       const {
         StudyInstanceUIDs: paramsStudyInstanceUIDs
       } = params;
@@ -1423,7 +1587,20 @@ let _store = {
   // }
   // }
 };
-
+function wrapSequences(obj) {
+  return Object.keys(obj).reduce((acc, key) => {
+    if (typeof obj[key] === 'object' && obj[key] !== null) {
+      // Recursively wrap sequences for nested objects
+      acc[key] = wrapSequences(obj[key]);
+    } else {
+      acc[key] = obj[key];
+    }
+    if (key.endsWith('Sequence')) {
+      acc[key] = src["default"].utils.addAccessors(acc[key]);
+    }
+    return acc;
+  }, Array.isArray(obj) ? [] : {});
+}
 const getMetaDataByURL = url => {
   return _store.urls.find(metaData => metaData.url === url);
 };
@@ -1443,11 +1620,10 @@ function createDicomJSONApi(dicomJsonConfig) {
     wadoRoot
   } = dicomJsonConfig;
   const implementation = {
-    initialize: async _ref => {
-      let {
-        query,
-        url
-      } = _ref;
+    initialize: async ({
+      query,
+      url
+    }) => {
       if (!url) {
         url = query.get('url');
       }
@@ -1548,12 +1724,11 @@ function createDicomJSONApi(dicomJsonConfig) {
         return utils_getDirectURL(wadoRoot, params);
       },
       series: {
-        metadata: async function () {
-          let {
-            StudyInstanceUID,
-            madeInClient = false,
-            customSort
-          } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        metadata: async ({
+          StudyInstanceUID,
+          madeInClient = false,
+          customSort
+        } = {}) => {
           if (!StudyInstanceUID) {
             throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
           }
@@ -1585,8 +1760,13 @@ function createDicomJSONApi(dicomJsonConfig) {
           const numberOfSeries = series.length;
           series.forEach((series, index) => {
             const instances = series.instances.map(instance => {
+              // for instance.metadata if the key ends with sequence then
+              // we need to add a proxy to the first item in the sequence
+              // so that we can access the value of the sequence
+              // by using sequenceName.value
+              const modifiedMetadata = wrapSequences(instance.metadata);
               const obj = {
-                ...instance.metadata,
+                ...modifiedMetadata,
                 url: instance.url,
                 imageId: instance.url,
                 ...series,
@@ -1636,22 +1816,20 @@ function createDicomJSONApi(dicomJsonConfig) {
       });
       return imageIds;
     },
-    getImageIdsForInstance(_ref2) {
-      let {
-        instance,
-        frame
-      } = _ref2;
+    getImageIdsForInstance({
+      instance,
+      frame
+    }) {
       const imageIds = getImageId({
         instance,
         frame
       });
       return imageIds;
     },
-    getStudyInstanceUIDs: _ref3 => {
-      let {
-        params,
-        query
-      } = _ref3;
+    getStudyInstanceUIDs: ({
+      params,
+      query
+    }) => {
       const url = query.get('url');
       return _store.studyInstanceUIDMap.get(url);
     }
@@ -1672,8 +1850,7 @@ const END_MODALITIES = {
   SEG: true,
   DOC: true
 };
-const compareValue = function (v1, v2) {
-  let def = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+const compareValue = (v1, v2, def = 0) => {
   if (v1 === v2) {
     return def;
   }
@@ -1705,12 +1882,10 @@ function createDicomLocalApi(dicomLocalConfig) {
     name
   } = dicomLocalConfig;
   const implementation = {
-    initialize: _ref => {
-      let {
-        params,
-        query
-      } = _ref;
-    },
+    initialize: ({
+      params,
+      query
+    }) => {},
     query: {
       studies: {
         mapParams: () => {},
@@ -1789,11 +1964,10 @@ function createDicomLocalApi(dicomLocalConfig) {
         }
       },
       series: {
-        metadata: async function () {
-          let {
-            StudyInstanceUID,
-            madeInClient = false
-          } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        metadata: async ({
+          StudyInstanceUID,
+          madeInClient = false
+        } = {}) => {
           if (!StudyInstanceUID) {
             throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
           }
@@ -1872,11 +2046,10 @@ function createDicomLocalApi(dicomLocalConfig) {
       });
       return imageIds;
     },
-    getImageIdsForInstance(_ref2) {
-      let {
-        instance,
-        frame
-      } = _ref2;
+    getImageIdsForInstance({
+      instance,
+      frame
+    }) {
       const {
         StudyInstanceUID,
         SeriesInstanceUID,
@@ -1892,11 +2065,10 @@ function createDicomLocalApi(dicomLocalConfig) {
     deleteStudyMetadataPromise() {
       console.log('deleteStudyMetadataPromise not implemented');
     },
-    getStudyInstanceUIDs: _ref3 => {
-      let {
-        params,
-        query
-      } = _ref3;
+    getStudyInstanceUIDs: ({
+      params,
+      query
+    }) => {
       const {
         StudyInstanceUIDs: paramsStudyInstanceUIDs
       } = params;
@@ -1931,17 +2103,16 @@ function createDicomLocalApi(dicomLocalConfig) {
  * dicomWeb configuration array
  *
  */
-function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService) {
+function createDicomWebProxyApi(dicomWebProxyConfig, servicesManager) {
   const {
     name
   } = dicomWebProxyConfig;
   let dicomWebDelegate = undefined;
   const implementation = {
-    initialize: async _ref => {
-      let {
-        params,
-        query
-      } = _ref;
+    initialize: async ({
+      params,
+      query
+    }) => {
       const url = query.get('url');
       if (!url) {
         throw new Error(`No url for '${name}'`);
@@ -1951,7 +2122,7 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
         if (!data.servers?.dicomWeb?.[0]) {
           throw new Error('Invalid configuration returned by url');
         }
-        dicomWebDelegate = createDicomWebApi(data.servers.dicomWeb[0].configuration, UserAuthenticationService);
+        dicomWebDelegate = createDicomWebApi(data.servers.dicomWeb[0].configuration, servicesManager);
         dicomWebDelegate.initialize({
           params,
           query
@@ -1963,43 +2134,28 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
         search: params => dicomWebDelegate.query.studies.search(params)
       },
       series: {
-        search: function () {
-          return dicomWebDelegate.query.series.search(...arguments);
-        }
+        search: (...args) => dicomWebDelegate.query.series.search(...args)
       },
       instances: {
         search: (studyInstanceUid, queryParameters) => dicomWebDelegate.query.instances.search(studyInstanceUid, queryParameters)
       }
     },
     retrieve: {
-      directURL: function () {
-        return dicomWebDelegate.retrieve.directURL(...arguments);
-      },
+      directURL: (...args) => dicomWebDelegate.retrieve.directURL(...args),
       series: {
-        metadata: async function () {
-          return dicomWebDelegate.retrieve.series.metadata(...arguments);
-        }
+        metadata: async (...args) => dicomWebDelegate.retrieve.series.metadata(...args)
       }
     },
     store: {
-      dicom: function () {
-        return dicomWebDelegate.store(...arguments);
-      }
-    },
-    deleteStudyMetadataPromise: function () {
-      return dicomWebDelegate.deleteStudyMetadataPromise(...arguments);
+      dicom: (...args) => dicomWebDelegate.store(...args)
     },
-    getImageIdsForDisplaySet: function () {
-      return dicomWebDelegate.getImageIdsForDisplaySet(...arguments);
-    },
-    getImageIdsForInstance: function () {
-      return dicomWebDelegate.getImageIdsForInstance(...arguments);
-    },
-    getStudyInstanceUIDs(_ref2) {
-      let {
-        params,
-        query
-      } = _ref2;
+    deleteStudyMetadataPromise: (...args) => dicomWebDelegate.deleteStudyMetadataPromise(...args),
+    getImageIdsForDisplaySet: (...args) => dicomWebDelegate.getImageIdsForDisplaySet(...args),
+    getImageIdsForInstance: (...args) => dicomWebDelegate.getImageIdsForInstance(...args),
+    getStudyInstanceUIDs({
+      params,
+      query
+    }) {
       let studyInstanceUIDs = [];
 
       // there seem to be a couple of variations of the case for this parameter
@@ -2014,6 +2170,250 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
   return src/* IWebApiDataSource */.Is.create(implementation);
 }
 
+// EXTERNAL MODULE: ../../../node_modules/lodash/lodash.js
+var lodash = __webpack_require__(44379);
+;// CONCATENATED MODULE: ../../../extensions/default/src/MergeDataSource/index.ts
+
+
+const mergeMap = {
+  'query.studies.search': {
+    mergeKey: 'studyInstanceUid',
+    tagFunc: x => x
+  },
+  'query.series.search': {
+    mergeKey: 'seriesInstanceUid',
+    tagFunc: (series, sourceName) => {
+      series.forEach(series => {
+        series.RetrieveAETitle = sourceName;
+        src.DicomMetadataStore.updateSeriesMetadata(series);
+      });
+      return series;
+    }
+  }
+};
+
+/**
+ * Calls all data sources asynchronously and merges the results.
+ * @param {CallForAllDataSourcesAsyncOptions} options - The options for calling all data sources.
+ * @param {string} options.path - The path to the function to be called on each data source.
+ * @param {unknown[]} options.args - The arguments to be passed to the function.
+ * @param {ExtensionManager} options.extensionManager - The extension manager.
+ * @param {string[]} options.dataSourceNames - The names of the data sources to be called.
+ * @returns {Promise<unknown[]>} - A promise that resolves to the merged data from all data sources.
+ */
+const callForAllDataSourcesAsync = async ({
+  mergeMap,
+  path,
+  args,
+  extensionManager,
+  dataSourceNames
+}) => {
+  const {
+    mergeKey,
+    tagFunc
+  } = mergeMap[path] || {
+    tagFunc: x => x
+  };
+  const dataSourceDefs = Object.values(extensionManager.dataSourceDefs);
+  const promises = [];
+  const mergedData = [];
+  for (const dataSourceDef of dataSourceDefs) {
+    const {
+      configuration,
+      sourceName
+    } = dataSourceDef;
+    if (!!configuration && dataSourceNames.includes(sourceName)) {
+      const [dataSource] = extensionManager.getDataSources(sourceName);
+      const func = (0,lodash.get)(dataSource, path);
+      const promise = func.apply(dataSource, args);
+      promises.push(promise.then(data => mergedData.push(tagFunc(data, sourceName))));
+    }
+  }
+  await Promise.allSettled(promises);
+  let results = [];
+  if (mergeKey) {
+    results = (0,lodash.uniqBy)(mergedData.flat(), obj => (0,lodash.get)(obj, mergeKey));
+  } else {
+    results = mergedData.flat();
+  }
+  return results;
+};
+
+/**
+ * Calls all data sources that match the provided names and merges their data.
+ * @param options - The options for calling all data sources.
+ * @param options.path - The path to the function to be called on each data source.
+ * @param options.args - The arguments to be passed to the function.
+ * @param options.extensionManager - The extension manager instance.
+ * @param options.dataSourceNames - The names of the data sources to be called.
+ * @returns The merged data from all the matching data sources.
+ */
+const callForAllDataSources = ({
+  path,
+  args,
+  extensionManager,
+  dataSourceNames
+}) => {
+  const dataSourceDefs = Object.values(extensionManager.dataSourceDefs);
+  const mergedData = [];
+  for (const dataSourceDef of dataSourceDefs) {
+    const {
+      configuration,
+      sourceName
+    } = dataSourceDef;
+    if (!!configuration && dataSourceNames.includes(sourceName)) {
+      const [dataSource] = extensionManager.getDataSources(sourceName);
+      const func = (0,lodash.get)(dataSource, path);
+      const data = func.apply(dataSource, args);
+      mergedData.push(data);
+    }
+  }
+  return mergedData.flat();
+};
+
+/**
+ * Calls the default data source function specified by the given path with the provided arguments.
+ * @param {CallForDefaultDataSourceOptions} options - The options for calling the default data source.
+ * @param {string} options.path - The path to the function within the default data source.
+ * @param {unknown[]} options.args - The arguments to pass to the function.
+ * @param {string} options.defaultDataSourceName - The name of the default data source.
+ * @param {ExtensionManager} options.extensionManager - The extension manager instance.
+ * @returns {unknown} - The result of calling the default data source function.
+ */
+const callForDefaultDataSource = ({
+  path,
+  args,
+  defaultDataSourceName,
+  extensionManager
+}) => {
+  const [dataSource] = extensionManager.getDataSources(defaultDataSourceName);
+  const func = (0,lodash.get)(dataSource, path);
+  return func.apply(dataSource, args);
+};
+
+/**
+ * Calls the data source specified by the RetrieveAETitle of the given display set.
+ * @typedef {Object} CallByRetrieveAETitleOptions
+ * @property {string} path - The path of the method to call on the data source.
+ * @property {unknown[]} args - The arguments to pass to the method.
+ * @property {string} defaultDataSourceName - The name of the default data source.
+ * @property {ExtensionManager} extensionManager - The extension manager.
+ */
+const callByRetrieveAETitle = ({
+  path,
+  args,
+  defaultDataSourceName,
+  extensionManager
+}) => {
+  const [displaySet] = args;
+  const seriesMetadata = src.DicomMetadataStore.getSeries(displaySet.StudyInstanceUID, displaySet.SeriesInstanceUID);
+  const [dataSource] = extensionManager.getDataSources(seriesMetadata.RetrieveAETitle || defaultDataSourceName);
+  return dataSource[path](...args);
+};
+function createMergeDataSourceApi(mergeConfig, servicesManager, extensionManager) {
+  const {
+    seriesMerge
+  } = mergeConfig;
+  const {
+    dataSourceNames,
+    defaultDataSourceName
+  } = seriesMerge;
+  const implementation = {
+    initialize: (...args) => callForAllDataSources({
+      path: 'initialize',
+      args,
+      extensionManager,
+      dataSourceNames
+    }),
+    query: {
+      studies: {
+        search: (...args) => callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'query.studies.search',
+          args,
+          extensionManager,
+          dataSourceNames
+        })
+      },
+      series: {
+        search: (...args) => callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'query.series.search',
+          args,
+          extensionManager,
+          dataSourceNames
+        })
+      },
+      instances: {
+        search: (...args) => callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'query.instances.search',
+          args,
+          extensionManager,
+          dataSourceNames
+        })
+      }
+    },
+    retrieve: {
+      bulkDataURI: (...args) => callForAllDataSourcesAsync({
+        mergeMap,
+        path: 'retrieve.bulkDataURI',
+        args,
+        extensionManager,
+        dataSourceNames
+      }),
+      directURL: (...args) => callForDefaultDataSource({
+        path: 'retrieve.directURL',
+        args,
+        defaultDataSourceName,
+        extensionManager
+      }),
+      series: {
+        metadata: (...args) => callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'retrieve.series.metadata',
+          args,
+          extensionManager,
+          dataSourceNames
+        })
+      }
+    },
+    store: {
+      dicom: (...args) => callForDefaultDataSource({
+        path: 'store.dicom',
+        args,
+        defaultDataSourceName,
+        extensionManager
+      })
+    },
+    deleteStudyMetadataPromise: (...args) => callForAllDataSources({
+      path: 'deleteStudyMetadataPromise',
+      args,
+      extensionManager,
+      dataSourceNames
+    }),
+    getImageIdsForDisplaySet: (...args) => callByRetrieveAETitle({
+      path: 'getImageIdsForDisplaySet',
+      args,
+      defaultDataSourceName,
+      extensionManager
+    }),
+    getImageIdsForInstance: (...args) => callByRetrieveAETitle({
+      path: 'getImageIdsForDisplaySet',
+      args,
+      defaultDataSourceName,
+      extensionManager
+    }),
+    getStudyInstanceUIDs: (...args) => callForAllDataSources({
+      path: 'getStudyInstanceUIDs',
+      args,
+      extensionManager,
+      dataSourceNames
+    })
+  };
+  return src/* IWebApiDataSource */.Is.create(implementation);
+}
+
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getDataSourcesModule.js
 // TODO: Pull in IWebClientApi from @ohif/core
 // TODO: Use constructor to create an instance of IWebClientApi
@@ -2024,6 +2424,7 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
 
 
 
+
 /**
  *
  */
@@ -2044,6 +2445,10 @@ function getDataSourcesModule() {
     name: 'dicomlocal',
     type: 'localApi',
     createDataSource: createDicomLocalApi
+  }, {
+    name: 'merge',
+    type: 'mergeApi',
+    createDataSource: createMergeDataSourceApi
   }];
 }
 /* harmony default export */ const src_getDataSourcesModule = (getDataSourcesModule);
@@ -2052,8 +2457,8 @@ var react = __webpack_require__(43001);
 // EXTERNAL MODULE: ../../../node_modules/prop-types/index.js
 var prop_types = __webpack_require__(3827);
 var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
-// EXTERNAL MODULE: ../../ui/src/index.js + 485 modules
-var ui_src = __webpack_require__(71783);
+// EXTERNAL MODULE: ../../ui/src/index.js + 487 modules
+var ui_src = __webpack_require__(18414);
 // EXTERNAL MODULE: ./state/index.js + 1 modules
 var state = __webpack_require__(62657);
 // EXTERNAL MODULE: ../node_modules/react-router-dom/dist/index.js
@@ -2062,31 +2467,37 @@ var dist = __webpack_require__(62474);
 var es = __webpack_require__(69190);
 // EXTERNAL MODULE: ../node_modules/react-router/dist/index.js
 var react_router_dist = __webpack_require__(85066);
-// EXTERNAL MODULE: ../../i18n/src/index.js + 134 modules
-var i18n_src = __webpack_require__(50376);
+// EXTERNAL MODULE: ../../i18n/src/index.js + 148 modules
+var i18n_src = __webpack_require__(68311);
 // EXTERNAL MODULE: ../../../node_modules/classnames/index.js
-var classnames = __webpack_require__(44921);
+var classnames = __webpack_require__(33901);
 var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/Toolbar/Toolbar.tsx
 function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
 
-function Toolbar(_ref) {
-  let {
-    servicesManager
-  } = _ref;
+
+function Toolbar({
+  servicesManager
+}) {
   const {
     toolbarService
   } = servicesManager.services;
+  const [viewportGrid, viewportGridService] = (0,ui_src/* useViewportGrid */.O_)();
   const [toolbarButtons, setToolbarButtons] = (0,react.useState)([]);
   (0,react.useEffect)(() => {
+    const updateToolbar = () => {
+      const toolGroupId = viewportGridService.getActiveViewportOptionByKey('toolGroupId') ?? 'default';
+      setToolbarButtons(toolbarService.getButtonSection(toolGroupId));
+    };
     const {
       unsubscribe
-    } = toolbarService.subscribe(toolbarService.EVENTS.TOOL_BAR_MODIFIED, () => setToolbarButtons(toolbarService.getButtonSection('primary')));
+    } = toolbarService.subscribe(toolbarService.EVENTS.TOOL_BAR_MODIFIED, updateToolbar);
+    updateToolbar();
     return () => {
       unsubscribe();
     };
-  }, [toolbarService]);
+  }, [toolbarService, viewportGrid]);
   const onInteraction = (0,react.useCallback)(args => toolbarService.recordInteraction(args), [toolbarService]);
   return /*#__PURE__*/react.createElement(react.Fragment, null, toolbarButtons.map(toolDef => {
     const {
@@ -2125,12 +2536,11 @@ const {
   defaultLanguage,
   currentLanguage
 } = i18n_src["default"];
-function ViewerHeader(_ref) {
-  let {
-    hotkeysManager,
-    extensionManager,
-    servicesManager
-  } = _ref;
+function ViewerHeader({
+  hotkeysManager,
+  extensionManager,
+  servicesManager
+}) {
   const [appConfig] = (0,state/* useAppConfig */.M)();
   const navigate = (0,dist/* useNavigate */.s0)();
   const location = (0,react_router_dist/* useLocation */.TH)();
@@ -2166,14 +2576,14 @@ function ViewerHeader(_ref) {
     hotkeyDefinitions,
     hotkeyDefaults
   } = hotkeysManager;
-  const versionNumber = "3.8.0-beta.5";
-  const commitHash = "d98439fe7f3825076dbc87b664a1d1480ff414d3";
+  const versionNumber = "3.8.0-beta.51";
+  const commitHash = "a47aeb8bd729dcb8d2cfc13b27a31b0dd88f11ad";
   const menuOptions = [{
     title: t('Header:About'),
     icon: 'info',
     onClick: () => show({
       content: ui_src/* AboutModal */.tk,
-      title: 'About OHIF Viewer',
+      title: t('AboutModal:About OHIF Viewer'),
       contentProps: {
         versionNumber,
         commitHash
@@ -2183,7 +2593,7 @@ function ViewerHeader(_ref) {
     title: t('Header:Preferences'),
     icon: 'settings',
     onClick: () => show({
-      title: t('UserPreferencesModal:User Preferences'),
+      title: t('UserPreferencesModal:User preferences'),
       content: ui_src/* UserPreferences */.i1,
       contentProps: {
         hotkeyDefaults: hotkeysManager.getValidHotkeyDefinitions(hotkeyDefaults),
@@ -2196,11 +2606,10 @@ function ViewerHeader(_ref) {
           src/* hotkeys */.dD.unpause();
           hide();
         },
-        onSubmit: _ref2 => {
-          let {
-            hotkeyDefinitions,
-            language
-          } = _ref2;
+        onSubmit: ({
+          hotkeyDefinitions,
+          language
+        }) => {
           if (language.value !== currentLanguage().value) {
             i18n_src["default"].changeLanguage(language.value);
           }
@@ -2238,14 +2647,14 @@ function ViewerHeader(_ref) {
 ;// CONCATENATED MODULE: ../../../extensions/default/src/Components/SidePanelWithServices.tsx
 
 
-const SidePanelWithServices = _ref => {
-  let {
-    servicesManager,
-    side,
-    className,
-    activeTabIndex: activeTabIndexProp,
-    tabs
-  } = _ref;
+const SidePanelWithServices = ({
+  servicesManager,
+  side,
+  className,
+  activeTabIndex: activeTabIndexProp,
+  tabs,
+  expandedWidth
+}) => {
   const panelService = servicesManager?.services?.panelService;
 
   // Tracks whether this SidePanel has been opened at least once since this SidePanel was inserted into the DOM.
@@ -2274,7 +2683,8 @@ const SidePanelWithServices = _ref => {
     tabs: tabs,
     onOpen: () => {
       setHasBeenOpened(true);
-    }
+    },
+    expandedWidth: expandedWidth
   });
 };
 /* harmony default export */ const Components_SidePanelWithServices = (SidePanelWithServices);
@@ -2286,21 +2696,20 @@ const SidePanelWithServices = _ref => {
 
 
 
-function ViewerLayout(_ref) {
-  let {
-    // From Extension Module Params
-    extensionManager,
-    servicesManager,
-    hotkeysManager,
-    commandsManager,
-    // From Modes
-    viewports,
-    ViewportGridComp,
-    leftPanels = [],
-    rightPanels = [],
-    leftPanelDefaultClosed = false,
-    rightPanelDefaultClosed = false
-  } = _ref;
+function ViewerLayout({
+  // From Extension Module Params
+  extensionManager,
+  servicesManager,
+  hotkeysManager,
+  commandsManager,
+  // From Modes
+  viewports,
+  ViewportGridComp,
+  leftPanels = [],
+  rightPanels = [],
+  leftPanelDefaultClosed = false,
+  rightPanelDefaultClosed = false
+}) {
   const [appConfig] = (0,state/* useAppConfig */.M)();
   const {
     hangingProtocolService
@@ -2438,13 +2847,12 @@ ViewerLayout.propTypes = {
 - Init layout based on the displaySets and the objects.
 */
 
-/* harmony default export */ function getLayoutTemplateModule(_ref) {
-  let {
-    servicesManager,
-    extensionManager,
-    commandsManager,
-    hotkeysManager
-  } = _ref;
+/* harmony default export */ function getLayoutTemplateModule({
+  servicesManager,
+  extensionManager,
+  commandsManager,
+  hotkeysManager
+}) {
   function ViewerLayoutWithServices(props) {
     return src_ViewerLayout({
       servicesManager,
@@ -2478,14 +2886,13 @@ const {
  *
  * @param {*} param0
  */
-function PanelStudyBrowser(_ref) {
-  let {
-    servicesManager,
-    getImageSrc,
-    getStudiesForPatientByMRN,
-    requestDisplaySetCreationForStudy,
-    dataSource
-  } = _ref;
+function PanelStudyBrowser({
+  servicesManager,
+  getImageSrc,
+  getStudiesForPatientByMRN,
+  requestDisplaySetCreationForStudy,
+  dataSource
+}) {
   const {
     hangingProtocolService,
     displaySetService,
@@ -2738,7 +3145,6 @@ function _mapDisplaySets(displaySets, thumbnailImageSrcMap) {
         displaySetInstanceUID: ds.displaySetInstanceUID
         // .. Any other data to pass
       },
-
       isHydratedForDerivedDisplaySet: ds.isHydrated
     });
   });
@@ -2853,17 +3259,16 @@ function requestDisplaySetCreationForStudy(dataSource, displaySetService, StudyI
  * @param {object} commandsManager
  * @param {object} extensionManager
  */
-function WrappedPanelStudyBrowser(_ref) {
-  let {
-    commandsManager,
-    extensionManager,
-    servicesManager
-  } = _ref;
+function WrappedPanelStudyBrowser({
+  commandsManager,
+  extensionManager,
+  servicesManager
+}) {
   // TODO: This should be made available a different way; route should have
   // already determined our datasource
   const dataSource = extensionManager.getDataSources()[0];
   const _getStudiesForPatientByMRN = Panels_getStudiesForPatientByMRN.bind(null, dataSource);
-  const _getImageSrcFromImageId = _createGetImageSrcFromImageIdFn(extensionManager);
+  const _getImageSrcFromImageId = (0,react.useCallback)(_createGetImageSrcFromImageIdFn(extensionManager), []);
   const _requestDisplaySetCreationForStudy = Panels_requestDisplaySetCreationForStudy.bind(null, dataSource);
   return /*#__PURE__*/react.createElement(Panels_PanelStudyBrowser, {
     servicesManager: servicesManager,
@@ -2905,11 +3310,10 @@ WrappedPanelStudyBrowser.propTypes = {
 
 
 
-function ActionButtons(_ref) {
-  let {
-    onExportClick,
-    onCreateReportClick
-  } = _ref;
+function ActionButtons({
+  onExportClick,
+  onCreateReportClick
+}) {
   const {
     t
   } = (0,es/* useTranslation */.$G)('MeasurementTable');
@@ -2943,10 +3347,9 @@ const CREATE_REPORT_DIALOG_RESPONSE = {
   CANCEL: 0,
   CREATE_REPORT: 1
 };
-function CreateReportDialogPrompt(uiDialogService, _ref) {
-  let {
-    extensionManager
-  } = _ref;
+function CreateReportDialogPrompt(uiDialogService, {
+  extensionManager
+}) {
   return new Promise(function (resolve, reject) {
     let dialogId = undefined;
     const _handleClose = () => {
@@ -2967,11 +3370,10 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
      * @param {string} param0.action - value of action performed
      * @param {string} param0.value - value from input field
      */
-    const _handleFormSubmit = _ref2 => {
-      let {
-        action,
-        value
-      } = _ref2;
+    const _handleFormSubmit = ({
+      action,
+      value
+    }) => {
       uiDialogService.dismiss({
         id: dialogId
       });
@@ -3028,11 +3430,10 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
         }],
         // TODO: Should be on button press...
         onSubmit: _handleFormSubmit,
-        body: _ref3 => {
-          let {
-            value,
-            setValue
-          } = _ref3;
+        body: ({
+          value,
+          setValue
+        }) => {
           const onChangeHandler = event => {
             event.persist();
             setValue(value => ({
@@ -3092,12 +3493,11 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
  *
  * @param {*} servicesManager
  */
-async function createReportAsync(_ref) {
-  let {
-    servicesManager,
-    getReport,
-    reportType = 'measurement'
-  } = _ref;
+async function createReportAsync({
+  servicesManager,
+  getReport,
+  reportType = 'measurement'
+}) {
   const {
     displaySetService,
     uiNotificationService,
@@ -3208,15 +3608,18 @@ function findSRWithSameSeriesDescription(SeriesDescription, displaySetService) {
 
 
 
+
 const {
   downloadCSVReport
 } = src.utils;
-function PanelMeasurementTable(_ref) {
-  let {
-    servicesManager,
-    commandsManager,
-    extensionManager
-  } = _ref;
+function PanelMeasurementTable({
+  servicesManager,
+  commandsManager,
+  extensionManager
+}) {
+  const {
+    t
+  } = (0,es/* useTranslation */.$G)('MeasurementTable');
   const [viewportGrid, viewportGridService] = (0,ui_src/* useViewportGrid */.O_)();
   const {
     activeViewportId,
@@ -3303,31 +3706,28 @@ function PanelMeasurementTable(_ref) {
       });
     }
   }
-  const jumpToImage = _ref2 => {
-    let {
-      uid,
-      isActive
-    } = _ref2;
+  const jumpToImage = ({
+    uid,
+    isActive
+  }) => {
     measurementService.jumpToMeasurement(viewportGrid.activeViewportId, uid);
     onMeasurementItemClickHandler({
       uid,
       isActive
     });
   };
-  const onMeasurementItemEditHandler = _ref3 => {
-    let {
-      uid,
-      isActive
-    } = _ref3;
+  const onMeasurementItemEditHandler = ({
+    uid,
+    isActive
+  }) => {
     const measurement = measurementService.getMeasurement(uid);
     //Todo: why we are jumping to image?
     // jumpToImage({ id, isActive });
 
-    const onSubmitHandler = _ref4 => {
-      let {
-        action,
-        value
-      } = _ref4;
+    const onSubmitHandler = ({
+      action,
+      value
+    }) => {
       switch (action.id) {
         case 'save':
           {
@@ -3353,11 +3753,10 @@ function PanelMeasurementTable(_ref) {
         value: {
           label: measurement.label || ''
         },
-        body: _ref5 => {
-          let {
-            value,
-            setValue
-          } = _ref5;
+        body: ({
+          value,
+          setValue
+        }) => {
           const onChangeHandler = event => {
             event.persist();
             setValue(value => ({
@@ -3400,11 +3799,10 @@ function PanelMeasurementTable(_ref) {
       }
     });
   };
-  const onMeasurementItemClickHandler = _ref6 => {
-    let {
-      uid,
-      isActive
-    } = _ref6;
+  const onMeasurementItemClickHandler = ({
+    uid,
+    isActive
+  }) => {
     if (!isActive) {
       const measurements = [...displayMeasurements];
       const measurement = measurements.find(m => m.uid === uid);
@@ -3417,7 +3815,7 @@ function PanelMeasurementTable(_ref) {
     className: "ohif-scrollbar overflow-y-auto overflow-x-hidden",
     "data-cy": 'measurements-panel'
   }, /*#__PURE__*/react.createElement(ui_src/* MeasurementTable */.wt, {
-    title: "Measurements",
+    title: t("Measurements"),
     servicesManager: servicesManager,
     data: displayMeasurements,
     onClick: jumpToImage,
@@ -3488,21 +3886,23 @@ function _mapMeasurementToDisplay(measurement, index, types) {
 
 
 
+// EXTERNAL MODULE: ../../../node_modules/i18next/dist/esm/i18next.js
+var i18next = __webpack_require__(73577);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getPanelModule.tsx
 
 
 
+
 // TODO:
 // - No loading UI exists yet
 // - cancel promises when component is destroyed
 // - show errors in UI for thumbnails if promise fails
 
-function getPanelModule(_ref) {
-  let {
-    commandsManager,
-    extensionManager,
-    servicesManager
-  } = _ref;
+function getPanelModule({
+  commandsManager,
+  extensionManager,
+  servicesManager
+}) {
   const wrappedMeasurementPanel = () => {
     return /*#__PURE__*/react.createElement(PanelMeasurementTable, {
       commandsManager: commandsManager,
@@ -3514,7 +3914,7 @@ function getPanelModule(_ref) {
     name: 'seriesList',
     iconName: 'tab-studies',
     iconLabel: 'Studies',
-    label: 'Studies',
+    label: i18next/* default */.Z.t('SidePanel:Studies'),
     component: Panels_WrappedPanelStudyBrowser.bind(null, {
       commandsManager,
       extensionManager,
@@ -3524,8 +3924,8 @@ function getPanelModule(_ref) {
     name: 'measure',
     iconName: 'tab-linear',
     iconLabel: 'Measure',
-    label: 'Measurements',
-    secondaryLabel: 'Measurements',
+    label: i18next/* default */.Z.t('SidePanel:Measurements'),
+    secondaryLabel: i18next/* default */.Z.t('SidePanel:Measurements'),
     component: wrappedMeasurementPanel
   }];
 }
@@ -4022,11 +4422,10 @@ function ToolbarLayoutSelector_extends() { ToolbarLayoutSelector_extends = Objec
 
 
 
-function ToolbarLayoutSelectorWithServices(_ref) {
-  let {
-    servicesManager,
-    ...props
-  } = _ref;
+function ToolbarLayoutSelectorWithServices({
+  servicesManager,
+  ...props
+}) {
   const {
     toolbarService
   } = servicesManager.services;
@@ -4046,14 +4445,13 @@ function ToolbarLayoutSelectorWithServices(_ref) {
     onSelection: onSelection
   }));
 }
-function LayoutSelector(_ref2) {
-  let {
-    rows,
-    columns,
-    className,
-    onSelection,
-    ...rest
-  } = _ref2;
+function LayoutSelector({
+  rows,
+  columns,
+  className,
+  onSelection,
+  ...rest
+}) {
   const [isOpen, setIsOpen] = (0,react.useState)(false);
   const closeOnOutsideClick = () => {
     if (isOpen) {
@@ -4102,18 +4500,17 @@ function ToolbarSplitButtonWithServices_extends() { ToolbarSplitButtonWithServic
 
 
 
-function ToolbarSplitButtonWithServices(_ref) {
-  let {
-    isRadio,
-    isAction,
-    groupId,
-    primary,
-    secondary,
-    items,
-    renderer,
-    onInteraction,
-    servicesManager
-  } = _ref;
+function ToolbarSplitButtonWithServices({
+  isRadio,
+  isAction,
+  groupId,
+  primary,
+  secondary,
+  items,
+  renderer,
+  onInteraction,
+  servicesManager
+}) {
   const {
     toolbarService
   } = servicesManager?.services;
@@ -4186,14 +4583,13 @@ function ToolbarSplitButtonWithServices(_ref) {
       isActive
     };
   });
-  const DefaultListItemRenderer = _ref2 => {
-    let {
-      type,
-      icon,
-      label,
-      t,
-      id
-    } = _ref2;
+  const DefaultListItemRenderer = ({
+    type,
+    icon,
+    label,
+    t,
+    id
+  }) => {
     const isActive = type === 'toggle' && toggles[id] === true;
     return /*#__PURE__*/react.createElement("div", {
       className: classnames_default()('hover:bg-primary-dark flex h-8 w-full flex-row items-center p-3', 'whitespace-pre text-base', isActive && 'bg-primary-dark', isActive ? 'text-[#348CFD]' : 'text-common-bright hover:bg-primary-dark hover:text-primary-light')
@@ -4264,15 +4660,14 @@ function ToolbarButtonWithServices_extends() { ToolbarButtonWithServices_extends
 
 
 
-function ToolbarButtonWithServices(_ref) {
-  let {
-    id,
-    type,
-    commands,
-    onInteraction,
-    servicesManager,
-    ...props
-  } = _ref;
+function ToolbarButtonWithServices({
+  id,
+  type,
+  commands,
+  onInteraction,
+  servicesManager,
+  ...props
+}) {
   const {
     toolbarService
   } = servicesManager?.services || {};
@@ -4320,7 +4715,7 @@ ToolbarButtonWithServices.propTypes = {
         state: prop_types_default().shape({
           primaryToolId: (prop_types_default()).string,
           toggles: prop_types_default().objectOf((prop_types_default()).bool),
-          groups: prop_types_default().objectOf((prop_types_default()).object)
+          groups: prop_types_default().objectOf((prop_types_default()).any)
         }).isRequired
       }).isRequired
     }).isRequired
@@ -4332,11 +4727,10 @@ ToolbarButtonWithServices.propTypes = {
 
 
 
-function getToolbarModule(_ref) {
-  let {
-    commandsManager,
-    servicesManager
-  } = _ref;
+function getToolbarModule({
+  commandsManager,
+  servicesManager
+}) {
   return [{
     name: 'ohif.divider',
     defaultComponent: ToolbarDivider,
@@ -4530,7 +4924,11 @@ function adaptItem(item, subProps) {
 }
 // EXTERNAL MODULE: ../../ui/src/components/ContextMenu/ContextMenu.tsx
 var ContextMenu = __webpack_require__(5638);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js + 454 modules
+var dist_esm = __webpack_require__(76634);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/CustomizableContextMenu/ContextMenuController.tsx
+var _class;
+
 
 
 /**
@@ -4577,6 +4975,16 @@ class ContextMenuController {
       menus,
       selectorProps
     } = contextMenuProps;
+    const annotationManager = dist_esm.annotation.state.getAnnotationManager();
+    const {
+      locking
+    } = dist_esm.annotation;
+    const targetAnnotationId = selectorProps?.nearbyToolData?.annotationUID;
+    const isLocked = locking.isAnnotationLocked(annotationManager.getAnnotation(targetAnnotationId));
+    if (isLocked) {
+      console.warn('Annotation is locked.');
+      return;
+    }
     console.log('Getting items from', menus);
     const items = getMenuItems(selectorProps || contextMenuProps, event, menus, menuId);
     this.services.uiDialogService.dismiss({
@@ -4635,6 +5043,7 @@ class ContextMenuController {
     });
   }
 }
+_class = ContextMenuController;
 ContextMenuController.getDefaultPosition = () => {
   return {
     x: 0,
@@ -4658,16 +5067,14 @@ ContextMenuController._getElementDefaultPosition = element => {
     y: undefined
   };
 };
-ContextMenuController._getCanvasPointsPosition = function () {
-  let points = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  let element = arguments.length > 1 ? arguments[1] : undefined;
-  const viewerPos = ContextMenuController._getElementDefaultPosition(element);
+ContextMenuController._getCanvasPointsPosition = (points = [], element) => {
+  const viewerPos = _class._getElementDefaultPosition(element);
   for (let pointIndex = 0; pointIndex < points.length; pointIndex++) {
     const point = {
       x: points[pointIndex][0] || points[pointIndex]['x'],
       y: points[pointIndex][1] || points[pointIndex]['y']
     };
-    if (ContextMenuController._isValidPosition(point) && ContextMenuController._isValidPosition(viewerPos)) {
+    if (_class._isValidPosition(point) && _class._isValidPosition(viewerPos)) {
       return {
         x: point.x + viewerPos.x,
         y: point.y + viewerPos.y
@@ -4683,17 +5090,17 @@ ContextMenuController._isValidPosition = source => {
  */
 ContextMenuController._getDefaultPosition = (canvasPoints, eventDetail, viewerElement) => {
   function* getPositionIterator() {
-    yield ContextMenuController._getCanvasPointsPosition(canvasPoints, viewerElement);
-    yield ContextMenuController._getEventDefaultPosition(eventDetail);
-    yield ContextMenuController._getElementDefaultPosition(viewerElement);
-    yield ContextMenuController.getDefaultPosition();
+    yield _class._getCanvasPointsPosition(canvasPoints, viewerElement);
+    yield _class._getEventDefaultPosition(eventDetail);
+    yield _class._getElementDefaultPosition(viewerElement);
+    yield _class.getDefaultPosition();
   }
   const positionIterator = getPositionIterator();
   let current = positionIterator.next();
   let position = current.value;
   while (!current.done) {
     position = current.value;
-    if (ContextMenuController._isValidPosition(position)) {
+    if (_class._isValidPosition(position)) {
       positionIterator.return();
     }
     current = positionIterator.next();
@@ -4708,12 +5115,9 @@ const defaultContextMenu = {
   // Get the items from the UI Customization for the menu name (and have a custom name)
   {
     id: 'forExistingMeasurement',
-    selector: _ref => {
-      let {
-        nearbyToolData
-      } = _ref;
-      return !!nearbyToolData;
-    },
+    selector: ({
+      nearbyToolData
+    }) => !!nearbyToolData,
     items: [{
       label: 'Delete measurement',
       commands: [{
@@ -4758,13 +5162,12 @@ const rowStyle = {
   borderBottomWidth: `${rowBottomBorderPx}px`,
   ...rowVerticalPaddingStyle
 };
-function ColumnHeaders(_ref) {
-  let {
-    tagRef,
-    vrRef,
-    keywordRef,
-    valueRef
-  } = _ref;
+function ColumnHeaders({
+  tagRef,
+  vrRef,
+  keywordRef,
+  valueRef
+}) {
   return /*#__PURE__*/react.createElement("div", {
     className: classnames_default()('bg-secondary-dark ohif-scrollbar flex w-full flex-row overflow-y-scroll'),
     style: rowVerticalPaddingStyle
@@ -4798,10 +5201,9 @@ function ColumnHeaders(_ref) {
     className: "flex flex-row items-center focus:outline-none"
   }, "Value"))));
 }
-function DicomTagTable(_ref2) {
-  let {
-    rows
-  } = _ref2;
+function DicomTagTable({
+  rows
+}) {
   const listRef = (0,react.useRef)();
   const canvasRef = (0,react.useRef)();
   const [tagHeaderElem, setTagHeaderElem] = (0,react.useState)(null);
@@ -4855,11 +5257,10 @@ function DicomTagTable(_ref2) {
       window.removeEventListener('resize', debouncedResize);
     };
   }, []);
-  const Row = (0,react.useCallback)(_ref3 => {
-    let {
-      index,
-      style
-    } = _ref3;
+  const Row = (0,react.useCallback)(({
+    index,
+    style
+  }) => {
     const row = rows[index];
     return /*#__PURE__*/react.createElement("div", {
       style: {
@@ -4948,11 +5349,10 @@ const {
 const {
   nameMap
 } = DicomTagBrowser_DicomMetaDictionary;
-const DicomTagBrowser = _ref => {
-  let {
-    displaySets,
-    displaySetInstanceUID
-  } = _ref;
+const DicomTagBrowser = ({
+  displaySets,
+  displaySetInstanceUID
+}) => {
   // The column indices that are to be excluded during a filter of the table.
   // At present the column indices are:
   // 0: DICOM tag
@@ -5113,8 +5513,7 @@ function getSortedTags(metadata) {
   _sortTagList(tagList);
   return tagList;
 }
-function getRows(metadata) {
-  let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+function getRows(metadata, depth = 0) {
   // Tag, Type, Value, Keyword
 
   const keywords = Object.keys(metadata);
@@ -5125,7 +5524,6 @@ function getRows(metadata) {
   if (depth > 0) {
     tagIndent += ' '; // If indented, add a space after the indents.
   }
-
   const rows = [];
   for (let i = 0; i < keywords.length; i++) {
     let keyword = keywords[i];
@@ -5366,11 +5764,10 @@ const findViewportsByPosition_findOrCreateViewport = (hangingProtocolService, vi
  * @returns Set of states that can be applied to the state sync to remember
  *   the current view state.
  */
-const findViewportsByPosition = (state, _ref, syncService) => {
-  let {
-    numRows,
-    numCols
-  } = _ref;
+const findViewportsByPosition = (state, {
+  numRows,
+  numCols
+}, syncService) => {
   const {
     viewports
   } = state;
@@ -5425,11 +5822,10 @@ const {
  * commands module, but if others get added elsewhere this may need enhancing.
  */
 const isHangingProtocolCommand = command => command && (command.commandName === 'setHangingProtocol' || command.commandName === 'toggleHangingProtocol');
-const commandsModule = _ref => {
-  let {
-    servicesManager,
-    commandsManager
-  } = _ref;
+const commandsModule = ({
+  servicesManager,
+  commandsManager
+}) => {
   const {
     customizationService,
     measurementService,
@@ -5484,12 +5880,11 @@ const commandsModule = _ref => {
     closeContextMenu: () => {
       contextMenuController.closeContextMenu();
     },
-    displayNotification: _ref2 => {
-      let {
-        text,
-        title,
-        type
-      } = _ref2;
+    displayNotification: ({
+      text,
+      title,
+      type
+    }) => {
       uiNotificationService.show({
         title: title,
         message: text,
@@ -5558,14 +5953,13 @@ const commandsModule = _ref => {
      * @param options.stageIndex - the index of the stage to go to.
      * @param options.reset - flag to indicate if the HP should be reset to its original and not restored to a previous state
      */
-    setHangingProtocol: _ref3 => {
-      let {
-        activeStudyUID = '',
-        protocolId,
-        stageId,
-        stageIndex,
-        reset = false
-      } = _ref3;
+    setHangingProtocol: ({
+      activeStudyUID = '',
+      protocolId,
+      stageId,
+      stageIndex,
+      reset = false
+    }) => {
       const primaryToolBeforeHPChange = toolbarService.getActivePrimaryTool();
       try {
         // Stores in the state the display set selector id to displaySetUID mapping
@@ -5626,9 +6020,6 @@ const commandsModule = _ref => {
         delete displaySetSelectorMap[`${activeStudyUID || hpInfo.activeStudyUID}:activeDisplaySet:0`];
         stateSyncService.store(stateSyncReduce);
         // This is a default action applied
-        const {
-          protocol
-        } = hangingProtocolService.getActiveProtocol();
         actions.toggleHpTools();
 
         // try to use the same tool in the new hanging protocol stage
@@ -5649,17 +6040,6 @@ const commandsModule = _ref => {
             });
           }
         }
-
-        // Send the notification about updating the state
-        if (protocolId !== hpInfo.protocolId) {
-          // The old protocol callbacks are used for turning off things
-          // like crosshairs when moving to the new HP
-          commandsManager.run(oldProtocol.callbacks?.onProtocolExit);
-          // The new protocol callback is used for things like
-          // activating modes etc.
-        }
-
-        commandsManager.run(protocol.callbacks?.onProtocolEnter);
         return true;
       } catch (e) {
         console.error(e);
@@ -5673,11 +6053,10 @@ const commandsModule = _ref => {
         return false;
       }
     },
-    toggleHangingProtocol: _ref4 => {
-      let {
-        protocolId,
-        stageIndex
-      } = _ref4;
+    toggleHangingProtocol: ({
+      protocolId,
+      stageIndex
+    }) => {
       const {
         protocol,
         stageIndex: desiredStageIndex,
@@ -5710,10 +6089,9 @@ const commandsModule = _ref => {
         });
       }
     },
-    deltaStage: _ref5 => {
-      let {
-        direction
-      } = _ref5;
+    deltaStage: ({
+      direction
+    }) => {
       const {
         protocolId,
         stageIndex: oldStageIndex
@@ -5739,11 +6117,10 @@ const commandsModule = _ref => {
     /**
      * Changes the viewport grid layout in terms of the MxN layout.
      */
-    setViewportGridLayout: _ref6 => {
-      let {
-        numRows,
-        numCols
-      } = _ref6;
+    setViewportGridLayout: ({
+      numRows,
+      numCols
+    }) => {
       const {
         protocol
       } = hangingProtocolService.getActiveProtocol();
@@ -5953,11 +6330,10 @@ const commandsModule = _ref => {
         behavior: 'smooth'
       });
     },
-    updateViewportDisplaySet: _ref7 => {
-      let {
-        direction,
-        excludeNonImageModalities
-      } = _ref7;
+    updateViewportDisplaySet: ({
+      direction,
+      excludeNonImageModalities
+    }) => {
       const nonImageModalities = ['SR', 'SEG', 'SM', 'RTSTRUCT', 'RTPLAN', 'RTDOSE'];
 
       // Sort the display sets as per the hanging protocol service viewport/display set scoring system.
@@ -6473,6 +6849,9 @@ const defaultProtocol = {
   editableBy: {},
   protocolMatchingRules: [],
   toolGroupIds: ['default'],
+  hpInitiationCriteria: {
+    minSeriesLoaded: 1
+  },
   // -1 would be used to indicate active only, whereas other values are
   // the number of required priors referenced - so 0 means active with
   // 0 or more priors.
@@ -6517,7 +6896,6 @@ const defaultProtocol = {
       // studyMatchingRules: [],
     }
   },
-
   stages: [{
     name: 'default',
     viewportStructure: {
@@ -6543,7 +6921,6 @@ const defaultProtocol = {
         //   preset: 'middle', // 'first', 'last', 'middle'
         // },
       },
-
       displaySets: [{
         id: 'defaultDisplaySetId'
       }]
@@ -6617,12 +6994,11 @@ function DataSourceSelector() {
 
 
 
-function ItemListComponent(_ref) {
-  let {
-    itemLabel,
-    itemList,
-    onItemClicked
-  } = _ref;
+function ItemListComponent({
+  itemLabel,
+  itemList,
+  onItemClicked
+}) {
   const {
     t
   } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
@@ -6676,12 +7052,11 @@ function ItemListComponent(_ref) {
 
 
 const NO_WRAP_ELLIPSIS_CLASS_NAMES = 'text-ellipsis whitespace-nowrap overflow-hidden';
-function DataSourceConfigurationModalComponent(_ref) {
-  let {
-    configurationAPI,
-    configuredItems,
-    onHide
-  } = _ref;
+function DataSourceConfigurationModalComponent({
+  configurationAPI,
+  configuredItems,
+  onHide
+}) {
   const {
     t
   } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
@@ -6788,11 +7163,10 @@ function DataSourceConfigurationModalComponent(_ref) {
 
 
 
-function DataSourceConfigurationComponent(_ref) {
-  let {
-    servicesManager,
-    extensionManager
-  } = _ref;
+function DataSourceConfigurationComponent({
+  servicesManager,
+  extensionManager
+}) {
   const {
     t
   } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
@@ -7010,9 +7384,7 @@ class GoogleCloudDataSourceConfigurationAPI {
    * @param fetchSearchParams any search query params; currently only used for paging results
    * @returns an array of items of the specified type
    */
-  static async _doFetch(urlStr, fetchItemType) {
-    let fetchOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    let fetchSearchParams = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  static async _doFetch(urlStr, fetchItemType, fetchOptions = {}, fetchSearchParams = {}) {
     try {
       const url = new URL(urlStr);
       url.search = new URLSearchParams(fetchSearchParams).toString();
@@ -7057,11 +7429,10 @@ class GoogleCloudDataSourceConfigurationAPI {
  * custom page for the user to view their profile, or to add a custom
  * page for login etc.
  */
-function getCustomizationModule(_ref) {
-  let {
-    servicesManager,
-    extensionManager
-  } = _ref;
+function getCustomizationModule({
+  servicesManager,
+  extensionManager
+}) {
   return [{
     name: 'helloPage',
     value: {
@@ -7269,11 +7640,10 @@ const init_metadataProvider = src.classes.MetadataProvider;
  * @param {Object} servicesManager
  * @param {Object} configuration
  */
-function init(_ref) {
-  let {
-    servicesManager,
-    configuration = {}
-  } = _ref;
+function init({
+  servicesManager,
+  configuration = {}
+}) {
   const {
     stateSyncService
   } = servicesManager.services;
@@ -7320,43 +7690,41 @@ function init(_ref) {
     clearOnModeExit: true
   });
 }
-const handlePETImageMetadata = _ref2 => {
-  let {
-    SeriesInstanceUID,
-    StudyInstanceUID
-  } = _ref2;
+const handlePETImageMetadata = ({
+  SeriesInstanceUID,
+  StudyInstanceUID
+}) => {
   const {
     instances
   } = src.DicomMetadataStore.getSeries(StudyInstanceUID, SeriesInstanceUID);
+  if (!instances?.length) {
+    return;
+  }
   const modality = instances[0].Modality;
-  if (modality !== 'PT') {
+  if (!modality || modality !== 'PT') {
     return;
   }
   const imageIds = instances.map(instance => instance.imageId);
   const instanceMetadataArray = [];
-  imageIds.forEach(imageId => {
-    const instanceMetadata = getPTImageIdInstanceMetadata(imageId);
-    if (instanceMetadata) {
-      instanceMetadataArray.push(instanceMetadata);
-    }
-  });
-  if (!instanceMetadataArray.length) {
-    return;
-  }
 
   // try except block to prevent errors when the metadata is not correct
-  let suvScalingFactors;
   try {
-    suvScalingFactors = (0,calculate_suv_esm/* calculateSUVScalingFactors */.d)(instanceMetadataArray);
+    imageIds.forEach(imageId => {
+      const instanceMetadata = getPTImageIdInstanceMetadata(imageId);
+      if (instanceMetadata) {
+        instanceMetadataArray.push(instanceMetadata);
+      }
+    });
+    if (!instanceMetadataArray.length) {
+      return;
+    }
+    const suvScalingFactors = (0,calculate_suv_esm/* calculateSUVScalingFactors */.d)(instanceMetadataArray);
+    instanceMetadataArray.forEach((instanceMetadata, index) => {
+      init_metadataProvider.addCustomMetadata(imageIds[index], 'scalingModule', suvScalingFactors[index]);
+    });
   } catch (error) {
     console.log(error);
   }
-  if (!suvScalingFactors) {
-    return;
-  }
-  instanceMetadataArray.forEach((instanceMetadata, index) => {
-    init_metadataProvider.addCustomMetadata(imageIds[index], 'scalingModule', suvScalingFactors[index]);
-  });
 };
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/utils/index.ts
 
@@ -7390,10 +7758,9 @@ const defaultExtension = {
   getSopClassHandlerModule: src_getSopClassHandlerModule,
   getToolbarModule: getToolbarModule,
   getCommandsModule: src_commandsModule,
-  getUtilityModule(_ref) {
-    let {
-      servicesManager
-    } = _ref;
+  getUtilityModule({
+    servicesManager
+  }) {
     return [{
       name: 'common',
       exports: {