fix(typescript): rename services to fix typescript (#3165)

* fix: Rename services to lower camel case, hp, measure

* fix: Rename DisplaySetService instances to displaySetService

* fix: Rename CornerstoneViewportService to lower camel case

* fix: Added lower case segmentationService rename

* rename other services (#3166)

* rename uiDialogService

* rename toolGroupService

* rename uiNotificationService

* rename viewportGridService

* rename syncGroupService

* rename CornerstoneCacheService

* Fix a syntax error in hotkeys

* Fix a couple of rename issues that were missed

---------

Co-authored-by: Alireza <ar.sedghi@gmail.com>

extensions/cornerstone-dicom-seg/src/getSopClassHandlerModule.js

@@ -71,8 +71,8 @@ function _getDisplaySetsFromSeries(
   displaySet.referencedSeriesInstanceUID = referencedSeries.SeriesInstanceUID;
 
   displaySet.getReferenceDisplaySet = () => {
-    const { DisplaySetService } = servicesManager.services;
-    const referencedDisplaySets = DisplaySetService.getDisplaySetsForSeries(
+    const { displaySetService } = servicesManager.services;
+    const referencedDisplaySets = displaySetService.getDisplaySetsForSeries(
       displaySet.referencedSeriesInstanceUID
     );
 
@@ -113,9 +113,9 @@ function _load(segDisplaySet, servicesManager, extensionManager, headers) {
   // We don't want to fire multiple loads, so we'll wait for the first to finish
   // and also return the same promise to any other callers.
   loadPromises[SOPInstanceUID] = new Promise(async (resolve, reject) => {
-    const { SegmentationService } = servicesManager.services;
+    const { segmentationService } = servicesManager.services;
 
-    if (_segmentationExistsInCache(segDisplaySet, SegmentationService)) {
+    if (_segmentationExistsInCache(segDisplaySet, segmentationService)) {
       return;
     }
 
@@ -133,7 +133,7 @@ function _load(segDisplaySet, servicesManager, extensionManager, headers) {
     }
 
     const suppressEvents = true;
-    SegmentationService.createSegmentationForSEGDisplaySet(
+    segmentationService.createSegmentationForSEGDisplaySet(
       segDisplaySet,
       null,
       suppressEvents
@@ -175,10 +175,10 @@ async function _loadSegments(extensionManager, segDisplaySet, headers) {
   return segments;
 }
 
-function _segmentationExistsInCache(segDisplaySet, SegmentationService) {
+function _segmentationExistsInCache(segDisplaySet, segmentationService) {
   // This should be abstracted with the CornerstoneCacheService
   const labelmapVolumeId = segDisplaySet.displaySetInstanceUID;
-  const segVolume = SegmentationService.getLabelmapVolume(labelmapVolumeId);
+  const segVolume = segmentationService.getLabelmapVolume(labelmapVolumeId);
 
   return segVolume !== undefined;
 }

extensions/cornerstone-dicom-seg/src/panels/PanelSegmentation.tsx

@@ -11,11 +11,11 @@ export default function PanelSegmentation({
   commandsManager,
 }) {
   const {
-    SegmentationService,
-    UIDialogService,
-    ViewportGridService,
-    ToolGroupService,
-    CornerstoneViewportService,
+    segmentationService,
+    uiDialogService,
+    viewportGridService,
+    toolGroupService,
+    cornerstoneViewportService,
   } = servicesManager.services;
 
   const { t } = useTranslation('PanelSegmentation');
@@ -23,10 +23,10 @@ export default function PanelSegmentation({
   const [
     initialSegmentationConfigurations,
     setInitialSegmentationConfigurations,
-  ] = useState(SegmentationService.getConfiguration());
+  ] = useState(segmentationService.getConfiguration());
 
   const [segmentations, setSegmentations] = useState(() =>
-    SegmentationService.getSegmentations()
+    segmentationService.getSegmentations()
   );
 
   const [isMinimized, setIsMinimized] = useState({});
@@ -54,14 +54,14 @@ export default function PanelSegmentation({
 
   useEffect(() => {
     // ~~ Subscription
-    const added = SegmentationService.EVENTS.SEGMENTATION_ADDED;
-    const updated = SegmentationService.EVENTS.SEGMENTATION_UPDATED;
-    const removed = SegmentationService.EVENTS.SEGMENTATION_REMOVED;
+    const added = segmentationService.EVENTS.SEGMENTATION_ADDED;
+    const updated = segmentationService.EVENTS.SEGMENTATION_UPDATED;
+    const removed = segmentationService.EVENTS.SEGMENTATION_REMOVED;
     const subscriptions = [];
 
     [added, updated, removed].forEach(evt => {
-      const { unsubscribe } = SegmentationService.subscribe(evt, () => {
-        const segmentations = SegmentationService.getSegmentations();
+      const { unsubscribe } = segmentationService.subscribe(evt, () => {
+        const segmentations = segmentationService.getSegmentations();
         setSegmentations(segmentations);
       });
       subscriptions.push(unsubscribe);
@@ -75,15 +75,15 @@ export default function PanelSegmentation({
   }, []);
 
   const onSegmentationClick = (segmentationId: string) => {
-    SegmentationService.setActiveSegmentationForToolGroup(segmentationId);
+    segmentationService.setActiveSegmentationForToolGroup(segmentationId);
   };
 
   const onSegmentationDelete = (segmentationId: string) => {
-    SegmentationService.remove(segmentationId);
+    segmentationService.remove(segmentationId);
   };
 
   const getToolGroupIds = segmentationId => {
-    const toolGroupIds = SegmentationService.getToolGroupIdsWithSegmentation(
+    const toolGroupIds = segmentationService.getToolGroupIdsWithSegmentation(
       segmentationId
     );
 
@@ -91,7 +91,7 @@ export default function PanelSegmentation({
   };
 
   const onSegmentClick = (segmentationId, segmentIndex) => {
-    SegmentationService.setActiveSegmentForSegmentation(
+    segmentationService.setActiveSegmentForSegmentation(
       segmentationId,
       segmentIndex
     );
@@ -100,11 +100,11 @@ export default function PanelSegmentation({
 
     toolGroupIds.forEach(toolGroupId => {
       // const toolGroupId =
-      SegmentationService.setActiveSegmentationForToolGroup(
+      segmentationService.setActiveSegmentationForToolGroup(
         segmentationId,
         toolGroupId
       );
-      SegmentationService.jumpToSegmentCenter(
+      segmentationService.jumpToSegmentCenter(
         segmentationId,
         segmentIndex,
         toolGroupId
@@ -113,17 +113,17 @@ export default function PanelSegmentation({
   };
 
   const onSegmentEdit = (segmentationId, segmentIndex) => {
-    const segmentation = SegmentationService.getSegmentation(segmentationId);
+    const segmentation = segmentationService.getSegmentation(segmentationId);
 
     const segment = segmentation.segments[segmentIndex];
     const { label } = segment;
 
-    callInputDialog(UIDialogService, label, (label, actionId) => {
+    callInputDialog(uiDialogService, label, (label, actionId) => {
       if (label === '') {
         return;
       }
 
-      SegmentationService.setSegmentLabelForSegmentation(
+      segmentationService.setSegmentLabelForSegmentation(
         segmentationId,
         segmentIndex,
         label
@@ -132,15 +132,15 @@ export default function PanelSegmentation({
   };
 
   const onSegmentationEdit = segmentationId => {
-    const segmentation = SegmentationService.getSegmentation(segmentationId);
+    const segmentation = segmentationService.getSegmentation(segmentationId);
     const { label } = segmentation;
 
-    callInputDialog(UIDialogService, label, (label, actionId) => {
+    callInputDialog(uiDialogService, label, (label, actionId) => {
       if (label === '') {
         return;
       }
 
-      SegmentationService.addOrUpdateSegmentation(
+      segmentationService.addOrUpdateSegmentation(
         {
           id: segmentationId,
           label,
@@ -157,7 +157,7 @@ export default function PanelSegmentation({
   };
 
   const onSegmentDelete = (segmentationId, segmentIndex) => {
-    // SegmentationService.removeSegmentFromSegmentation(
+    // segmentationService.removeSegmentFromSegmentation(
     //   segmentationId,
     //   segmentIndex
     // );
@@ -165,14 +165,14 @@ export default function PanelSegmentation({
   };
 
   const onToggleSegmentVisibility = (segmentationId, segmentIndex) => {
-    const segmentation = SegmentationService.getSegmentation(segmentationId);
+    const segmentation = segmentationService.getSegmentation(segmentationId);
     const segmentInfo = segmentation.segments[segmentIndex];
     const isVisible = !segmentInfo.isVisible;
     const toolGroupIds = getToolGroupIds(segmentationId);
 
     // Todo: right now we apply the visibility to all tool groups
     toolGroupIds.forEach(toolGroupId => {
-      SegmentationService.setSegmentVisibility(
+      segmentationService.setSegmentVisibility(
         segmentationId,
         segmentIndex,
         isVisible,
@@ -182,17 +182,17 @@ export default function PanelSegmentation({
   };
 
   const onToggleSegmentationVisibility = segmentationId => {
-    SegmentationService.toggleSegmentationVisibility(segmentationId);
+    segmentationService.toggleSegmentationVisibility(segmentationId);
   };
 
   const setSegmentationConfiguration = useCallback(
     (segmentationId, key, value) => {
-      SegmentationService.setConfiguration({
+      segmentationService.setConfiguration({
         segmentationId,
         [key]: value,
       });
     },
-    [SegmentationService]
+    [segmentationService]
   );
 
   return (
@@ -280,7 +280,7 @@ PanelSegmentation.propTypes = {
   }),
   servicesManager: PropTypes.shape({
     services: PropTypes.shape({
-      SegmentationService: PropTypes.shape({
+      segmentationService: PropTypes.shape({
         getSegmentation: PropTypes.func.isRequired,
         getSegmentations: PropTypes.func.isRequired,
         toggleSegmentationVisibility: PropTypes.func.isRequired,

extensions/cornerstone-dicom-seg/src/panels/callInputDialog.tsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import { Input, Dialog } from '@ohif/ui';
 
-function callInputDialog(UIDialogService, label, callback) {
+function callInputDialog(uiDialogService, label, callback) {
   const dialogId = 'enter-segment-label';
 
   const onSubmitHandler = ({ action, value }) => {
@@ -13,11 +13,11 @@ function callInputDialog(UIDialogService, label, callback) {
         callback('', action.id);
         break;
     }
-    UIDialogService.dismiss({ id: dialogId });
+    uiDialogService.dismiss({ id: dialogId });
   };
 
-  if (UIDialogService) {
-    UIDialogService.create({
+  if (uiDialogService) {
+    uiDialogService.create({
       id: dialogId,
       centralize: true,
       isDraggable: false,
@@ -27,7 +27,7 @@ function callInputDialog(UIDialogService, label, callback) {
         title: 'Enter Segment Label',
         value: { label },
         noCloseButton: true,
-        onClose: () => UIDialogService.dismiss({ id: dialogId }),
+        onClose: () => uiDialogService.dismiss({ id: dialogId }),
         actions: [
           { id: 'cancel', text: 'Cancel', type: 'primary' },
           { id: 'save', text: 'Confirm', type: 'secondary' },

extensions/cornerstone-dicom-seg/src/utils/_hydrateSEG.ts

@@ -5,9 +5,9 @@ async function _hydrateSEGDisplaySet({
   servicesManager,
 }) {
   const {
-    SegmentationService,
-    HangingProtocolService,
-    ViewportGridService,
+    segmentationService,
+    hangingProtocolService,
+    viewportGridService,
   } = servicesManager.services;
 
   const displaySetInstanceUID = segDisplaySet.referencedDisplaySetInstanceUID;
@@ -17,22 +17,22 @@ async function _hydrateSEGDisplaySet({
   // We need the hydration to notify panels about the new segmentation added
   const suppressEvents = false;
 
-  segmentationId = await SegmentationService.createSegmentationForSEGDisplaySet(
+  segmentationId = await segmentationService.createSegmentationForSEGDisplaySet(
     segDisplaySet,
     segmentationId,
     suppressEvents
   );
 
-  SegmentationService.hydrateSegmentation(segDisplaySet.displaySetInstanceUID);
+  segmentationService.hydrateSegmentation(segDisplaySet.displaySetInstanceUID);
 
-  const { viewports } = ViewportGridService.getState();
+  const { viewports } = viewportGridService.getState();
 
-  const updatedViewports = HangingProtocolService.getViewportsRequireUpdate(
+  const updatedViewports = hangingProtocolService.getViewportsRequireUpdate(
     viewportIndex,
     displaySetInstanceUID
   );
 
-  ViewportGridService.setDisplaySetsForViewports(updatedViewports);
+  viewportGridService.setDisplaySetsForViewports(updatedViewports);
 
   // Todo: fix this after we have a better way for stack viewport segmentations
 
@@ -45,13 +45,13 @@ async function _hydrateSEGDisplaySet({
       return;
     }
 
-    const shouldDisplaySeg = SegmentationService.shouldRenderSegmentation(
+    const shouldDisplaySeg = segmentationService.shouldRenderSegmentation(
       viewport.displaySetInstanceUIDs,
       segDisplaySet.displaySetInstanceUID
     );
 
     if (shouldDisplaySeg) {
-      ViewportGridService.setDisplaySetsForViewport({
+      viewportGridService.setDisplaySetsForViewport({
         viewportIndex: index,
         displaySetInstanceUIDs: viewport.displaySetInstanceUIDs,
         viewportOptions: {

extensions/cornerstone-dicom-seg/src/utils/initSEGToolGroup.ts

@@ -1,5 +1,5 @@
 function createSEGToolGroupAndAddTools(
-  ToolGroupService,
+  toolGroupService,
   toolGroupId,
   extensionManager
 ) {
@@ -28,7 +28,7 @@ function createSEGToolGroupAndAddTools(
     enabled: [{ toolName: toolNames.SegmentationDisplay }],
   };
 
-  return ToolGroupService.createToolGroupAndAddTools(toolGroupId, tools, {});
+  return toolGroupService.createToolGroupAndAddTools(toolGroupId, tools, {});
 }
 
 export default createSEGToolGroupAndAddTools;

extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx

@@ -33,10 +33,10 @@ function OHIFCornerstoneSEGViewport(props) {
   const { t } = useTranslation('SEGViewport');
 
   const {
-    DisplaySetService,
-    ToolGroupService,
-    SegmentationService,
-    UINotificationService,
+    displaySetService,
+    toolGroupService,
+    segmentationService,
+    uiNotificationService,
   } = servicesManager.services;
 
   const toolGroupId = `${SEG_TOOLGROUP_BASE_NAME}-${viewportIndex}`;
@@ -127,7 +127,7 @@ function OHIFCornerstoneSEGViewport(props) {
     direction => {
       direction = direction === 'left' ? -1 : 1;
       const segmentationId = segDisplaySet.displaySetInstanceUID;
-      const segmentation = SegmentationService.getSegmentation(segmentationId);
+      const segmentation = segmentationService.getSegmentation(segmentationId);
 
       const { segments } = segmentation;
 
@@ -141,7 +141,7 @@ function OHIFCornerstoneSEGViewport(props) {
         newSelectedSegmentIndex = numberOfSegments - 1;
       }
 
-      SegmentationService.jumpToSegmentCenter(
+      segmentationService.jumpToSegmentCenter(
         segmentationId,
         newSelectedSegmentIndex,
         toolGroupId
@@ -168,8 +168,8 @@ function OHIFCornerstoneSEGViewport(props) {
   }, [servicesManager, viewportIndex, segDisplaySet, segIsLoading]);
 
   useEffect(() => {
-    const { unsubscribe } = SegmentationService.subscribe(
-      SegmentationService.EVENTS.SEGMENTATION_PIXEL_DATA_CREATED,
+    const { unsubscribe } = segmentationService.subscribe(
+      segmentationService.EVENTS.SEGMENTATION_PIXEL_DATA_CREATED,
       evt => {
         if (
           evt.segDisplaySet.displaySetInstanceUID ===
@@ -179,7 +179,7 @@ function OHIFCornerstoneSEGViewport(props) {
         }
 
         if (evt.overlappingSegments) {
-          UINotificationService.show({
+          uiNotificationService.show({
             title: 'Overlapping Segments',
             message:
               'Overlapping segments detected which is not currently supported',
@@ -195,8 +195,8 @@ function OHIFCornerstoneSEGViewport(props) {
   }, [segDisplaySet]);
 
   useEffect(() => {
-    const { unsubscribe } = SegmentationService.subscribe(
-      SegmentationService.EVENTS.SEGMENT_PIXEL_DATA_CREATED,
+    const { unsubscribe } = segmentationService.subscribe(
+      segmentationService.EVENTS.SEGMENT_PIXEL_DATA_CREATED,
       ({ segmentIndex, numSegments }) => {
         setProcessingProgress({
           segmentIndex,
@@ -214,8 +214,8 @@ function OHIFCornerstoneSEGViewport(props) {
    Cleanup the SEG viewport when the viewport is destroyed
    */
   useEffect(() => {
-    const onDisplaySetsRemovedSubscription = DisplaySetService.subscribe(
-      DisplaySetService.EVENTS.DISPLAY_SETS_REMOVED,
+    const onDisplaySetsRemovedSubscription = displaySetService.subscribe(
+      displaySetService.EVENTS.DISPLAY_SETS_REMOVED,
       ({ displaySetInstanceUIDs }) => {
         const activeViewport = viewports[activeViewportIndex];
         if (
@@ -235,14 +235,14 @@ function OHIFCornerstoneSEGViewport(props) {
   }, []);
 
   useEffect(() => {
-    let toolGroup = ToolGroupService.getToolGroup(toolGroupId);
+    let toolGroup = toolGroupService.getToolGroup(toolGroupId);
 
     if (toolGroup) {
       return;
     }
 
     toolGroup = createSEGToolGroupAndAddTools(
-      ToolGroupService,
+      toolGroupService,
       toolGroupId,
       extensionManager
     );
@@ -251,11 +251,11 @@ function OHIFCornerstoneSEGViewport(props) {
 
     return () => {
       // remove the segmentation representations if seg displayset changed
-      SegmentationService.removeSegmentationRepresentationFromToolGroup(
+      segmentationService.removeSegmentationRepresentationFromToolGroup(
         toolGroupId
       );
 
-      ToolGroupService.destroyToolGroup(toolGroupId);
+      toolGroupService.destroyToolGroup(toolGroupId);
     };
   }, []);
 
@@ -264,7 +264,7 @@ function OHIFCornerstoneSEGViewport(props) {
 
     return () => {
       // remove the segmentation representations if seg displayset changed
-      SegmentationService.removeSegmentationRepresentationFromToolGroup(
+      segmentationService.removeSegmentationRepresentationFromToolGroup(
         toolGroupId
       );
       referencedDisplaySetRef.current = null;