@ohif/app 3.7.0-beta.6 → 3.7.0-beta.61

package/dist/{82.bundle.0b649d84e313e1928590.js → 362.bundle.9d4d81eab3e31314a932.js}

@@ -1,7 +1,7 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[82],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[362],{
 
-/***/ 96082:
+/***/ 13362:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -28,11 +28,11 @@ __webpack_require__.d(utils_namespaceObject, {
 });
 
 // EXTERNAL MODULE: ../../../node_modules/dicomweb-client/build/dicomweb-client.es.js
-var dicomweb_client_es = __webpack_require__(75935);
-// EXTERNAL MODULE: ../../core/src/index.ts + 101 modules
-var src = __webpack_require__(48501);
+var dicomweb_client_es = __webpack_require__(97604);
+// EXTERNAL MODULE: ../../core/src/index.ts + 106 modules
+var src = __webpack_require__(38930);
 // EXTERNAL MODULE: ../../core/src/utils/sortStudy.ts
-var sortStudy = __webpack_require__(87853);
+var sortStudy = __webpack_require__(62971);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/qido.js
 /**
  * QIDO - Query based on ID for DICOM Objects
@@ -378,7 +378,7 @@ function getImageId(_ref) {
   }
 }
 // EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
-var dcmjs_es = __webpack_require__(22737);
+var dcmjs_es = __webpack_require__(67540);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoader.js
 /**
  * Class to define inheritance of load retrieve strategy.
@@ -708,12 +708,16 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
    * @returns
    */
   async searchForStudies(options) {
-    if (!this.staticWado) return super.searchForStudies(options);
+    if (!this.staticWado) {
+      return super.searchForStudies(options);
+    }
     const searchResult = await super.searchForStudies(options);
     const {
       queryParams
     } = options;
-    if (!queryParams) return searchResult;
+    if (!queryParams) {
+      return searchResult;
+    }
     const lowerParams = this.toLowerParams(queryParams);
     const filtered = searchResult.filter(study => {
       for (const key of Object.keys(StaticWadoClient.studyFilterKeys)) {
@@ -726,12 +730,16 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
     return filtered;
   }
   async searchForSeries(options) {
-    if (!this.staticWado) return super.searchForSeries(options);
+    if (!this.staticWado) {
+      return super.searchForSeries(options);
+    }
     const searchResult = await super.searchForSeries(options);
     const {
       queryParams
     } = options;
-    if (!queryParams) return searchResult;
+    if (!queryParams) {
+      return searchResult;
+    }
     const lowerParams = this.toLowerParams(queryParams);
     const filtered = searchResult.filter(series => {
       for (const key of Object.keys(StaticWadoClient.seriesFilterKeys)) {
@@ -767,8 +775,12 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
       actual = actual.Alphabetic;
     }
     if (typeof actual == 'string') {
-      if (actual.length === 0) return true;
-      if (desired.length === 0 || desired === '*') return true;
+      if (actual.length === 0) {
+        return true;
+      }
+      if (desired.length === 0 || desired === '*') {
+        return true;
+      }
       if (desired[0] === '*' && desired[desired.length - 1] === '*') {
         // console.log(`Comparing ${actual} to ${desired.substring(1, desired.length - 1)}`)
         return actual.indexOf(desired.substring(1, desired.length - 1)) != -1;
@@ -783,9 +795,13 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
 
   /** Compares a pair of dates to see if the value is within the range */
   compareDateRange(range, value) {
-    if (!value) return true;
+    if (!value) {
+      return true;
+    }
     const dash = range.indexOf('-');
-    if (dash === -1) return this.compareValues(range, value);
+    if (dash === -1) {
+      return this.compareValues(range, value);
+    }
     const start = range.substring(0, dash);
     const end = range.substring(dash + 1);
     return (!start || value >= start) && (!end || value <= end);
@@ -802,11 +818,17 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
    */
   filterItem(key, queryParams, study, sourceFilterMap) {
     const altKey = sourceFilterMap[key] || key;
-    if (!queryParams) return true;
+    if (!queryParams) {
+      return true;
+    }
     const testValue = queryParams[key] || queryParams[altKey];
-    if (!testValue) return true;
+    if (!testValue) {
+      return true;
+    }
     const valueElem = study[key] || study[altKey];
-    if (!valueElem) return false;
+    if (!valueElem) {
+      return false;
+    }
     if (valueElem.vr == 'DA') {
       return this.compareDateRange(testValue, valueElem.Value[0]);
     }
@@ -867,8 +889,12 @@ const getDirectURL = (config, params) => {
     singlepart: fetchPart = 'video'
   } = params;
   const value = instance[tag];
-  if (!value) return undefined;
-  if (value.DirectRetrieveURL) return value.DirectRetrieveURL;
+  if (!value) {
+    return undefined;
+  }
+  if (value.DirectRetrieveURL) {
+    return value.DirectRetrieveURL;
+  }
   if (value.InlineBinary) {
     const blob = src.utils.b64toBlob(value.InlineBinary, defaultType);
     value.DirectRetrieveURL = URL.createObjectURL(blob);
@@ -991,65 +1017,69 @@ const metadataProvider = src.classes.MetadataProvider;
  * @param {string|bool} singlepart - indicates of the retrieves can fetch singlepart.  Options are bulkdata, video, image or boolean true
  */
 function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
-  const {
-    qidoRoot,
-    wadoRoot,
-    enableStudyLazyLoad,
-    supportsFuzzyMatching,
-    supportsWildcard,
-    supportsReject,
-    staticWado,
-    singlepart
-  } = dicomWebConfig;
-  const dicomWebConfigCopy = JSON.parse(JSON.stringify(dicomWebConfig));
-  const qidoConfig = {
-    url: qidoRoot,
-    staticWado,
-    singlepart,
-    headers: userAuthenticationService.getAuthorizationHeader(),
-    errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
-  };
-  const wadoConfig = {
-    url: wadoRoot,
-    staticWado,
-    singlepart,
-    headers: userAuthenticationService.getAuthorizationHeader(),
-    errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
-  };
-
-  // TODO -> Two clients sucks, but its better than 1000.
-  // TODO -> We'll need to merge auth later.
-  const qidoDicomWebClient = staticWado ? new StaticWadoClient(qidoConfig) : new dicomweb_client_es.api.DICOMwebClient(qidoConfig);
-  const wadoDicomWebClient = staticWado ? new StaticWadoClient(wadoConfig) : new dicomweb_client_es.api.DICOMwebClient(wadoConfig);
+  let dicomWebConfigCopy, qidoConfig, wadoConfig, qidoDicomWebClient, wadoDicomWebClient, getAuthrorizationHeader, generateWadoHeader;
   const implementation = {
     initialize: _ref => {
       let {
         params,
         query
       } = _ref;
-      const {
-        StudyInstanceUIDs: paramsStudyInstanceUIDs
-      } = params;
-      const queryStudyInstanceUIDs = src.utils.splitComma(query.getAll('StudyInstanceUIDs'));
-      const StudyInstanceUIDs = queryStudyInstanceUIDs.length && queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
-      const StudyInstanceUIDsAsArray = StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs) ? StudyInstanceUIDs : [StudyInstanceUIDs];
-      return StudyInstanceUIDsAsArray;
+      if (dicomWebConfig.onConfiguration && typeof dicomWebConfig.onConfiguration === 'function') {
+        dicomWebConfig = dicomWebConfig.onConfiguration(dicomWebConfig, {
+          params,
+          query
+        });
+      }
+      dicomWebConfigCopy = JSON.parse(JSON.stringify(dicomWebConfig));
+      getAuthrorizationHeader = () => {
+        const xhrRequestHeaders = {};
+        const authHeaders = userAuthenticationService.getAuthorizationHeader();
+        if (authHeaders && authHeaders.Authorization) {
+          xhrRequestHeaders.Authorization = authHeaders.Authorization;
+        }
+        return xhrRequestHeaders;
+      };
+      generateWadoHeader = () => {
+        let authorizationHeader = getAuthrorizationHeader();
+        //Generate accept header depending on config params
+        let formattedAcceptHeader = src.utils.generateAcceptHeader(dicomWebConfig.acceptHeader, dicomWebConfig.requestTransferSyntaxUID, dicomWebConfig.omitQuotationForMultipartRequest);
+        return {
+          ...authorizationHeader,
+          Accept: formattedAcceptHeader
+        };
+      };
+      qidoConfig = {
+        url: dicomWebConfig.qidoRoot,
+        staticWado: dicomWebConfig.staticWado,
+        singlepart: dicomWebConfig.singlepart,
+        headers: userAuthenticationService.getAuthorizationHeader(),
+        errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
+      };
+      wadoConfig = {
+        url: dicomWebConfig.wadoRoot,
+        staticWado: dicomWebConfig.staticWado,
+        singlepart: dicomWebConfig.singlepart,
+        headers: userAuthenticationService.getAuthorizationHeader(),
+        errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
+      };
+
+      // TODO -> Two clients sucks, but its better than 1000.
+      // TODO -> We'll need to merge auth later.
+      qidoDicomWebClient = dicomWebConfig.staticWado ? new StaticWadoClient(qidoConfig) : new dicomweb_client_es.api.DICOMwebClient(qidoConfig);
+      wadoDicomWebClient = dicomWebConfig.staticWado ? new StaticWadoClient(wadoConfig) : new dicomweb_client_es.api.DICOMwebClient(wadoConfig);
     },
     query: {
       studies: {
         mapParams: mapParams.bind(),
         search: async function (origParams) {
-          const headers = userAuthenticationService.getAuthorizationHeader();
-          if (headers) {
-            qidoDicomWebClient.headers = headers;
-          }
+          qidoDicomWebClient.headers = getAuthrorizationHeader();
           const {
             studyInstanceUid,
             seriesInstanceUid,
             ...mappedParams
           } = mapParams(origParams, {
-            supportsFuzzyMatching,
-            supportsWildcard
+            supportsFuzzyMatching: dicomWebConfig.supportsFuzzyMatching,
+            supportsWildcard: dicomWebConfig.supportsWildcard
           }) || {};
           const results = await search(qidoDicomWebClient, undefined, undefined, mappedParams);
           return processResults(results);
@@ -1059,10 +1089,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
       series: {
         // mapParams: mapParams.bind(),
         search: async function (studyInstanceUid) {
-          const headers = userAuthenticationService.getAuthorizationHeader();
-          if (headers) {
-            qidoDicomWebClient.headers = headers;
-          }
+          qidoDicomWebClient.headers = getAuthrorizationHeader();
           const results = await seriesInStudy(qidoDicomWebClient, studyInstanceUid);
           return processSeriesResults(results);
         }
@@ -1071,10 +1098,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
 
       instances: {
         search: (studyInstanceUid, queryParameters) => {
-          const headers = userAuthenticationService.getAuthorizationHeader();
-          if (headers) {
-            qidoDicomWebClient.headers = headers;
-          }
+          qidoDicomWebClient.headers = getAuthrorizationHeader();
           search.call(undefined, qidoDicomWebClient, studyInstanceUid, null, queryParameters);
         }
       }
@@ -1093,8 +1117,8 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
        */
       directURL: params => {
         return utils_getDirectURL({
-          wadoRoot,
-          singlepart
+          wadoRoot: dicomWebConfig.wadoRoot,
+          singlepart: dicomWebConfig.singlepart
         }, params);
       },
       bulkDataURI: async _ref2 => {
@@ -1102,6 +1126,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
           StudyInstanceUID,
           BulkDataURI
         } = _ref2;
+        qidoDicomWebClient.headers = getAuthrorizationHeader();
         const options = {
           multipart: false,
           BulkDataURI,
@@ -1121,14 +1146,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
             sortFunction,
             madeInClient = false
           } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-          const headers = userAuthenticationService.getAuthorizationHeader();
-          if (headers) {
-            wadoDicomWebClient.headers = headers;
-          }
           if (!StudyInstanceUID) {
             throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
           }
-          if (enableStudyLazyLoad) {
+          if (dicomWebConfig.enableStudyLazyLoad) {
             return implementation._retrieveSeriesMetadataAsync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient);
           }
           return implementation._retrieveSeriesMetadataSync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient);
@@ -1137,10 +1158,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     },
     store: {
       dicom: async (dataset, request) => {
-        const headers = userAuthenticationService.getAuthorizationHeader();
-        if (headers) {
-          wadoDicomWebClient.headers = headers;
-        }
+        wadoDicomWebClient.headers = getAuthrorizationHeader();
         if (dataset instanceof ArrayBuffer) {
           const options = {
             datasets: [dataset],
@@ -1170,7 +1188,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     },
     _retrieveSeriesMetadataSync: async (StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient) => {
       const enableStudyLazyLoad = false;
-
+      wadoDicomWebClient.headers = generateWadoHeader();
       // data is all SOPInstanceUIDs
       const data = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction);
 
@@ -1215,6 +1233,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     _retrieveSeriesMetadataAsync: async function (StudyInstanceUID, filters, sortCriteria, sortFunction) {
       let madeInClient = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
       const enableStudyLazyLoad = true;
+      wadoDicomWebClient.headers = generateWadoHeader();
       // Get Series
       const {
         preLoadData: seriesSummaryMetadata,
@@ -1356,10 +1375,23 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     },
     getConfig() {
       return dicomWebConfigCopy;
+    },
+    getStudyInstanceUIDs(_ref4) {
+      let {
+        params,
+        query
+      } = _ref4;
+      const {
+        StudyInstanceUIDs: paramsStudyInstanceUIDs
+      } = params;
+      const queryStudyInstanceUIDs = src.utils.splitComma(query.getAll('StudyInstanceUIDs'));
+      const StudyInstanceUIDs = queryStudyInstanceUIDs.length && queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
+      const StudyInstanceUIDsAsArray = StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs) ? StudyInstanceUIDs : [StudyInstanceUIDs];
+      return StudyInstanceUIDsAsArray;
     }
   };
-  if (supportsReject) {
-    implementation.reject = dcm4cheeReject(wadoRoot);
+  if (dicomWebConfig.supportsReject) {
+    implementation.reject = dcm4cheeReject(dicomWebConfig.wadoRoot);
   }
   return src/* IWebApiDataSource */.Is.create(implementation);
 }
@@ -1375,7 +1407,8 @@ const mappings = {
   patientId: 'PatientID'
 };
 let _store = {
-  urls: []
+  urls: [],
+  studyInstanceUIDMap: new Map() // map of urls to array of study instance UIDs
   // {
   //   url: url1
   //   studies: [Study1, Study2], // if multiple studies
@@ -1403,17 +1436,17 @@ const findStudies = (key, value) => {
 };
 function createDicomJSONApi(dicomJsonConfig) {
   const {
-    name,
     wadoRoot
   } = dicomJsonConfig;
   const implementation = {
     initialize: async _ref => {
       let {
-        params,
         query,
         url
       } = _ref;
-      if (!url) url = query.get('url');
+      if (!url) {
+        url = query.get('url');
+      }
       let metaData = getMetaDataByURL(url);
 
       // if we have already cached the data from this specific url
@@ -1425,8 +1458,7 @@ function createDicomJSONApi(dicomJsonConfig) {
         });
       }
       const response = await fetch(url);
-      let data = await response.json();
-      const studyInstanceUIDs = data.studies.map(study => study.StudyInstanceUID);
+      const data = await response.json();
       let StudyInstanceUID;
       let SeriesInstanceUID;
       data.studies.forEach(study => {
@@ -1452,7 +1484,7 @@ function createDicomJSONApi(dicomJsonConfig) {
         url,
         studies: [...data.studies]
       });
-      return studyInstanceUIDs;
+      _store.studyInstanceUIDMap.set(url, data.studies.map(study => study.StudyInstanceUID));
     },
     query: {
       studies: {
@@ -1561,7 +1593,9 @@ function createDicomJSONApi(dicomJsonConfig) {
               return obj;
             });
             storeInstances(instances);
-            if (index === numberOfSeries - 1) setSuccessFlag();
+            if (index === numberOfSeries - 1) {
+              setSuccessFlag();
+            }
           });
         }
       }
@@ -1608,6 +1642,14 @@ function createDicomJSONApi(dicomJsonConfig) {
         frame
       });
       return imageIds;
+    },
+    getStudyInstanceUIDs: _ref3 => {
+      let {
+        params,
+        query
+      } = _ref3;
+      const url = query.get('url');
+      return _store.studyInstanceUIDMap.get(url);
     }
   };
   return src/* IWebApiDataSource */.Is.create(implementation);
@@ -1628,8 +1670,12 @@ const END_MODALITIES = {
 };
 const compareValue = function (v1, v2) {
   let def = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  if (v1 === v2) return def;
-  if (v1 < v2) return -1;
+  if (v1 === v2) {
+    return def;
+  }
+  if (v1 < v2) {
+    return -1;
+  }
   return 1;
 };
 
@@ -1660,19 +1706,6 @@ function createDicomLocalApi(dicomLocalConfig) {
         params,
         query
       } = _ref;
-      const {
-        StudyInstanceUIDs: paramsStudyInstanceUIDs
-      } = params;
-      const queryStudyInstanceUIDs = query.getAll('StudyInstanceUIDs');
-      const StudyInstanceUIDs = queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
-      const StudyInstanceUIDsAsArray = StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs) ? StudyInstanceUIDs : [StudyInstanceUIDs];
-
-      // Put SRs at the end of series list to make sure images are loaded first
-      StudyInstanceUIDsAsArray.forEach(StudyInstanceUID => {
-        const study = src.DicomMetadataStore.getStudy(StudyInstanceUID);
-        study.series = study.series.sort(customSort);
-      });
-      return StudyInstanceUIDsAsArray;
     },
     query: {
       studies: {
@@ -1854,6 +1887,29 @@ function createDicomLocalApi(dicomLocalConfig) {
     },
     deleteStudyMetadataPromise() {
       console.log('deleteStudyMetadataPromise not implemented');
+    },
+    getStudyInstanceUIDs: _ref3 => {
+      let {
+        params,
+        query
+      } = _ref3;
+      const {
+        StudyInstanceUIDs: paramsStudyInstanceUIDs
+      } = params;
+      const queryStudyInstanceUIDs = query.getAll('StudyInstanceUIDs');
+      const StudyInstanceUIDs = queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
+      const StudyInstanceUIDsAsArray = StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs) ? StudyInstanceUIDs : [StudyInstanceUIDs];
+
+      // Put SRs at the end of series list to make sure images are loaded first
+      let isStudyInCache = false;
+      StudyInstanceUIDsAsArray.forEach(StudyInstanceUID => {
+        const study = src.DicomMetadataStore.getStudy(StudyInstanceUID);
+        if (study) {
+          study.series = study.series.sort(customSort);
+          isStudyInCache = true;
+        }
+      });
+      return isStudyInCache ? StudyInstanceUIDsAsArray : [];
     }
   };
   return src/* IWebApiDataSource */.Is.create(implementation);
@@ -1882,13 +1938,6 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
         params,
         query
       } = _ref;
-      let studyInstanceUIDs = [];
-
-      // there seem to be a couple of variations of the case for this parameter
-      const queryStudyInstanceUIDs = query.get('studyInstanceUIDs') || query.get('studyInstanceUids');
-      if (!queryStudyInstanceUIDs) {
-        throw new Error(`No studyInstanceUids in request for '${name}'`);
-      }
       const url = query.get('url');
       if (!url) {
         throw new Error(`No url for '${name}'`);
@@ -1898,10 +1947,12 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
         if (!data.servers?.dicomWeb?.[0]) {
           throw new Error('Invalid configuration returned by url');
         }
-        dicomWebDelegate = createDicomWebApi(data.servers.dicomWeb[0], UserAuthenticationService);
-        studyInstanceUIDs = queryStudyInstanceUIDs.split(';');
+        dicomWebDelegate = createDicomWebApi(data.servers.dicomWeb[0].configuration, UserAuthenticationService);
+        dicomWebDelegate.initialize({
+          params,
+          query
+        });
       }
-      return studyInstanceUIDs;
     },
     query: {
       studies: {
@@ -1939,6 +1990,21 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
     },
     getImageIdsForInstance: function () {
       return dicomWebDelegate.getImageIdsForInstance(...arguments);
+    },
+    getStudyInstanceUIDs(_ref2) {
+      let {
+        params,
+        query
+      } = _ref2;
+      let studyInstanceUIDs = [];
+
+      // there seem to be a couple of variations of the case for this parameter
+      const queryStudyInstanceUIDs = query.get('studyInstanceUIDs') || query.get('studyInstanceUids');
+      if (!queryStudyInstanceUIDs) {
+        throw new Error(`No studyInstanceUids in request for '${name}'`);
+      }
+      studyInstanceUIDs = queryStudyInstanceUIDs.split(';');
+      return studyInstanceUIDs;
     }
   };
   return src/* IWebApiDataSource */.Is.create(implementation);
@@ -1978,24 +2044,24 @@ function getDataSourcesModule() {
 }
 /* harmony default export */ const src_getDataSourcesModule = (getDataSourcesModule);
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
-var react = __webpack_require__(32735);
+var react = __webpack_require__(43001);
 // EXTERNAL MODULE: ../../../node_modules/prop-types/index.js
-var prop_types = __webpack_require__(60216);
+var prop_types = __webpack_require__(3827);
 var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
 // EXTERNAL MODULE: ../node_modules/react-router-dom/dist/index.js
-var dist = __webpack_require__(65783);
+var dist = __webpack_require__(62474);
 // EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules
-var es = __webpack_require__(21572);
+var es = __webpack_require__(69190);
 // EXTERNAL MODULE: ../node_modules/react-router/dist/index.js
-var react_router_dist = __webpack_require__(14935);
-// EXTERNAL MODULE: ../../ui/src/index.js + 452 modules
-var ui_src = __webpack_require__(28619);
-// EXTERNAL MODULE: ../../i18n/src/index.js + 95 modules
-var i18n_src = __webpack_require__(93058);
+var react_router_dist = __webpack_require__(85066);
+// EXTERNAL MODULE: ../../ui/src/index.js + 458 modules
+var ui_src = __webpack_require__(33570);
+// EXTERNAL MODULE: ../../i18n/src/index.js + 98 modules
+var i18n_src = __webpack_require__(43040);
 // EXTERNAL MODULE: ./state/index.js + 1 modules
-var state = __webpack_require__(22896);
+var state = __webpack_require__(62657);
 // EXTERNAL MODULE: ../../../node_modules/classnames/index.js
-var classnames = __webpack_require__(40841);
+var classnames = __webpack_require__(44921);
 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); }
@@ -2030,7 +2096,7 @@ function Toolbar(_ref) {
       unsub2();
     };
   }, [toolbarService]);
-  return /*#__PURE__*/react.createElement(react.Fragment, null, toolbarButtons.map((toolDef, index) => {
+  return /*#__PURE__*/react.createElement(react.Fragment, null, toolbarButtons.map(toolDef => {
     const {
       id,
       Component,
@@ -2116,8 +2182,10 @@ function ViewerLayout(_ref) {
     // Todo: Handle parameters in a better way.
     const query = new URLSearchParams(window.location.search);
     const configUrl = query.get('configUrl');
+    const dataSourceName = pathname.substring(dataSourceIdx + 1);
+    const existingDataSource = extensionManager.getDataSources(dataSourceName);
     const searchQuery = new URLSearchParams();
-    if (dataSourceIdx !== -1) {
+    if (dataSourceIdx !== -1 && existingDataSource) {
       searchQuery.append('datasources', pathname.substring(dataSourceIdx + 1));
     }
     if (configUrl) {
@@ -2143,8 +2211,8 @@ function ViewerLayout(_ref) {
     hotkeyDefinitions,
     hotkeyDefaults
   } = hotkeysManager;
-  const versionNumber = "3.7.0-beta.6";
-  const commitHash = "e6f73a202501898856ad3edad3c395b8e030d11a";
+  const versionNumber = "3.7.0-beta.61";
+  const commitHash = "35fc30c5359d8199cc38ffa670c08687d2672f11";
   const menuOptions = [{
     title: t('Header:About'),
     icon: 'info',
@@ -2364,6 +2432,7 @@ ViewerLayout.propTypes = {
 
 
 
+
 const {
   sortStudyInstances,
   formatDate
@@ -2386,6 +2455,8 @@ function PanelStudyBrowser(_ref) {
     displaySetService,
     uiNotificationService
   } = servicesManager.services;
+  const navigate = (0,dist/* useNavigate */.s0)();
+
   // Normally you nest the components so the tree isn't so deep, and the data
   // doesn't have to have such an intense shape. This works well enough for now.
   // Tabs --> Studies --> DisplaySets --> Thumbnails
@@ -2427,6 +2498,10 @@ function PanelStudyBrowser(_ref) {
       const qidoForStudyUID = await dataSource.query.studies.search({
         studyInstanceUid: StudyInstanceUID
       });
+      if (!qidoForStudyUID?.length) {
+        navigate('/notfoundstudy', '_self');
+        throw new Error('Invalid study URL');
+      }
       let qidoStudiesForPatient = qidoForStudyUID;
 
       // try to fetch the prior studies based on the patientID if the
@@ -2470,7 +2545,7 @@ function PanelStudyBrowser(_ref) {
       const imageId = imageIds[Math.floor(imageIds.length / 2)];
 
       // TODO: Is it okay that imageIds are not returned here for SR displaySets?
-      if (imageId) {
+      if (imageId && !displaySet?.unsupported) {
         // When the image arrives, render it and store the result in the thumbnailImgSrcMap
         newImageSrcEntry[dSet.displaySetInstanceUID] = await getImageSrc(imageId);
         if (isMounted.current) {
@@ -2509,20 +2584,22 @@ function PanelStudyBrowser(_ref) {
       displaySetsAdded.forEach(async dSet => {
         const newImageSrcEntry = {};
         const displaySet = displaySetService.getDisplaySetByUID(dSet.displaySetInstanceUID);
-        const imageIds = dataSource.getImageIdsForDisplaySet(displaySet);
-        const imageId = imageIds[Math.floor(imageIds.length / 2)];
-
-        // TODO: Is it okay that imageIds are not returned here for SR displaysets?
-        if (imageId) {
-          // When the image arrives, render it and store the result in the thumbnailImgSrcMap
-          newImageSrcEntry[dSet.displaySetInstanceUID] = await getImageSrc(imageId, dSet.initialViewport);
-          if (isMounted.current) {
-            setThumbnailImageSrcMap(prevState => {
-              return {
-                ...prevState,
-                ...newImageSrcEntry
-              };
-            });
+        if (!displaySet?.unsupported) {
+          const imageIds = dataSource.getImageIdsForDisplaySet(displaySet);
+          const imageId = imageIds[Math.floor(imageIds.length / 2)];
+
+          // TODO: Is it okay that imageIds are not returned here for SR displaysets?
+          if (imageId) {
+            // When the image arrives, render it and store the result in the thumbnailImgSrcMap
+            newImageSrcEntry[dSet.displaySetInstanceUID] = await getImageSrc(imageId, dSet.initialViewport);
+            if (isMounted.current) {
+              setThumbnailImageSrcMap(prevState => {
+                return {
+                  ...prevState,
+                  ...newImageSrcEntry
+                };
+              });
+            }
           }
         }
       });
@@ -2534,9 +2611,14 @@ function PanelStudyBrowser(_ref) {
       const mappedDisplaySets = _mapDisplaySets(changedDisplaySets, thumbnailImageSrcMap);
       setDisplaySets(mappedDisplaySets);
     });
+    const SubscriptionDisplaySetMetaDataInvalidated = displaySetService.subscribe(displaySetService.EVENTS.DISPLAY_SET_SERIES_METADATA_INVALIDATED, () => {
+      const mappedDisplaySets = _mapDisplaySets(displaySetService.getActiveDisplaySets(), thumbnailImageSrcMap);
+      setDisplaySets(mappedDisplaySets);
+    });
     return () => {
       SubscriptionDisplaySetsAdded.unsubscribe();
       SubscriptionDisplaySetsChanged.unsubscribe();
+      SubscriptionDisplaySetMetaDataInvalidated.unsubscribe();
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
@@ -2605,7 +2687,7 @@ function _mapDisplaySets(displaySets, thumbnailImageSrcMap) {
   const thumbnailNoImageDisplaySets = [];
   displaySets.filter(ds => !ds.excludeFromThumbnailBrowser).forEach(ds => {
     const imageSrc = thumbnailImageSrcMap[ds.displaySetInstanceUID];
-    const componentType = _getComponentType(ds.Modality);
+    const componentType = _getComponentType(ds);
     const array = componentType === 'thumbnail' ? thumbnailDisplaySets : thumbnailNoImageDisplaySets;
     array.push({
       displaySetInstanceUID: ds.displaySetInstanceUID,
@@ -2617,21 +2699,23 @@ function _mapDisplaySets(displaySets, thumbnailImageSrcMap) {
       numInstances: ds.numImageFrames,
       countIcon: ds.countIcon,
       StudyInstanceUID: ds.StudyInstanceUID,
+      messages: ds.messages,
       componentType,
       imageSrc,
       dragData: {
         type: 'displayset',
         displaySetInstanceUID: ds.displaySetInstanceUID
         // .. Any other data to pass
-      }
+      },
+
+      isHydratedForDerivedDisplaySet: ds.isHydrated
     });
   });
-
   return [...thumbnailDisplaySets, ...thumbnailNoImageDisplaySets];
 }
 const thumbnailNoImageModalities = ['SR', 'SEG', 'SM', 'RTSTRUCT', 'RTPLAN', 'RTDOSE'];
-function _getComponentType(Modality) {
-  if (thumbnailNoImageModalities.includes(Modality)) {
+function _getComponentType(ds) {
+  if (thumbnailNoImageModalities.includes(ds.Modality) || ds?.unsupported) {
     // TODO probably others.
     return 'thumbnailNoImage';
   }
@@ -2819,7 +2903,7 @@ ActionButtons.defaultProps = {
 };
 /* harmony default export */ const Panels_ActionButtons = (ActionButtons);
 // EXTERNAL MODULE: ../../../node_modules/lodash.debounce/index.js
-var lodash_debounce = __webpack_require__(40001);
+var lodash_debounce = __webpack_require__(8324);
 var lodash_debounce_default = /*#__PURE__*/__webpack_require__.n(lodash_debounce);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/Panels/createReportDialogPrompt.tsx
 /* eslint-disable react/display-name */
@@ -3336,7 +3420,9 @@ function _mapMeasurementToDisplay(measurement, index, types) {
   if (findingSites) {
     const siteText = [];
     findingSites.forEach(site => {
-      if (site?.text !== label) siteText.push(site.text);
+      if (site?.text !== label) {
+        siteText.push(site.text);
+      }
     });
     displayText = [...siteText, ...displayText];
   }
@@ -3403,119 +3489,424 @@ function getPanelModule(_ref) {
 }
 /* harmony default export */ const src_getPanelModule = (getPanelModule);
 // EXTERNAL MODULE: ../../core/src/utils/isImage.js
-var isImage = __webpack_require__(81596);
+var isImage = __webpack_require__(11835);
 // EXTERNAL MODULE: ../../core/src/utils/sopClassDictionary.js
-var sopClassDictionary = __webpack_require__(32746);
+var sopClassDictionary = __webpack_require__(24369);
 // EXTERNAL MODULE: ../../core/src/classes/ImageSet.ts
-var ImageSet = __webpack_require__(4797);
+var ImageSet = __webpack_require__(13950);
 // EXTERNAL MODULE: ../../core/src/utils/isDisplaySetReconstructable.js
-var isDisplaySetReconstructable = __webpack_require__(51227);
+var isDisplaySetReconstructable = __webpack_require__(89359);
 ;// CONCATENATED MODULE: ../../../extensions/default/package.json
 const package_namespaceObject = JSON.parse('{"u2":"@ohif/extension-default"}');
 ;// CONCATENATED MODULE: ../../../extensions/default/src/id.js
 
 const id = package_namespaceObject.u2;
 
-;// CONCATENATED MODULE: ../../../extensions/default/src/getSopClassHandlerModule.js
+// EXTERNAL MODULE: ../../core/src/utils/sortInstancesByPosition.ts
+var sortInstancesByPosition = __webpack_require__(87425);
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/checkMultiframe.ts
 
 
 
+/**
+ * Check various multi frame issues. It calls OHIF core functions
+ * @param {*} multiFrameInstance
+ * @param {*} warnings
+ */
+function checkMultiFrame(multiFrameInstance, messages) {
+  if (!(0,isDisplaySetReconstructable/* hasPixelMeasurements */.hu)(multiFrameInstance)) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MULTIFRAME_NO_PIXEL_MEASUREMENTS);
+  }
+  if (!(0,isDisplaySetReconstructable/* hasOrientation */.sb)(multiFrameInstance)) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MULTIFRAME_NO_ORIENTATION);
+  }
+  if (!(0,isDisplaySetReconstructable/* hasPosition */.kN)(multiFrameInstance)) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MULTIFRAME_NO_POSITION_INFORMATION);
+  }
+}
+// EXTERNAL MODULE: ../../core/src/utils/toNumber.js
+var toNumber = __webpack_require__(94972);
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageDimensionsEqual.ts
 
 
-const sopClassHandlerName = 'stack';
-const isMultiFrame = instance => {
-  return instance.NumberOfFrames > 1;
-};
-const makeDisplaySet = instances => {
-  const instance = instances[0];
-  const imageSet = new ImageSet/* default */.Z(instances);
-  const {
-    value: isReconstructable,
-    averageSpacingBetweenFrames
-  } = (0,isDisplaySetReconstructable/* default */.Z)(instances);
+/**
+ * Check if the frames in a series has different dimensions
+ * @param {*} instances
+ * @returns
+ */
+function areAllImageDimensionsEqual(instances) {
+  if (!instances?.length) {
+    return false;
+  }
+  const firstImage = instances[0];
+  const firstImageRows = (0,toNumber/* default */.Z)(firstImage.Rows);
+  const firstImageColumns = (0,toNumber/* default */.Z)(firstImage.Columns);
+  for (let i = 1; i < instances.length; i++) {
+    const instance = instances[i];
+    const {
+      Rows,
+      Columns
+    } = instance;
+    if (Rows !== firstImageRows || Columns !== firstImageColumns) {
+      return false;
+    }
+  }
+  return true;
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageComponentsEqual.ts
 
-  // set appropriate attributes to image set...
-  imageSet.setAttributes({
-    displaySetInstanceUID: imageSet.uid,
-    // create a local alias for the imageSet UID
-    SeriesDate: instance.SeriesDate,
-    SeriesTime: instance.SeriesTime,
-    SeriesInstanceUID: instance.SeriesInstanceUID,
-    StudyInstanceUID: instance.StudyInstanceUID,
-    SeriesNumber: instance.SeriesNumber || 0,
-    FrameRate: instance.FrameTime,
-    SOPClassUID: instance.SOPClassUID,
-    SeriesDescription: instance.SeriesDescription || '',
-    Modality: instance.Modality,
-    isMultiFrame: isMultiFrame(instance),
-    countIcon: isReconstructable ? 'icon-mpr' : undefined,
-    numImageFrames: instances.length,
-    SOPClassHandlerId: `${id}.sopClassHandlerModule.${sopClassHandlerName}`,
-    isReconstructable,
-    averageSpacingBetweenFrames: averageSpacingBetweenFrames || null
-  });
 
-  // Sort the images in this series if needed
-  const shallSort = true; //!OHIF.utils.ObjectPath.get(Meteor, 'settings.public.ui.sortSeriesByIncomingOrder');
-  if (shallSort) {
-    imageSet.sortBy((a, b) => {
-      // Sort by InstanceNumber (0020,0013)
-      return (parseInt(a.InstanceNumber) || 0) - (parseInt(b.InstanceNumber) || 0);
-    });
+/**
+ * Check if all voxels in series images has same number of components (samplesPerPixel)
+ * @param {*} instances
+ * @returns
+ */
+function areAllImageComponentsEqual(instances) {
+  if (!instances?.length) {
+    return false;
+  }
+  const firstImage = instances[0];
+  const firstImageSamplesPerPixel = (0,toNumber/* default */.Z)(firstImage.SamplesPerPixel);
+  for (let i = 1; i < instances.length; i++) {
+    const instance = instances[i];
+    const {
+      SamplesPerPixel
+    } = instance;
+    if (SamplesPerPixel !== firstImageSamplesPerPixel) {
+      return false;
+    }
   }
+  return true;
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageOrientationsEqual.ts
 
-  // Include the first image instance number (after sorted)
-  /*imageSet.setAttribute(
-    'instanceNumber',
-    imageSet.getImage(0).InstanceNumber
-  );*/
 
-  /*const isReconstructable = isDisplaySetReconstructable(series, instances);
-   imageSet.isReconstructable = isReconstructable.value;
-   if (isReconstructable.missingFrames) {
-    // TODO -> This is currently unused, but may be used for reconstructing
-    // Volumes with gaps later on.
-    imageSet.missingFrames = isReconstructable.missingFrames;
-  }*/
 
-  return imageSet;
-};
-const isSingleImageModality = modality => {
-  return modality === 'CR' || modality === 'MG' || modality === 'DX';
-};
-function getSopClassUids(instances) {
-  const uniqueSopClassUidsInSeries = new Set();
-  instances.forEach(instance => {
-    uniqueSopClassUidsInSeries.add(instance.SOPClassUID);
-  });
-  const sopClassUids = Array.from(uniqueSopClassUidsInSeries);
-  return sopClassUids;
+/**
+ * Check is the series has frames with different orientations
+ * @param {*} instances
+ * @returns
+ */
+function areAllImageOrientationsEqual(instances) {
+  if (!instances?.length) {
+    return false;
+  }
+  const firstImage = instances[0];
+  const firstImageOrientationPatient = (0,toNumber/* default */.Z)(firstImage.ImageOrientationPatient);
+  for (let i = 1; i < instances.length; i++) {
+    const instance = instances[i];
+    const imageOrientationPatient = (0,toNumber/* default */.Z)(instance.ImageOrientationPatient);
+    if (!(0,isDisplaySetReconstructable/* _isSameOrientation */.NB)(imageOrientationPatient, firstImageOrientationPatient)) {
+      return false;
+    }
+  }
+  return true;
 }
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 10 modules
+var esm = __webpack_require__(45451);
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/calculateScanAxisNormal.ts
+
 
 /**
- * Basic SOPClassHandler:
- * - For all Image types that are stackable, create
- *   a displaySet with a stack of images
- *
- * @param {Array} sopClassHandlerModules List of SOP Class Modules
- * @param {SeriesMetadata} series The series metadata object from which the display sets will be created
- * @returns {Array} The list of display sets created for the given series object
+ * Calculates the scanAxisNormal based on a image orientation vector extract from a frame
+ * @param {*} imageOrientation
+ * @returns
  */
-function getDisplaySetsFromSeries(instances) {
-  // If the series has no instances, stop here
-  if (!instances || !instances.length) {
-    throw new Error('No instances were provided');
-  }
-  const displaySets = [];
-  const sopClassUids = getSopClassUids(instances);
+function calculateScanAxisNormal(imageOrientation) {
+  const rowCosineVec = esm/* vec3.fromValues */.R3.fromValues(imageOrientation[0], imageOrientation[1], imageOrientation[2]);
+  const colCosineVec = esm/* vec3.fromValues */.R3.fromValues(imageOrientation[3], imageOrientation[4], imageOrientation[5]);
+  return esm/* vec3.cross */.R3.cross(esm/* vec3.create */.R3.create(), rowCosineVec, colCosineVec);
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImagePositionsEqual.ts
 
-  // Search through the instances (InstanceMetadata object) of this series
-  // Split Multi-frame instances and Single-image modalities
-  // into their own specific display sets. Place the rest of each
-  // series into another display set.
-  const stackableInstances = [];
-  instances.forEach(instance => {
-    // All imaging modalities must have a valid value for sopClassUid (x00080016) or rows (x00280010)
+
+
+
+
+/**
+ * Checks if there is a position shift between consecutive frames
+ * @param {*} previousPosition
+ * @param {*} actualPosition
+ * @param {*} scanAxisNormal
+ * @param {*} averageSpacingBetweenFrames
+ * @returns
+ */
+function _checkSeriesPositionShift(previousPosition, actualPosition, scanAxisNormal, averageSpacingBetweenFrames) {
+  // predicted position should be the previous position added by the multiplication
+  // of the scanAxisNormal and the average spacing between frames
+  const predictedPosition = esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(esm/* vec3.create */.R3.create(), previousPosition, scanAxisNormal, averageSpacingBetweenFrames);
+  return esm/* vec3.distance */.R3.distance(actualPosition, predictedPosition) > averageSpacingBetweenFrames;
+}
+
+/**
+ * Checks if a series has position shifts between consecutive frames
+ * @param {*} instances
+ * @returns
+ */
+function areAllImagePositionsEqual(instances) {
+  if (!instances?.length) {
+    return false;
+  }
+  const firstImageOrientationPatient = (0,toNumber/* default */.Z)(instances[0].ImageOrientationPatient);
+  const scanAxisNormal = calculateScanAxisNormal(firstImageOrientationPatient);
+  const firstImagePositionPatient = (0,toNumber/* default */.Z)(instances[0].ImagePositionPatient);
+  const lastIpp = (0,toNumber/* default */.Z)(instances[instances.length - 1].ImagePositionPatient);
+  const averageSpacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.Xn)(firstImagePositionPatient, lastIpp) / (instances.length - 1);
+  let previousImagePositionPatient = firstImagePositionPatient;
+  for (let i = 1; i < instances.length; i++) {
+    const instance = instances[i];
+    const imagePositionPatient = (0,toNumber/* default */.Z)(instance.ImagePositionPatient);
+    if (_checkSeriesPositionShift(previousImagePositionPatient, imagePositionPatient, scanAxisNormal, averageSpacingBetweenFrames)) {
+      return false;
+    }
+    previousImagePositionPatient = imagePositionPatient;
+  }
+  return true;
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageSpacingEqual.ts
+
+
+
+/**
+ * Checks if series has spacing issues
+ * @param {*} instances
+ * @param {*} warnings
+ */
+function areAllImageSpacingEqual(instances, messages) {
+  if (!instances?.length) {
+    return;
+  }
+  const firstImagePositionPatient = (0,toNumber/* default */.Z)(instances[0].ImagePositionPatient);
+  const lastIpp = (0,toNumber/* default */.Z)(instances[instances.length - 1].ImagePositionPatient);
+  const averageSpacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.Xn)(firstImagePositionPatient, lastIpp) / (instances.length - 1);
+  let previousImagePositionPatient = firstImagePositionPatient;
+  const issuesFound = [];
+  for (let i = 1; i < instances.length; i++) {
+    const instance = instances[i];
+    const imagePositionPatient = (0,toNumber/* default */.Z)(instance.ImagePositionPatient);
+    const spacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.Xn)(imagePositionPatient, previousImagePositionPatient);
+    const spacingIssue = (0,isDisplaySetReconstructable/* _getSpacingIssue */.bg)(spacingBetweenFrames, averageSpacingBetweenFrames);
+    if (spacingIssue) {
+      const issue = spacingIssue.issue;
+
+      // avoid multiple warning of the same thing
+      if (!issuesFound.includes(issue)) {
+        issuesFound.push(issue);
+        if (issue === isDisplaySetReconstructable/* reconstructionIssues */.e1.MISSING_FRAMES) {
+          messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MISSING_FRAMES);
+        } else if (issue === isDisplaySetReconstructable/* reconstructionIssues */.e1.IRREGULAR_SPACING) {
+          messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.IRREGULAR_SPACING);
+        }
+      }
+      // we just want to find issues not how many
+      if (issuesFound.length > 1) {
+        break;
+      }
+    }
+    previousImagePositionPatient = imagePositionPatient;
+  }
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/checkSingleFrames.ts
+
+
+
+
+
+
+
+/**
+ * Runs various checks in a single frame series
+ * @param {*} instances
+ * @param {*} warnings
+ */
+function checkSingleFrames(instances, messages) {
+  if (instances.length > 2) {
+    if (!areAllImageDimensionsEqual(instances)) {
+      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_DIMENSIONS);
+    }
+    if (!areAllImageComponentsEqual(instances)) {
+      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_COMPONENTS);
+    }
+    if (!areAllImageOrientationsEqual(instances)) {
+      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_ORIENTATIONS);
+    }
+    if (!areAllImagePositionsEqual(instances)) {
+      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_POSITION_INFORMATION);
+    }
+    areAllImageSpacingEqual(instances, messages);
+  }
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/getDisplaySetMessages.ts
+
+
+
+
+
+/**
+ * Checks if a series is reconstructable to a 3D volume.
+ *
+ * @param {Object[]} instances An array of `OHIFInstanceMetadata` objects.
+ */
+function getDisplaySetMessages(instances, isReconstructable) {
+  const messages = new src/* DisplaySetMessageList */.iK();
+  if (!instances.length) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.NO_VALID_INSTANCES);
+  }
+  const firstInstance = instances[0];
+  // Due to current requirements, LOCALIZER series doesn't have any messages
+  if (firstInstance.ImageType.includes('LOCALIZER')) {
+    return messages;
+  }
+  const Modality = firstInstance.Modality;
+  if (!isDisplaySetReconstructable/* constructableModalities */.M6.includes(Modality)) {
+    return messages;
+  }
+  const isMultiframe = firstInstance.NumberOfFrames > 1;
+  // Can't reconstruct if all instances don't have the ImagePositionPatient.
+  if (!isMultiframe && !instances.every(instance => instance.ImagePositionPatient)) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.NO_POSITION_INFORMATION);
+  }
+  const sortedInstances = (0,sortInstancesByPosition/* default */.Z)(instances);
+  isMultiframe ? checkMultiFrame(sortedInstances[0], messages) : checkSingleFrames(sortedInstances, messages);
+  if (!isReconstructable) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.NOT_RECONSTRUCTABLE);
+  }
+  return messages;
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/getDisplaySetsFromUnsupportedSeries.js
+
+
+/**
+ * Default handler for a instance list with an unsupported sopClassUID
+ */
+function getDisplaySetsFromUnsupportedSeries(instances) {
+  const imageSet = new ImageSet/* default */.Z(instances);
+  const messages = new src/* DisplaySetMessageList */.iK();
+  messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.UNSUPPORTED_DISPLAYSET);
+  const instance = instances[0];
+  imageSet.setAttributes({
+    displaySetInstanceUID: imageSet.uid,
+    // create a local alias for the imageSet UID
+    SeriesDate: instance.SeriesDate,
+    SeriesTime: instance.SeriesTime,
+    SeriesInstanceUID: instance.SeriesInstanceUID,
+    StudyInstanceUID: instance.StudyInstanceUID,
+    SeriesNumber: instance.SeriesNumber || 0,
+    FrameRate: instance.FrameTime,
+    SOPClassUID: instance.SOPClassUID,
+    SeriesDescription: instance.SeriesDescription || '',
+    Modality: instance.Modality,
+    numImageFrames: instances.length,
+    unsupported: true,
+    SOPClassHandlerId: 'unsupported',
+    isReconstructable: false,
+    messages
+  });
+  return [imageSet];
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/getSopClassHandlerModule.js
+
+
+
+
+
+
+
+const sopClassHandlerName = 'stack';
+const isMultiFrame = instance => {
+  return instance.NumberOfFrames > 1;
+};
+const makeDisplaySet = instances => {
+  const instance = instances[0];
+  const imageSet = new ImageSet/* default */.Z(instances);
+  const {
+    value: isReconstructable,
+    averageSpacingBetweenFrames
+  } = (0,isDisplaySetReconstructable/* default */.ZP)(instances);
+  // set appropriate attributes to image set...
+  const messages = getDisplaySetMessages(instances, isReconstructable);
+  imageSet.setAttributes({
+    displaySetInstanceUID: imageSet.uid,
+    // create a local alias for the imageSet UID
+    SeriesDate: instance.SeriesDate,
+    SeriesTime: instance.SeriesTime,
+    SeriesInstanceUID: instance.SeriesInstanceUID,
+    StudyInstanceUID: instance.StudyInstanceUID,
+    SeriesNumber: instance.SeriesNumber || 0,
+    FrameRate: instance.FrameTime,
+    SOPClassUID: instance.SOPClassUID,
+    SeriesDescription: instance.SeriesDescription || '',
+    Modality: instance.Modality,
+    isMultiFrame: isMultiFrame(instance),
+    countIcon: isReconstructable ? 'icon-mpr' : undefined,
+    numImageFrames: instances.length,
+    SOPClassHandlerId: `${id}.sopClassHandlerModule.${sopClassHandlerName}`,
+    isReconstructable,
+    messages,
+    averageSpacingBetweenFrames: averageSpacingBetweenFrames || null
+  });
+
+  // Sort the images in this series if needed
+  const shallSort = true; //!OHIF.utils.ObjectPath.get(Meteor, 'settings.public.ui.sortSeriesByIncomingOrder');
+  if (shallSort) {
+    imageSet.sortBy((a, b) => {
+      // Sort by InstanceNumber (0020,0013)
+      return (parseInt(a.InstanceNumber) || 0) - (parseInt(b.InstanceNumber) || 0);
+    });
+  }
+
+  // Include the first image instance number (after sorted)
+  /*imageSet.setAttribute(
+    'instanceNumber',
+    imageSet.getImage(0).InstanceNumber
+  );*/
+
+  /*const isReconstructable = isDisplaySetReconstructable(series, instances);
+   imageSet.isReconstructable = isReconstructable.value;
+   if (isReconstructable.missingFrames) {
+    // TODO -> This is currently unused, but may be used for reconstructing
+    // Volumes with gaps later on.
+    imageSet.missingFrames = isReconstructable.missingFrames;
+  }*/
+
+  return imageSet;
+};
+const isSingleImageModality = modality => {
+  return modality === 'CR' || modality === 'MG' || modality === 'DX';
+};
+function getSopClassUids(instances) {
+  const uniqueSopClassUidsInSeries = new Set();
+  instances.forEach(instance => {
+    uniqueSopClassUidsInSeries.add(instance.SOPClassUID);
+  });
+  const sopClassUids = Array.from(uniqueSopClassUidsInSeries);
+  return sopClassUids;
+}
+
+/**
+ * Basic SOPClassHandler:
+ * - For all Image types that are stackable, create
+ *   a displaySet with a stack of images
+ *
+ * @param {Array} sopClassHandlerModules List of SOP Class Modules
+ * @param {SeriesMetadata} series The series metadata object from which the display sets will be created
+ * @returns {Array} The list of display sets created for the given series object
+ */
+function getDisplaySetsFromSeries(instances) {
+  // If the series has no instances, stop here
+  if (!instances || !instances.length) {
+    throw new Error('No instances were provided');
+  }
+  const displaySets = [];
+  const sopClassUids = getSopClassUids(instances);
+
+  // Search through the instances (InstanceMetadata object) of this series
+  // Split Multi-frame instances and Single-image modalities
+  // into their own specific display sets. Place the rest of each
+  // series into another display set.
+  const stackableInstances = [];
+  instances.forEach(instance => {
+    // All imaging modalities must have a valid value for sopClassUid (x00080016) or rows (x00280010)
     if (!(0,isImage/* isImage */.O)(instance.SOPClassUID) && !instance.Rows) {
       return;
     }
@@ -3558,6 +3949,10 @@ function getSopClassHandlerModule() {
     name: sopClassHandlerName,
     sopClassUids,
     getDisplaySetsFromSeries
+  }, {
+    name: 'not-supported-display-sets-handler',
+    sopClassUids: [],
+    getDisplaySetsFromSeries: getDisplaySetsFromUnsupportedSeries
   }];
 }
 /* harmony default export */ const src_getSopClassHandlerModule = (getSopClassHandlerModule);
@@ -3856,7 +4251,7 @@ function adaptItem(item, subProps) {
   return newItem;
 }
 // EXTERNAL MODULE: ../../ui/src/components/ContextMenu/ContextMenu.tsx
-var ContextMenu = __webpack_require__(63021);
+var ContextMenu = __webpack_require__(5638);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/CustomizableContextMenu/ContextMenuController.tsx
 
 
@@ -4065,10 +4460,10 @@ const defaultContextMenu = {
 
 
 // EXTERNAL MODULE: ../../../node_modules/moment/moment.js
-var moment = __webpack_require__(53806);
+var moment = __webpack_require__(71271);
 var moment_default = /*#__PURE__*/__webpack_require__.n(moment);
 // EXTERNAL MODULE: ../../../node_modules/react-window/dist/index.esm.js
-var index_esm = __webpack_require__(21767);
+var index_esm = __webpack_require__(94614);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomTagBrowser/DicomTagTable.tsx
 
 
@@ -4266,7 +4661,6 @@ function DicomTagTable(_ref2) {
 
 
 
-
 const {
   ImageSet: DicomTagBrowser_ImageSet
 } = src.classes;
@@ -4295,7 +4689,6 @@ const DicomTagBrowser = _ref => {
     setSelectedDisplaySetInstanceUID(value.value);
     setInstanceNumber(1);
   };
-  const searchInputRef = (0,react.useRef)(null);
   const activeDisplaySet = displaySets.find(ds => ds.displaySetInstanceUID === selectedDisplaySetInstanceUID);
   const isImageStack = _isImageStack(activeDisplaySet);
   const showInstanceList = isImageStack && activeDisplaySet.images.length > 1;
@@ -4399,29 +4792,11 @@ const DicomTagBrowser = _ref => {
     className: "w-full h-1 bg-black"
   }), /*#__PURE__*/react.createElement("div", {
     className: "flex flex-row my-3 w-1/2"
-  }, /*#__PURE__*/react.createElement("label", {
-    className: "relative block w-full mr-8"
-  }, /*#__PURE__*/react.createElement("span", {
-    className: "absolute inset-y-0 left-0 flex items-center pl-2"
-  }, /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
-    name: "icon-search"
-  })), /*#__PURE__*/react.createElement("input", {
-    ref: searchInputRef,
-    type: "text",
-    className: "block bg-black w-full shadow transition duration-300 appearance-none border border-inputfield-main focus:border-inputfield-focus focus:outline-none disabled:border-inputfield-disabled rounded w-full py-2 px-9 text-base leading-tight placeholder:text-inputfield-placeholder",
+  }, /*#__PURE__*/react.createElement(ui_src/* InputFilterText */.Xe, {
+    className: "block w-full mr-8",
     placeholder: "Search metadata...",
-    onChange: event => debouncedSetFilterValue(event.target.value),
-    autoComplete: "off"
-  }), /*#__PURE__*/react.createElement("span", {
-    className: "absolute inset-y-0 right-0 flex items-center pr-2"
-  }, /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
-    name: "icon-clear-field",
-    className: classnames_default()('cursor-pointer', filterValue ? '' : 'hidden'),
-    onClick: () => {
-      searchInputRef.current.value = '';
-      debouncedSetFilterValue('');
-    }
-  })))), /*#__PURE__*/react.createElement(DicomTagBrowser_DicomTagTable, {
+    onDebounceChange: setFilterValue
+  })), /*#__PURE__*/react.createElement(DicomTagBrowser_DicomTagTable, {
     rows: filteredRows
   }));
 };
@@ -4637,10 +5012,14 @@ const reuseCachedLayout = (state, hangingProtocolService, syncService) => {
       displaySetOptions,
       displaySetInstanceUIDs
     } = viewport;
-    if (!displaySetOptions) continue;
+    if (!displaySetOptions) {
+      continue;
+    }
     for (let i = 0; i < displaySetOptions.length; i++) {
       const displaySetUID = displaySetInstanceUIDs[i];
-      if (!displaySetUID) continue;
+      if (!displaySetUID) {
+        continue;
+      }
       if (idx === activeViewportIndex && i === 0) {
         displaySetSelectorMap[`${activeStudyUID}:activeDisplaySet:0`] = displaySetUID;
       }
@@ -4673,9 +5052,11 @@ const reuseCachedLayout = (state, hangingProtocolService, syncService) => {
  */
 const findViewportsByPosition_findOrCreateViewport = (hangingProtocolService, viewportsByPosition, viewportIndex, positionId, options) => {
   const byPositionViewport = viewportsByPosition?.[positionId];
-  if (byPositionViewport) return {
-    ...byPositionViewport
-  };
+  if (byPositionViewport) {
+    return {
+      ...byPositionViewport
+    };
+  }
   const {
     protocolId,
     stageIndex
@@ -4756,8 +5137,8 @@ const findViewportsByPosition = (state, _ref, syncService) => {
   };
 };
 /* harmony default export */ const src_findViewportsByPosition = (findViewportsByPosition);
-// EXTERNAL MODULE: ./index.js + 32 modules
-var index = __webpack_require__(97837);
+// EXTERNAL MODULE: ./index.js + 33 modules
+var index = __webpack_require__(59754);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/commandsModule.ts
 
 
@@ -4859,7 +5240,9 @@ const commandsModule = _ref => {
         stage
       } = hangingProtocolService.getActiveProtocol();
       const enableListener = button => {
-        if (!button.id) return;
+        if (!button.id) {
+          return;
+        }
         const {
           commands,
           items
@@ -4868,7 +5251,9 @@ const commandsModule = _ref => {
           items.forEach(enableListener);
         }
         const hpCommand = commands?.find?.(isHangingProtocolCommand);
-        if (!hpCommand) return;
+        if (!hpCommand) {
+          return;
+        }
         const {
           protocolId,
           stageIndex,
@@ -5397,7 +5782,6 @@ const commandsModule = _ref => {
  * It is not included in the viewer mode by default.
  */
 const hpMN = {
-  hasUpdatedPriorsInformation: false,
   id: '@ohif/mnGrid',
   description: 'Has various hanging protocol grid layouts',
   name: '2x2',
@@ -5606,15 +5990,182 @@ const hpMN = {
   numberOfPriorsReferenced: -1
 };
 /* harmony default export */ const hpMNGrid = (hpMN);
+;// CONCATENATED MODULE: ../../../extensions/default/src/hpCompare.ts
+const defaultDisplaySetSelector = {
+  studyMatchingRules: [{
+    // The priorInstance is a study counter that indicates what position this study is in
+    // and the value comes from the options parameter.
+    attribute: 'studyInstanceUIDsIndex',
+    from: 'options',
+    required: true,
+    constraint: {
+      equals: {
+        value: 0
+      }
+    }
+  }],
+  seriesMatchingRules: [{
+    attribute: 'numImageFrames',
+    constraint: {
+      greaterThan: {
+        value: 0
+      }
+    }
+  },
+  // This display set will select the specified items by preference
+  // It has no affect if nothing is specified in the URL.
+  {
+    attribute: 'isDisplaySetFromUrl',
+    weight: 10,
+    constraint: {
+      equals: true
+    }
+  }]
+};
+const priorDisplaySetSelector = {
+  studyMatchingRules: [{
+    // The priorInstance is a study counter that indicates what position this study is in
+    // and the value comes from the options parameter.
+    attribute: 'studyInstanceUIDsIndex',
+    from: 'options',
+    required: true,
+    constraint: {
+      equals: {
+        value: 1
+      }
+    }
+  }],
+  seriesMatchingRules: [{
+    attribute: 'numImageFrames',
+    constraint: {
+      greaterThan: {
+        value: 0
+      }
+    }
+  },
+  // This display set will select the specified items by preference
+  // It has no affect if nothing is specified in the URL.
+  {
+    attribute: 'isDisplaySetFromUrl',
+    weight: 10,
+    constraint: {
+      equals: true
+    }
+  }]
+};
+const currentDisplaySet = {
+  id: 'defaultDisplaySetId'
+};
+const priorDisplaySet = {
+  id: 'priorDisplaySetId'
+};
+const currentViewport0 = {
+  viewportOptions: {
+    toolGroupId: 'default',
+    allowUnmatchedView: true
+  },
+  displaySets: [currentDisplaySet]
+};
+const currentViewport1 = {
+  ...currentViewport0,
+  displaySets: [{
+    ...currentDisplaySet,
+    matchedDisplaySetsIndex: 1
+  }]
+};
+const priorViewport0 = {
+  ...currentViewport0,
+  displaySets: [priorDisplaySet]
+};
+const priorViewport1 = {
+  ...priorViewport0,
+  displaySets: [{
+    ...priorDisplaySet,
+    matchedDisplaySetsIndex: 1
+  }]
+};
+
+/**
+ * This hanging protocol can be activated on the primary mode by directly
+ * referencing it in a URL or by directly including it within a mode, e.g.:
+ * `&hangingProtocolId=@ohif/mnGrid` added to the viewer URL
+ * It is not included in the viewer mode by default.
+ */
+const hpMNCompare = {
+  id: '@ohif/hpCompare',
+  description: 'Compare two studies in various layouts',
+  name: 'Compare Two Studies',
+  numberOfPriorsReferenced: 1,
+  protocolMatchingRules: [{
+    id: 'Two Studies',
+    weight: 1000,
+    attribute: 'StudyInstanceUID',
+    // The 'from' attribute says where to get the 'attribute' value from.  In this case
+    // prior means the second study in the study list.
+    from: 'prior',
+    required: true,
+    constraint: {
+      notNull: true
+    }
+  }],
+  toolGroupIds: ['default'],
+  displaySetSelectors: {
+    defaultDisplaySetId: defaultDisplaySetSelector,
+    priorDisplaySetId: priorDisplaySetSelector
+  },
+  defaultViewport: {
+    viewportOptions: {
+      viewportType: 'stack',
+      toolGroupId: 'default',
+      allowUnmatchedView: true
+    },
+    displaySets: [{
+      id: 'defaultDisplaySetId',
+      matchedDisplaySetsIndex: -1
+    }]
+  },
+  stages: [{
+    name: '2x2',
+    stageActivation: {
+      enabled: {
+        minViewportsMatched: 4
+      }
+    },
+    viewportStructure: {
+      layoutType: 'grid',
+      properties: {
+        rows: 2,
+        columns: 2
+      }
+    },
+    viewports: [currentViewport0, priorViewport0, currentViewport1, priorViewport1]
+  }, {
+    name: '2x1',
+    stageActivation: {
+      enabled: {
+        minViewportsMatched: 2
+      }
+    },
+    viewportStructure: {
+      layoutType: 'grid',
+      properties: {
+        rows: 1,
+        columns: 2
+      }
+    },
+    viewports: [currentViewport0, priorViewport0]
+  }]
+};
+/* harmony default export */ const hpCompare = (hpMNCompare);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getHangingProtocolModule.js
 
+
 const defaultProtocol = {
   id: 'default',
   locked: true,
   // Don't store this hanging protocol as it applies to the currently active
   // display set by default
   // cacheId: null,
-  hasUpdatedPriorsInformation: false,
   name: 'Default',
   createdDate: '2021-02-23T19:22:08.894Z',
   modifiedDate: '2023-04-01',
@@ -5708,6 +6259,11 @@ function getHangingProtocolModule() {
   {
     name: hpMNGrid.id,
     protocol: hpMNGrid
+  },
+  // Create a MxN comparison hanging protocol available by default
+  {
+    name: hpCompare.id,
+    protocol: hpCompare
   }];
 }
 /* harmony default export */ const src_getHangingProtocolModule = (getHangingProtocolModule);
@@ -5743,7 +6299,7 @@ function DataSourceSelector() {
     key: ds.sourceName
   }, /*#__PURE__*/react.createElement("h1", {
     className: "text-white"
-  }, ds.friendlyName), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
+  }, ds.configuration?.friendlyName || ds.friendlyName), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
     type: ui_src/* ButtonEnums.type */.LZ.U.primary,
     className: classnames_default()('ml-2'),
     onClick: () => {
@@ -5755,10 +6311,419 @@ function DataSourceSelector() {
   }, ds.sourceName), /*#__PURE__*/react.createElement("br", null)))))));
 }
 /* harmony default export */ const Panels_DataSourceSelector = (DataSourceSelector);
+;// CONCATENATED MODULE: ../../../extensions/default/src/Components/ItemListComponent.tsx
+
+
+
+
+function ItemListComponent(_ref) {
+  let {
+    itemLabel,
+    itemList,
+    onItemClicked
+  } = _ref;
+  const {
+    t
+  } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
+  const [filterValue, setFilterValue] = (0,react.useState)('');
+  (0,react.useEffect)(() => {
+    setFilterValue('');
+  }, [itemList]);
+  return /*#__PURE__*/react.createElement("div", {
+    className: "flex flex-col gap-4 min-h-[1px] grow"
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "flex justify-between items-center"
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "text-primary-light text-[20px]"
+  }, t(`Select ${itemLabel}`)), /*#__PURE__*/react.createElement(ui_src/* InputFilterText */.Xe, {
+    className: "grow max-w-[40%]",
+    value: filterValue,
+    onDebounceChange: setFilterValue,
+    placeholder: t(`Search ${itemLabel} list`)
+  })), /*#__PURE__*/react.createElement("div", {
+    className: "flex flex-col relative min-h-[1px] grow text-[14px] bg-black"
+  }, itemList == null ? /*#__PURE__*/react.createElement(ui_src/* LoadingIndicatorProgress */.LE, {
+    className: 'w-full h-full'
+  }) : itemList.length === 0 ? /*#__PURE__*/react.createElement("div", {
+    className: "flex flex-col h-full px-6 py-4 items-center justify-center text-primary-light"
+  }, /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+    name: "magnifier",
+    className: "mb-4"
+  }), /*#__PURE__*/react.createElement("span", null, t(`No ${itemLabel} available`))) : /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("div", {
+    className: "bg-secondary-dark text-white px-3 py-1.5"
+  }, t(itemLabel)), /*#__PURE__*/react.createElement("div", {
+    className: "overflow-auto ohif-scrollbar"
+  }, itemList.filter(item => !filterValue || item.name.toLowerCase().includes(filterValue.toLowerCase())).map(item => {
+    const border = 'rounded border-transparent border-b-secondary-light border-[1px] hover:border-primary-light';
+    return /*#__PURE__*/react.createElement("div", {
+      className: classnames_default()('group mx-2 px-6 py-2 flex justify-between items-center hover:text-primary-light hover:bg-primary-dark', border),
+      key: item.id
+    }, /*#__PURE__*/react.createElement("div", null, item.name), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
+      onClick: () => onItemClicked(item),
+      className: "invisible group-hover:visible",
+      endIcon: /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+        name: "arrow-left"
+      })
+    }, t('Select')));
+  })))));
+}
+/* harmony default export */ const Components_ItemListComponent = (ItemListComponent);
+;// CONCATENATED MODULE: ../../../extensions/default/src/Components/DataSourceConfigurationModalComponent.tsx
+
+
+
+
+
+const NO_WRAP_ELLIPSIS_CLASS_NAMES = 'text-ellipsis whitespace-nowrap overflow-hidden';
+function DataSourceConfigurationModalComponent(_ref) {
+  let {
+    configurationAPI,
+    configuredItems,
+    onHide
+  } = _ref;
+  const {
+    t
+  } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
+  const [itemList, setItemList] = (0,react.useState)();
+  const [selectedItems, setSelectedItems] = (0,react.useState)(configuredItems);
+
+  // Determines whether to show the full configuration for the data source.
+  // This typically occurs when the configuration component is first displayed.
+  const [showFullConfig, setShowFullConfig] = (0,react.useState)(true);
+  const [errorMessage, setErrorMessage] = (0,react.useState)();
+  const [itemLabels] = (0,react.useState)(configurationAPI.getItemLabels());
+
+  /**
+   * The index of the selected item that is considered current and for which
+   * its sub-items should be displayed in the items list component. When the
+   * full/existing configuration for a data source is to be shown, the current
+   * selected item is the second to last in the `selectedItems` list.
+   */
+  const currentSelectedItemIndex = showFullConfig ? selectedItems.length - 2 : selectedItems.length - 1;
+  (0,react.useEffect)(() => {
+    let shouldUpdate = true;
+    setErrorMessage(null);
+
+    // Clear out the former/old list while we fetch the next sub item list.
+    setItemList(null);
+    if (selectedItems.length === 0) {
+      configurationAPI.initialize().then(items => {
+        if (shouldUpdate) {
+          setItemList(items);
+        }
+      }).catch(error => setErrorMessage(error.message));
+    } else if (!showFullConfig && selectedItems.length === itemLabels.length) {
+      // The last item to configure the data source (path) has been selected.
+      configurationAPI.setCurrentItem(selectedItems[selectedItems.length - 1]);
+      // We can hide the modal dialog now.
+      onHide();
+    } else {
+      configurationAPI.setCurrentItem(selectedItems[currentSelectedItemIndex]).then(items => {
+        if (shouldUpdate) {
+          setItemList(items);
+        }
+      }).catch(error => setErrorMessage(error.message));
+    }
+    return () => {
+      shouldUpdate = false;
+    };
+  }, [selectedItems, configurationAPI, onHide, itemLabels, showFullConfig, currentSelectedItemIndex]);
+  const getSelectedItemCursorClasses = itemIndex => itemIndex !== itemLabels.length - 1 && itemIndex < selectedItems.length ? 'cursor-pointer' : 'cursor-auto';
+  const getSelectedItemBackgroundClasses = itemIndex => itemIndex < selectedItems.length ? classnames_default()('bg-black/[.4]', itemIndex !== itemLabels.length - 1 ? 'hover:bg-transparent active:bg-secondary-dark' : '') : 'bg-transparent';
+  const getSelectedItemBorderClasses = itemIndex => itemIndex === currentSelectedItemIndex + 1 ? classnames_default()('border-2', 'border-solid', 'border-primary-light') : itemIndex < selectedItems.length ? 'border border-solid border-primary-active hover:border-primary-light active:border-white' : 'border border-dashed border-secondary-light';
+  const getSelectedItemTextClasses = itemIndex => itemIndex <= selectedItems.length ? 'text-primary-light' : 'text-primary-active';
+  const getErrorComponent = () => {
+    return /*#__PURE__*/react.createElement("div", {
+      className: "flex flex-col gap-4 min-h-[1px] grow"
+    }, /*#__PURE__*/react.createElement("div", {
+      className: "text-primary-light text-[20px]"
+    }, t(`Error fetching ${itemLabels[selectedItems.length]} list`)), /*#__PURE__*/react.createElement("div", {
+      className: "bg-black text-[14px] grow p-4"
+    }, errorMessage));
+  };
+  const getSelectedItemsComponent = () => {
+    return /*#__PURE__*/react.createElement("div", {
+      className: "flex gap-4"
+    }, itemLabels.map((itemLabel, itemLabelIndex) => {
+      return /*#__PURE__*/react.createElement("div", {
+        key: itemLabel,
+        className: classnames_default()('rounded-md p-3.5 flex flex-col gap-1 shrink min-w-[1px] basis-[200px]', getSelectedItemCursorClasses(itemLabelIndex), getSelectedItemBackgroundClasses(itemLabelIndex), getSelectedItemBorderClasses(itemLabelIndex), getSelectedItemTextClasses(itemLabelIndex)),
+        onClick: showFullConfig && itemLabelIndex < currentSelectedItemIndex || itemLabelIndex <= currentSelectedItemIndex ? () => {
+          setShowFullConfig(false);
+          setSelectedItems(theList => theList.slice(0, itemLabelIndex));
+        } : undefined
+      }, /*#__PURE__*/react.createElement("div", {
+        className: "flex gap-2 items-center text-"
+      }, itemLabelIndex < selectedItems.length ? /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+        name: "status-tracked"
+      }) : /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+        name: "status-untracked"
+      }), /*#__PURE__*/react.createElement("div", {
+        className: classnames_default()(NO_WRAP_ELLIPSIS_CLASS_NAMES)
+      }, t(itemLabel))), itemLabelIndex < selectedItems.length ? /*#__PURE__*/react.createElement("div", {
+        className: classnames_default()('text-white text-[14px]', NO_WRAP_ELLIPSIS_CLASS_NAMES)
+      }, selectedItems[itemLabelIndex].name) : /*#__PURE__*/react.createElement("br", null));
+    }));
+  };
+  return /*#__PURE__*/react.createElement("div", {
+    className: "h-[calc(100vh-300px)] flex flex-col pt-0.5 gap-4 select-none"
+  }, getSelectedItemsComponent(), /*#__PURE__*/react.createElement("div", {
+    className: "w-full h-0.5 shrink-0 bg-black"
+  }), errorMessage ? getErrorComponent() : /*#__PURE__*/react.createElement(Components_ItemListComponent, {
+    itemLabel: itemLabels[currentSelectedItemIndex + 1],
+    itemList: itemList,
+    onItemClicked: item => {
+      setShowFullConfig(false);
+      setSelectedItems(theList => [...theList.slice(0, currentSelectedItemIndex + 1), item]);
+    }
+  }));
+}
+/* harmony default export */ const Components_DataSourceConfigurationModalComponent = (DataSourceConfigurationModalComponent);
+;// CONCATENATED MODULE: ../../../extensions/default/src/Components/DataSourceConfigurationComponent.tsx
+
+
+
+
+function DataSourceConfigurationComponent(_ref) {
+  let {
+    servicesManager,
+    extensionManager
+  } = _ref;
+  const {
+    t
+  } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
+  const {
+    show,
+    hide
+  } = (0,ui_src/* useModal */.dd)();
+  const {
+    customizationService
+  } = servicesManager.services;
+  const [configurationAPI, setConfigurationAPI] = (0,react.useState)();
+  const [configuredItems, setConfiguredItems] = (0,react.useState)();
+  (0,react.useEffect)(() => {
+    let shouldUpdate = true;
+    const dataSourceChangedCallback = async () => {
+      const activeDataSourceDef = extensionManager.getActiveDataSourceDefinition();
+      if (!activeDataSourceDef.configuration.configurationAPI) {
+        return;
+      }
+      const {
+        factory: configurationAPIFactory
+      } = customizationService.get(activeDataSourceDef.configuration.configurationAPI) ?? {};
+      if (!configurationAPIFactory) {
+        return;
+      }
+      const configAPI = configurationAPIFactory(activeDataSourceDef.sourceName);
+      setConfigurationAPI(configAPI);
+      configAPI.getConfiguredItems().then(list => {
+        if (shouldUpdate) {
+          setConfiguredItems(list);
+        }
+      });
+    };
+    const sub = extensionManager.subscribe(extensionManager.EVENTS.ACTIVE_DATA_SOURCE_CHANGED, dataSourceChangedCallback);
+    dataSourceChangedCallback();
+    return () => {
+      shouldUpdate = false;
+      sub.unsubscribe();
+    };
+  }, []);
+  return configuredItems ? /*#__PURE__*/react.createElement("div", {
+    className: "flex text-aqua-pale overflow-hidden items-center"
+  }, /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+    name: "settings",
+    className: "cursor-pointer shrink-0 w-3.5 h-3.5 mr-2.5",
+    onClick: () => show({
+      content: Components_DataSourceConfigurationModalComponent,
+      title: t('Configure Data Source'),
+      contentProps: {
+        configurationAPI,
+        configuredItems,
+        onHide: hide
+      }
+    })
+  }), configuredItems.map((item, itemIndex) => {
+    return /*#__PURE__*/react.createElement("div", {
+      key: itemIndex,
+      className: "flex overflow-hidden"
+    }, /*#__PURE__*/react.createElement("div", {
+      key: itemIndex,
+      className: "text-ellipsis whitespace-nowrap overflow-hidden"
+    }, item.name), itemIndex !== configuredItems.length - 1 && /*#__PURE__*/react.createElement("div", {
+      className: "px-2.5"
+    }, "|"));
+  })) : /*#__PURE__*/react.createElement(react.Fragment, null);
+}
+/* harmony default export */ const Components_DataSourceConfigurationComponent = (DataSourceConfigurationComponent);
+;// CONCATENATED MODULE: ../../../extensions/default/src/DataSourceConfigurationAPI/GoogleCloudDataSourceConfigurationAPI.ts
+/**
+ * This file contains the implementations of BaseDataSourceConfigurationAPIItem
+ * and BaseDataSourceConfigurationAPI for the Google cloud healthcare API. To
+ * better understand this implementation and/or to implement custom implementations,
+ * see the platform\core\src\types\DataSourceConfigurationAPI.ts and its JS doc
+ * comments as a guide.
+ */
+/**
+ * The various Google Cloud Healthcare path item types.
+ */
+var ItemType = /*#__PURE__*/function (ItemType) {
+  ItemType[ItemType["projects"] = 0] = "projects";
+  ItemType[ItemType["locations"] = 1] = "locations";
+  ItemType[ItemType["datasets"] = 2] = "datasets";
+  ItemType[ItemType["dicomStores"] = 3] = "dicomStores";
+  return ItemType;
+}(ItemType || {});
+const initialUrl = 'https://cloudresourcemanager.googleapis.com/v1';
+const baseHealthcareUrl = 'https://healthcare.googleapis.com/v1';
+class GoogleCloudDataSourceConfigurationAPIItem {
+  constructor() {
+    this.id = void 0;
+    this.name = void 0;
+    this.url = void 0;
+    this.itemType = void 0;
+  }
+}
+class GoogleCloudDataSourceConfigurationAPI {
+  constructor(dataSourceName, servicesManager, extensionManager) {
+    this._extensionManager = void 0;
+    this._fetchOptions = void 0;
+    this._dataSourceName = void 0;
+    this.getItemLabels = () => ['Project', 'Location', 'Data set', 'DICOM store'];
+    this._dataSourceName = dataSourceName;
+    this._extensionManager = extensionManager;
+    const userAuthenticationService = servicesManager.services.userAuthenticationService;
+    this._fetchOptions = {
+      method: 'GET',
+      headers: userAuthenticationService.getAuthorizationHeader()
+    };
+  }
+  async initialize() {
+    const url = `${initialUrl}/projects`;
+    const projects = await GoogleCloudDataSourceConfigurationAPI._doFetch(url, ItemType.projects, this._fetchOptions);
+    if (!projects?.length) {
+      return [];
+    }
+    const projectItems = projects.map(project => {
+      return {
+        id: project.projectId,
+        name: project.name,
+        itemType: ItemType.projects,
+        url: `${baseHealthcareUrl}/projects/${project.projectId}`
+      };
+    });
+    return projectItems;
+  }
+  async setCurrentItem(anItem) {
+    const googleCloudItem = anItem;
+    if (googleCloudItem.itemType === ItemType.dicomStores) {
+      // Last configurable item, so update the data source configuration.
+      const url = `${googleCloudItem.url}/dicomWeb`;
+      const dataSourceDefCopy = JSON.parse(JSON.stringify(this._extensionManager.getDataSourceDefinition(this._dataSourceName)));
+      dataSourceDefCopy.configuration = {
+        ...dataSourceDefCopy.configuration,
+        wadoUriRoot: url,
+        qidoRoot: url,
+        wadoRoot: url
+      };
+      this._extensionManager.updateDataSourceConfiguration(dataSourceDefCopy.sourceName, dataSourceDefCopy.configuration);
+      return [];
+    }
+    const subItemType = googleCloudItem.itemType + 1;
+    const subItemField = `${ItemType[subItemType]}`;
+    const url = `${googleCloudItem.url}/${subItemField}`;
+    const fetchedSubItems = await GoogleCloudDataSourceConfigurationAPI._doFetch(url, subItemType, this._fetchOptions);
+    if (!fetchedSubItems?.length) {
+      return [];
+    }
+    const subItems = fetchedSubItems.map(subItem => {
+      const nameSplit = subItem.name.split('/');
+      return {
+        id: subItem.name,
+        name: nameSplit[nameSplit.length - 1],
+        itemType: subItemType,
+        url: `${baseHealthcareUrl}/${subItem.name}`
+      };
+    });
+    return subItems;
+  }
+  async getConfiguredItems() {
+    const dataSourceDefinition = this._extensionManager.getDataSourceDefinition(this._dataSourceName);
+    const url = dataSourceDefinition.configuration.wadoUriRoot;
+    const projectsIndex = url.indexOf('projects');
+    const urlSplit = url.substring(projectsIndex).split('/');
+    const configuredItems = [];
+    for (let itemType = 0; itemType < 4; itemType += 1) {
+      if (itemType === ItemType.projects) {
+        const projectId = urlSplit[1];
+        const projectUrl = `${initialUrl}/projects/${projectId}`;
+        const data = await GoogleCloudDataSourceConfigurationAPI._doFetch(projectUrl, ItemType.projects, this._fetchOptions);
+        const project = data[0];
+        configuredItems.push({
+          id: project.projectId,
+          name: project.name,
+          itemType: itemType,
+          url: `${baseHealthcareUrl}/projects/${project.projectId}`
+        });
+      } else {
+        const relativePath = urlSplit.slice(0, itemType * 2 + 2).join('/');
+        configuredItems.push({
+          id: relativePath,
+          name: urlSplit[itemType * 2 + 1],
+          itemType: itemType,
+          url: `${baseHealthcareUrl}/${relativePath}`
+        });
+      }
+    }
+    return configuredItems;
+  }
+
+  /**
+   * Fetches an array of items the specified item type.
+   * @param urlStr the fetch url
+   * @param fetchItemType the type to fetch
+   * @param fetchOptions the header options for the fetch (e.g. authorization header)
+   * @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] : {};
+    try {
+      const url = new URL(urlStr);
+      url.search = new URLSearchParams(fetchSearchParams).toString();
+      const response = await fetch(url, fetchOptions);
+      const data = await response.json();
+      if (response.status >= 200 && response.status < 300 && data != null) {
+        if (data.nextPageToken != null) {
+          fetchSearchParams.pageToken = data.nextPageToken;
+          const subPageData = await this._doFetch(urlStr, fetchItemType, fetchOptions, fetchSearchParams);
+          data[ItemType[fetchItemType]] = data[ItemType[fetchItemType]].concat(subPageData);
+        }
+        if (data[ItemType[fetchItemType]]) {
+          return data[ItemType[fetchItemType]];
+        } else if (data.name) {
+          return [data];
+        } else {
+          return [];
+        }
+      } else {
+        const message = data?.error?.message || `Error returned from Google Cloud Healthcare: ${response.status} - ${response.statusText}`;
+        throw new Error(message);
+      }
+    } catch (err) {
+      const message = err?.message || 'Error occurred during fetch request.';
+      throw new Error(message);
+    }
+  }
+}
+
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getCustomizationModule.tsx
 
 
 
+
+
 /**
  *
  * Note: this is an example of how the customization module can be used
@@ -5768,7 +6733,11 @@ function DataSourceSelector() {
  * custom page for the user to view their profile, or to add a custom
  * page for login etc.
  */
-function getCustomizationModule() {
+function getCustomizationModule(_ref) {
+  let {
+    servicesManager,
+    extensionManager
+  } = _ref;
   return [{
     name: 'helloPage',
     value: {
@@ -5835,12 +6804,16 @@ function getCustomizationModule() {
     {
       id: 'ohif.overlayItem',
       content: function (props) {
-        if (this.condition && !this.condition(props)) return null;
+        if (this.condition && !this.condition(props)) {
+          return null;
+        }
         const {
           instance
         } = props;
         const value = instance && this.attribute ? instance[this.attribute] : this.contentF && typeof this.contentF === 'function' ? this.contentF(props) : null;
-        if (!value) return null;
+        if (!value) {
+          return null;
+        }
         return /*#__PURE__*/react.createElement("span", {
           className: "overlay-item flex flex-row",
           style: {
@@ -5878,11 +6851,22 @@ function getCustomizationModule() {
         }
         return clonedObject;
       }
+    }, {
+      // the generic GUI component to configure a data source using an instance of a BaseDataSourceConfigurationAPI
+      id: 'ohif.dataSourceConfigurationComponent',
+      component: Components_DataSourceConfigurationComponent.bind(null, {
+        servicesManager,
+        extensionManager
+      })
+    }, {
+      // The factory for creating an instance of a BaseDataSourceConfigurationAPI for Google Cloud Healthcare
+      id: 'ohif.dataSourceConfigurationAPI.google',
+      factory: dataSourceName => new GoogleCloudDataSourceConfigurationAPI(dataSourceName, servicesManager, extensionManager)
     }]
   }];
 }
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/calculate-suv/dist/calculate-suv.esm.js
-var calculate_suv_esm = __webpack_require__(71251);
+var calculate_suv_esm = __webpack_require__(15747);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getPTImageIdInstanceMetadata.ts
 
 const getPTImageIdInstanceMetadata_metadataProvider = src["default"].classes.MetadataProvider;
@@ -5891,9 +6875,12 @@ function getPTImageIdInstanceMetadata(imageId) {
   if (!dicomMetaData) {
     throw new Error('dicom metadata are required');
   }
-  if (dicomMetaData.SeriesDate === undefined || dicomMetaData.SeriesTime === undefined || dicomMetaData.PatientWeight === undefined || dicomMetaData.CorrectedImage === undefined || dicomMetaData.Units === undefined || !dicomMetaData.RadiopharmaceuticalInformationSequence || dicomMetaData.RadiopharmaceuticalInformationSequence[0].RadionuclideHalfLife === undefined || dicomMetaData.RadiopharmaceuticalInformationSequence[0].RadionuclideTotalDose === undefined || dicomMetaData.DecayCorrection === undefined || dicomMetaData.AcquisitionDate === undefined || dicomMetaData.AcquisitionTime === undefined || dicomMetaData.RadiopharmaceuticalInformationSequence[0].RadiopharmaceuticalStartDateTime === undefined && dicomMetaData.RadiopharmaceuticalInformationSequence[0].RadiopharmaceuticalStartTime === undefined) {
+  if (dicomMetaData.SeriesDate === undefined || dicomMetaData.SeriesTime === undefined || dicomMetaData.CorrectedImage === undefined || dicomMetaData.Units === undefined || !dicomMetaData.RadiopharmaceuticalInformationSequence || dicomMetaData.RadiopharmaceuticalInformationSequence[0].RadionuclideHalfLife === undefined || dicomMetaData.RadiopharmaceuticalInformationSequence[0].RadionuclideTotalDose === undefined || dicomMetaData.DecayCorrection === undefined || dicomMetaData.AcquisitionDate === undefined || dicomMetaData.AcquisitionTime === undefined || dicomMetaData.RadiopharmaceuticalInformationSequence[0].RadiopharmaceuticalStartDateTime === undefined && dicomMetaData.RadiopharmaceuticalInformationSequence[0].RadiopharmaceuticalStartTime === undefined) {
     throw new Error('required metadata are missing');
   }
+  if (dicomMetaData.PatientWeight === undefined) {
+    console.warn('PatientWeight missing from PT instance metadata');
+  }
   const instanceMetadata = {
     CorrectedImage: dicomMetaData.CorrectedImage,
     Units: dicomMetaData.Units,