@3cr/viewer-browser 0.0.248 → 0.0.292

package/src/services/__tests__/viewer-3cr.service.spec.ts

@@ -1,8 +1,7 @@
-import { emptyPayload, Viewer3crService } from '@/services/viewer-3cr.service';
 import { unref } from 'vue';
 import {
-  AnchorPoint,
   DataOverlaysActions,
+  FileManagementActions,
   FrontEndInterfaces,
   InteractivityActions,
   LayoutActions,
@@ -12,20 +11,23 @@ import {
   PresetsActions,
   ScanMovementActions,
   ScanOrientationActions,
-  ScanView,
-  SlidersActions
+  SlidersActions,
+  ViewSelectionActions
 } from '@3cr/types-ts';
 import { currentColourPreset, previousLayout, transactionStarted } from '@/models/scanState';
 import { useViewer3cr } from '@/composables/useViewer3cr';
-import { MockInstance } from 'vitest';
+import { Viewer3crServiceImpl } from '@/services/viewer-3cr.service';
+import { executePayload } from '@3cr/sdk-browser';
+import { flushPromises } from '@vue/test-utils';
+import { Mock, MockInstance } from '@vitest/spy';
 
 describe('Viewer3cr tests', () => {
-  const viewer3cr = useViewer3cr();
+  const viewer3cr = useViewer3cr() as Viewer3crServiceImpl;
 
   let sendPayload: MockInstance;
 
   beforeEach(() => {
-    sendPayload = vi.spyOn(Viewer3crService.prototype, 'sendPayload').mockResolvedValue();
+    sendPayload = vi.spyOn(viewer3cr, 'sendPayload').mockResolvedValue();
   });
 
   it('should create instance', () => {
@@ -34,37 +36,151 @@ describe('Viewer3cr tests', () => {
 
   describe('data overlay actions', () => {
     it('should toggle 2d annotation', async () => {
-      const value = { Id: 'test', Visibility: true };
-      await viewer3cr.toggle2dAnnotation(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.data_overlay, DataOverlaysActions.do03, {
-        Version: expect.any(String),
-        Id: 'test',
-        Visibility: true
-      });
+      await viewer3cr.setAnnotation2dVisibility({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.data_overlay,
+        DataOverlaysActions.do03,
+        expect.any(Object)
+      );
+    });
+
+    it('should set size 2d annotation', async () => {
+      await viewer3cr.setAnnotation2dSize({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.data_overlay,
+        DataOverlaysActions.do04,
+        expect.any(Object)
+      );
+    });
+
+    it('should set colour 2d annotation', async () => {
+      await viewer3cr.setAnnotation2dColour({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.data_overlay,
+        DataOverlaysActions.do05,
+        expect.any(Object)
+      );
+    });
+
+    it('should set Icon annotation', async () => {
+      await viewer3cr.setAnnotationIcon({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.data_overlay,
+        DataOverlaysActions.do06,
+        expect.any(Object)
+      );
+    });
+
+    it('should set size 3d annotation', async () => {
+      await viewer3cr.setAnnotation3dSize({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.data_overlay,
+        DataOverlaysActions.do08,
+        expect.any(Object)
+      );
+    });
+
+    it('should set size 3d annotation', async () => {
+      await viewer3cr.setAnnotation3dColour({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.data_overlay,
+        DataOverlaysActions.do09,
+        expect.any(Object)
+      );
     });
 
     it('should toggle 3d annotation', async () => {
-      const value = { Id: 'test', Visibility: true };
-      await viewer3cr.toggle3dAnnotation(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.data_overlay, DataOverlaysActions.do11, {
-        Version: expect.any(String),
-        Id: 'test',
-        Visibility: true
-      });
+      await viewer3cr.setAnnotation3dVisibility({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.data_overlay,
+        DataOverlaysActions.do11,
+        expect.any(Object)
+      );
     });
   });
 
   describe('interactivity actions', () => {
+    it('should set mouse input', async () => {
+      await viewer3cr.setMouseInput({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.interactivity,
+        InteractivityActions.in01,
+        expect.any(Object)
+      );
+    });
+
     it('should enable/disable unity inputs', async () => {
-      await viewer3cr.hoverOverCanvas(true);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.interactivity, InteractivityActions.in01, {
-        Version: expect.any(String),
-        Value: true
-      });
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.interactivity, InteractivityActions.in02, {
-        Version: expect.any(String),
-        Value: true
-      });
+      await viewer3cr.setKeyboardInput({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.interactivity,
+        InteractivityActions.in02,
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('file management actions', () => {
+    it('should set loadScan', async () => {
+      await viewer3cr.loadScan({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.file_management,
+        FileManagementActions.fm01,
+        expect.any(Object)
+      );
+    });
+
+    it('should set loadScanSession', async () => {
+      await viewer3cr.loadScanSession({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.file_management,
+        FileManagementActions.fm03,
+        expect.any(Object)
+      );
+    });
+
+    it('should set setDataOverlaySession', async () => {
+      await viewer3cr.setDataOverlaySession({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.file_management,
+        FileManagementActions.fm05,
+        expect.any(Object)
+      );
+    });
+
+    it('should set addDataOverlaySession', async () => {
+      await viewer3cr.addDataOverlaySession({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.file_management,
+        FileManagementActions.fm06,
+        expect.any(Object)
+      );
+    });
+
+    it('should set loadExternalMcadObject', async () => {
+      await viewer3cr.loadExternalMcadObject({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.file_management,
+        FileManagementActions.fm07,
+        expect.any(Object)
+      );
+    });
+
+    it('should set loadExternalMcadObject', async () => {
+      await viewer3cr.loadLocalMcadObject({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.file_management,
+        FileManagementActions.fm08,
+        expect.any(Object)
+      );
+    });
+
+    it('should set loadMcadObjects', async () => {
+      await viewer3cr.loadMcadObjects({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.file_management,
+        FileManagementActions.fm09,
+        expect.any(Object)
+      );
     });
   });
 
@@ -77,7 +193,7 @@ describe('Viewer3cr tests', () => {
       const action = LayoutActions.lo01;
       expect(sendPayload).not.toHaveBeenCalled();
       await viewer3cr.layouts(action);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.layout, action, emptyPayload);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.layout, action, expect.any(Object));
     });
 
     it('should set prevLayout', async () => {
@@ -86,145 +202,209 @@ describe('Viewer3cr tests', () => {
       expect(unref(previousLayout)).not.toBe(LayoutActions.lo02);
       await viewer3cr.layouts(action);
       expect(unref(previousLayout)).toBe(LayoutActions.lo02);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.layout, action, emptyPayload);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.layout, action, expect.any(Object));
     });
   });
 
   describe('mcad actions', () => {
     it('should set mcad object visibility', async () => {
-      const value = { Version: '1.2.0', Id: 'test', Visibility: true };
-      await viewer3cr.setMcadObjectVisibility(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc03, value);
+      await viewer3cr.setMcadObjectVisibility({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc03, expect.any(Object));
     });
 
     it('should set mcad object colour', async () => {
-      const value = { Version: '1.2.0', Id: 'test', Colour: { Version: '1.2.0', R: 0, G: 0, B: 0, A: 0 } };
-      await viewer3cr.setMcadObjectColour(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc04, value);
+      await viewer3cr.setMcadObjectColour({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc04, expect.any(Object));
     });
 
     it('should toggle mcad object movement', async () => {
-      const value = { Version: '1.2.0', Id: 'test', Value: true };
-      await viewer3cr.moveMcadObject(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc05, value);
+      await viewer3cr.moveMcadObject({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc05, expect.any(Object));
+    });
+
+    it('should toggle rotateMcadObject', async () => {
+      await viewer3cr.rotateMcadObject({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc06, expect.any(Object));
+    });
+
+    it('should toggle lockMcad', async () => {
+      await viewer3cr.lockMcad({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc09, expect.any(Object));
+    });
+
+    it('should toggle groupMcad', async () => {
+      await viewer3cr.groupMcad({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc10, expect.any(Object));
+    });
+
+    it('should toggle ungroupMcad', async () => {
+      await viewer3cr.ungroupMcad({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc11, expect.any(Object));
     });
 
     it('should toggle mcad inversion', async () => {
-      const value = {
-        Version: '1.2.0',
-        Id: 'test',
-        Inverted: { Version: '1.2.0', InvertedSagittal: true, InvertedCoronal: true, InvertedTransverse: true }
-      };
-      await viewer3cr.invertMcadObject(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc16, value);
+      await viewer3cr.invertMcadObject({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc16, expect.any(Object));
+    });
+
+    it('should toggle removeMcadObject', async () => {
+      await viewer3cr.removeMcadObject({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc17, expect.any(Object));
+    });
+
+    it('should toggle setMcadObjectTitle', async () => {
+      await viewer3cr.setMcadObjectTitle({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.mcad, McadActions.mc18, expect.any(Object));
     });
   });
 
-  describe('markup actions', () => {
-    it('should set markup visibility', async () => {
-      const value = { Version: '1.2.1', Id: 'test', Visibility2d: false, Visibility3d: false };
-      await viewer3cr.setMarkupVisibility(value.Id, value.Visibility2d);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu16, [value]);
+  describe('measurement actions', () => {
+    it('should set createAnnotation2dTool', async () => {
+      await viewer3cr.createAnnotation2dTool({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu01, expect.any(Object));
+    });
+
+    it('should set createAnnotation3dTool', async () => {
+      await viewer3cr.createAnnotation3dTool({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu02, expect.any(Object));
+    });
+
+    it('should set createAnnotation', async () => {
+      await viewer3cr.createAnnotation({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu03, expect.any(Object));
+    });
+
+    it('should set moveAnnotation2dTool', async () => {
+      await viewer3cr.moveAnnotation2dTool({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu04, expect.any(Object));
+    });
+
+    it('should set moveAnnotation3dTool', async () => {
+      await viewer3cr.moveAnnotation3dTool({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu05, expect.any(Object));
+    });
+
+    it('should set moveAnnotation', async () => {
+      await viewer3cr.moveAnnotation({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu06, expect.any(Object));
+    });
+
+    it('should set removeAnnotation', async () => {
+      await viewer3cr.removeAnnotation({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu07, expect.any(Object));
+    });
+
+    it('should set updateAnnotationTitle', async () => {
+      await viewer3cr.updateAnnotationTitle({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu08, expect.any(Object));
+    });
+
+    it('should set updateAnnotationDescription', async () => {
+      await viewer3cr.updateAnnotationDescription({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu09, expect.any(Object));
+    });
+
+    it('should set updateAnnotationActions', async () => {
+      await viewer3cr.updateAnnotationActions({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu10, expect.any(Object));
+    });
+
+    it('should set measurement visibility', async () => {
+      await viewer3cr.setMeasurementVisibility({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu16, expect.any(Object));
     });
 
     it('should toggle length tool', async () => {
-      const value = { Version: '1.2.0', Value: true };
-      await viewer3cr.lengthTool(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu20, value);
+      await viewer3cr.lengthTool({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu20, expect.any(Object));
     });
 
     it('should toggle polygon tool', async () => {
-      const value = { Version: '1.2.0', Value: true };
-      await viewer3cr.polygonTool(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu21, value);
+      await viewer3cr.polygonTool({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu21, expect.any(Object));
     });
 
     it('should toggle angle tool', async () => {
-      const value = { Version: '1.2.0', Value: true };
-      await viewer3cr.angleTool(value);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu22, value);
+      await viewer3cr.angleTool({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.markups, MarkupsActions.mu22, expect.any(Object));
     });
   });
 
   describe('navigation actions', () => {
     it('should set nav cube position', async () => {
-      await viewer3cr.setNavCubePositionSize(AnchorPoint.TOP_LEFT, 10, 10, 100, 100);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.navigation_cube, NavigationCubeActions.nc01, {
-        Version: expect.any(String),
-        AnchorPoint: AnchorPoint.TOP_LEFT,
-        Position: { Version: expect.any(String), X: 10, Y: 10 },
-        Size: { Version: expect.any(String), X: 100, Y: 100 }
-      });
+      await viewer3cr.setNavCubePositionSize({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.navigation_cube,
+        NavigationCubeActions.nc01,
+        expect.any(Object)
+      );
     });
 
     it('should set nav cube visibility', async () => {
-      await viewer3cr.setNavCubeVisibility(true);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.navigation_cube, NavigationCubeActions.nc02, {
-        Version: expect.any(String),
-        Value: true
-      });
+      await viewer3cr.setNavCubeVisibility({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.navigation_cube,
+        NavigationCubeActions.nc02,
+        expect.any(Object)
+      );
     });
 
     it('should set nav cube interactivity', async () => {
-      await viewer3cr.setNavCubeInteractivity(true);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.navigation_cube, NavigationCubeActions.nc03, {
-        Version: expect.any(String),
-        Value: true
-      });
-    });
-
-    it('should set nav cube perspective', async () => {
-      await viewer3cr.setNavCubePerspective(true);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.navigation_cube, NavigationCubeActions.nc04, {
-        Version: expect.any(String),
-        Value: true
-      });
+      await viewer3cr.setNavCubeInteractivity({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.navigation_cube,
+        NavigationCubeActions.nc03,
+        expect.any(Object)
+      );
     });
 
     it('should set nav cube colour/opacity', async () => {
-      const colour = { R: 100, G: 200, B: 50, A: 180 };
-      await viewer3cr.setNavCubeColourOpacity(colour.R, colour.G, colour.B, colour.A);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.navigation_cube, NavigationCubeActions.nc05, {
-        Version: expect.any(String),
-        R: colour.R / 255,
-        G: colour.G / 255,
-        B: colour.B / 255,
-        A: colour.A / 255
-      });
+      await viewer3cr.setNavCubeColourOpacity({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.navigation_cube,
+        NavigationCubeActions.nc05,
+        expect.any(Object)
+      );
     });
 
     it('should set nav cube highlight colour/opacity', async () => {
-      const colour = { R: 100, G: 200, B: 50, A: 180 };
-      await viewer3cr.setNavCubeHighlightColourOpacity(colour.R, colour.G, colour.B, colour.A);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.navigation_cube, NavigationCubeActions.nc07, {
-        Version: expect.any(String),
-        R: colour.R / 255,
-        G: colour.G / 255,
-        B: colour.B / 255,
-        A: colour.A / 255
-      });
+      await viewer3cr.setNavCubeHighlightColourOpacity({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.navigation_cube,
+        NavigationCubeActions.nc07,
+        expect.any(Object)
+      );
+    });
+
+    it('should set nav cube setNavCubeGraphics', async () => {
+      await viewer3cr.setNavCubeGraphics({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.navigation_cube,
+        NavigationCubeActions.nc08,
+        expect.any(Object)
+      );
     });
   });
 
   describe('preset actions', () => {
     it('should set setPreset', async () => {
       const action = PresetsActions.pr01;
-      const data = { asd: '123' };
+      const data = { asd: '123' } as any;
       expect(sendPayload).not.toHaveBeenCalled();
       expect(unref(currentColourPreset)).not.toBe(data);
       await viewer3cr.setPreset(action, data);
       expect(unref(currentColourPreset)).not.toBe(data);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.presets, action, data);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.presets, action, { message: data });
     });
 
     it('should set setPreset change colour', async () => {
       const action = PresetsActions.pr02;
-      const data = { asd: '123' };
+      const data = { asd: '123' } as any;
       expect(sendPayload).not.toHaveBeenCalled();
       expect(unref(currentColourPreset)).not.toBe(data);
       await viewer3cr.setPreset(action, data);
       expect(unref(currentColourPreset)).toStrictEqual(data);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.presets, action, data);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.presets, action, { message: data });
     });
   });
 
@@ -235,8 +415,10 @@ describe('Viewer3cr tests', () => {
       expect(sendPayload).not.toHaveBeenCalled();
       await viewer3cr.scanMovementHandler(action, value);
       expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, action, {
-        Version: expect.any(String),
-        Value: value
+        message: {
+          Version: expect.any(String),
+          Value: value
+        }
       });
     });
 
@@ -247,117 +429,133 @@ describe('Viewer3cr tests', () => {
       expect(sendPayload).not.toHaveBeenCalled();
       await viewer3cr.scanMovementHandler(action, value);
       expect(sendPayload).not.toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, action, {
-        Version: expect.any(String),
-        Value: value
+        message: {
+          Version: expect.any(String),
+          Value: value
+        }
       });
     });
 
     it('should pan left', async () => {
-      const view = ScanView.Volume;
-      const movement = 10;
-      await viewer3cr.panLeft(view, movement);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, ScanMovementActions.sm13, {
-        Version: expect.any(String),
-        View: view,
-        Movement: movement
-      });
+      await viewer3cr.panLeft({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_movement,
+        ScanMovementActions.sm13,
+        expect.any(Object)
+      );
     });
 
     it('should pan right', async () => {
-      const view = ScanView.Volume;
-      const movement = 10;
-      await viewer3cr.panRight(view, movement);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, ScanMovementActions.sm14, {
-        Version: expect.any(String),
-        View: view,
-        Movement: movement
-      });
+      await viewer3cr.panRight({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_movement,
+        ScanMovementActions.sm14,
+        expect.any(Object)
+      );
     });
 
     it('should pan up', async () => {
-      const view = ScanView.Volume;
-      const movement = 10;
-      await viewer3cr.panUp(view, movement);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, ScanMovementActions.sm15, {
-        Version: expect.any(String),
-        View: view,
-        Movement: movement
-      });
+      await viewer3cr.panUp({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_movement,
+        ScanMovementActions.sm15,
+        expect.any(Object)
+      );
     });
 
     it('should pan down', async () => {
-      const view = ScanView.Volume;
-      const movement = 10;
-      await viewer3cr.panDown(view, movement);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, ScanMovementActions.sm16, {
-        Version: expect.any(String),
-        View: view,
-        Movement: movement
-      });
+      await viewer3cr.panDown({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_movement,
+        ScanMovementActions.sm16,
+        expect.any(Object)
+      );
     });
 
     it('should zoom in', async () => {
-      const view = ScanView.Volume;
-      const movement = 10;
-      await viewer3cr.zoomIn(view, movement);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, ScanMovementActions.sm17, {
-        Version: expect.any(String),
-        View: view,
-        Movement: movement
-      });
+      await viewer3cr.zoomIn({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_movement,
+        ScanMovementActions.sm17,
+        expect.any(Object)
+      );
     });
 
     it('should zoom out', async () => {
-      const view = ScanView.Volume;
-      const movement = 10;
-      await viewer3cr.zoomOut(view, movement);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, ScanMovementActions.sm18, {
-        Version: expect.any(String),
-        View: view,
-        Movement: movement
-      });
+      await viewer3cr.zoomOut({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_movement,
+        ScanMovementActions.sm18,
+        expect.any(Object)
+      );
+    });
+
+    it('should pan', async () => {
+      await viewer3cr.pan({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_movement,
+        ScanMovementActions.sm26,
+        expect.any(Object)
+      );
     });
   });
 
   describe('scan orientation actions', () => {
     it('should rotateByDeg', async () => {
-      const view = ScanView.Coronal;
-      const deg = 100;
-      expect(sendPayload).not.toHaveBeenCalled();
-      await viewer3cr.rotateByDeg(view, deg);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_orientation, ScanOrientationActions.so01, {
-        Version: expect.any(String),
-        View: view,
-        Angle: deg
-      });
+      await viewer3cr.rotateByDeg({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_orientation,
+        ScanOrientationActions.so01,
+        expect.any(Object)
+      );
     });
 
     it('should flip 2d view horizontally', async () => {
-      await viewer3cr.flipHorizontally(ScanView.Sagittal, true);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_orientation, ScanOrientationActions.so02, {
-        Version: expect.any(String),
-        View: ScanView.Sagittal,
-        Flipped: true
-      });
+      await viewer3cr.flipHorizontally({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_orientation,
+        ScanOrientationActions.so02,
+        expect.any(Object)
+      );
     });
 
     it('should flip 2d view vertically', async () => {
-      await viewer3cr.flipVertically(ScanView.Sagittal, true);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_orientation, ScanOrientationActions.so03, {
-        Version: expect.any(String),
-        View: ScanView.Sagittal,
-        Flipped: true
-      });
+      await viewer3cr.flipVertically({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_orientation,
+        ScanOrientationActions.so03,
+        expect.any(Object)
+      );
     });
 
     it('should invert transform', async () => {
-      await viewer3cr.invertTransform(true, true, true);
-      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_orientation, ScanOrientationActions.so04, {
-        Version: expect.any(String),
-        InvertedSagittal: true,
-        InvertedCoronal: true,
-        InvertedTransverse: true
+      await viewer3cr.invertTransform({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.scan_orientation,
+        ScanOrientationActions.so04,
+        expect.any(Object)
+      );
+    });
+  });
+  describe('view selection actions', () => {
+    for (const action of Object.keys(ViewSelectionActions)) {
+      it('should viewSelection', async () => {
+        expect(sendPayload).not.toHaveBeenCalled();
+        await viewer3cr.viewSelection(action as ViewSelectionActions);
+        expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.view_selection, action, {
+          message: {
+            Version: expect.any(String)
+          }
+        });
       });
+    }
+    it('should viewSelectionToggleView', async () => {
+      await viewer3cr.viewSelectionToggleView({} as any);
+      expect(sendPayload).toHaveBeenCalledWith(
+        FrontEndInterfaces.view_selection,
+        ViewSelectionActions.vs07,
+        expect.any(Object)
+      );
     });
   });
 
@@ -372,8 +570,10 @@ describe('Viewer3cr tests', () => {
       expect(sendPayload).not.toHaveBeenCalled();
       await viewer3cr.sliderHandler(action, value);
       expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.sliders, action, {
-        Version: expect.any(String),
-        Value: value
+        message: {
+          Version: expect.any(String),
+          Value: value
+        }
       });
     });
 
@@ -384,9 +584,233 @@ describe('Viewer3cr tests', () => {
       expect(sendPayload).not.toHaveBeenCalled();
       await viewer3cr.sliderHandler(action, value);
       expect(sendPayload).not.toHaveBeenCalledWith(FrontEndInterfaces.sliders, action, {
-        Version: expect.any(String),
-        Value: value
+        message: {
+          Version: expect.any(String),
+          Value: value
+        }
       });
     });
   });
 });
+
+describe('Viewer3CR payloads', () => {
+  const viewer3cr = new Viewer3crServiceImpl();
+  const execMockRef = executePayload as Mock<typeof executePayload>;
+
+  beforeEach(() => {
+    execMockRef.mockClear();
+    execMockRef.mockResolvedValue();
+  });
+
+  it('should sendPayload', async () => {
+    const iface = FrontEndInterfaces.sliders;
+    const action = SlidersActions.sl08;
+
+    await viewer3cr.sendPayload(iface, action, {} as any);
+
+    await flushPromises();
+    expect(execMockRef).toHaveBeenCalledWith({
+      Version: '0.0.1',
+      Interface: iface,
+      Action: action,
+      Message: expect.toBeTypeOrNull(String),
+      ReturnChannel: expect.toBeTypeOrNull(String),
+      ReturnTo: expect.toBeTypeOrNull(String)
+    });
+  });
+
+  it('should sendPayload with message JSON', async () => {
+    const iface = FrontEndInterfaces.sliders;
+    const action = SlidersActions.sl08;
+
+    const messageJSON = {
+      Value: '123'
+    };
+    await viewer3cr.sendPayload(iface, action, {
+      message: messageJSON
+    } as any);
+
+    await flushPromises();
+    expect(execMockRef).toHaveBeenCalledWith({
+      Version: '0.0.1',
+      Interface: iface,
+      Action: action,
+      Message: JSON.stringify(messageJSON),
+      ReturnChannel: expect.toBeTypeOrNull(String),
+      ReturnTo: expect.toBeTypeOrNull(String)
+    });
+  });
+
+  it('should sendPayload with returnChannel JSON', async () => {
+    const iface = FrontEndInterfaces.sliders;
+    const action = SlidersActions.sl08;
+
+    const returnChannelJSON = {
+      Value: '123'
+    };
+    await viewer3cr.sendPayload(iface, action, {
+      returnChannel: returnChannelJSON
+    } as any);
+
+    await flushPromises();
+    expect(execMockRef).toHaveBeenCalledWith({
+      Version: '0.0.1',
+      Interface: iface,
+      Action: action,
+      Message: expect.toBeTypeOrNull(String),
+      ReturnChannel: JSON.stringify(returnChannelJSON),
+      ReturnTo: expect.toBeTypeOrNull(String)
+    });
+  });
+});
+describe('Viewer3CR callbacks', () => {
+  let viewer3cr = new Viewer3crServiceImpl();
+  const execMockRef = executePayload as Mock<typeof executePayload>;
+  const interfaceCallback = vi.fn();
+  const actionCallback = vi.fn();
+
+  beforeEach(() => {
+    execMockRef.mockClear();
+    execMockRef.mockResolvedValue();
+    interfaceCallback.mockClear();
+    actionCallback.mockClear();
+    viewer3cr = new Viewer3crServiceImpl();
+  });
+
+  for (const iface of Object.keys(FrontEndInterfaces)) {
+    it(`should call interface callbacks onPayload [${iface}]`, async () => {
+      const ifaceTyped: FrontEndInterfaces = iface as FrontEndInterfaces;
+      const action = SlidersActions.sl08;
+
+      viewer3cr.addInterfaceHandler(ifaceTyped, interfaceCallback);
+
+      const payload = {
+        Version: '0.0.1',
+        Interface: ifaceTyped,
+        Action: action,
+        Message: null,
+        ReturnChannel: null,
+        ReturnTo: null
+      };
+      await viewer3cr.onPayload(payload);
+
+      await flushPromises();
+      expect(interfaceCallback).toHaveBeenCalledWith(
+        expect.toBeTypeOrNull(String),
+        action,
+        expect.toBeTypeOrNull(String),
+        expect.toBeTypeOrNull(String)
+      );
+    });
+    it(`should call interface callbacks onPayload [${iface}] and not on removal`, async () => {
+      const ifaceTyped: FrontEndInterfaces = iface as FrontEndInterfaces;
+      const action = SlidersActions.sl08;
+
+      viewer3cr.addInterfaceHandler(ifaceTyped, interfaceCallback);
+
+      const payload = {
+        Version: '0.0.1',
+        Interface: ifaceTyped,
+        Action: action,
+        Message: null,
+        ReturnChannel: null,
+        ReturnTo: null
+      };
+      await viewer3cr.onPayload(payload);
+
+      await flushPromises();
+      expect(interfaceCallback).toHaveBeenCalledWith(
+        expect.toBeTypeOrNull(String),
+        action,
+        expect.toBeTypeOrNull(String),
+        expect.toBeTypeOrNull(String)
+      );
+
+      interfaceCallback.mockClear();
+
+      viewer3cr.removeInterfaceHandler(ifaceTyped, interfaceCallback);
+
+      await viewer3cr.onPayload(payload);
+
+      await flushPromises();
+      expect(interfaceCallback).not.toHaveBeenCalledWith(
+        expect.toBeTypeOrNull(String),
+        action,
+        expect.toBeTypeOrNull(String),
+        expect.toBeTypeOrNull(String)
+      );
+    });
+  }
+
+  for (const actionSet of [
+    DataOverlaysActions,
+    FileManagementActions,
+    InteractivityActions,
+    LayoutActions,
+    MarkupsActions,
+    McadActions,
+    NavigationCubeActions,
+    PresetsActions,
+    ScanMovementActions,
+    ScanOrientationActions,
+    SlidersActions,
+    ViewSelectionActions
+  ]) {
+    for (const action of Object.keys(actionSet)) {
+      const ifaceTyped: FrontEndInterfaces = FrontEndInterfaces.file_management;
+      it(`should call action callbacks onPayload [${action}]`, async () => {
+        viewer3cr.addActionHandler(action, actionCallback);
+
+        const payload = {
+          Version: '0.0.1',
+          Interface: ifaceTyped,
+          Action: action,
+          Message: null,
+          ReturnChannel: null,
+          ReturnTo: null
+        };
+        await viewer3cr.onPayload(payload);
+
+        await flushPromises();
+        expect(actionCallback).toHaveBeenCalledWith(
+          expect.toBeTypeOrNull(String),
+          expect.toBeTypeOrNull(String),
+          expect.toBeTypeOrNull(String)
+        );
+      });
+      it(`should call action callbacks onPayload [${action}] and not on removal`, async () => {
+        viewer3cr.addActionHandler(action, actionCallback);
+
+        const payload = {
+          Version: '0.0.1',
+          Interface: ifaceTyped,
+          Action: action,
+          Message: null,
+          ReturnChannel: null,
+          ReturnTo: null
+        };
+        await viewer3cr.onPayload(payload);
+
+        await flushPromises();
+        expect(actionCallback).toHaveBeenCalledWith(
+          expect.toBeTypeOrNull(String),
+          expect.toBeTypeOrNull(String),
+          expect.toBeTypeOrNull(String)
+        );
+
+        actionCallback.mockClear();
+
+        viewer3cr.removeActionHandler(action, actionCallback);
+
+        await viewer3cr.onPayload(payload);
+
+        await flushPromises();
+        expect(actionCallback).not.toHaveBeenCalledWith(
+          expect.toBeTypeOrNull(String),
+          expect.toBeTypeOrNull(String),
+          expect.toBeTypeOrNull(String)
+        );
+      });
+    }
+  }
+});